code stringlengths 1 1.72M | language stringclasses 1 value |
|---|---|
from django.conf.urls.defaults import *
urlpatterns = patterns('',
(r'^wartime', include('Wartime.wartime.urls')),
(r'^wild', include('Wartime.wild.urls')),
# Uncomment this for admin:
# (r'^admin/', include('django.contrib.admin.urls')),
)
import sys
sys.path.append("H:\StuphMUD\lib\python\supplemental\implementor")
try: from fraun.supervisor import urlpatterns as supervisor_urlpatterns
except ImportError: pass
else: urlpatterns += supervisor_urlpatterns
| Python |
# Django settings for Wartime project.
DEBUG = True
TEMPLATE_DEBUG = DEBUG
ADMINS = (
# ('Your Name', 'your_email@domain.com'),
)
MANAGERS = ADMINS
DATABASE_ENGINE = 'sqlite3' # 'postgresql_psycopg2', 'postgresql', 'mysql', 'sqlite3' or 'ado_mssql'.
DATABASE_NAME = 'H:\My Projects\Wartime\wartime.db' # Or path to database file if using sqlite3.
DATABASE_USER = '' # Not used with sqlite3.
DATABASE_PASSWORD = '' # Not used with sqlite3.
DATABASE_HOST = '' # Set to empty string for localhost. Not used with sqlite3.
DATABASE_PORT = '' # Set to empty string for default. Not used with sqlite3.
# Local time zone for this installation. Choices can be found here:
# http://www.postgresql.org/docs/8.1/static/datetime-keywords.html#DATETIME-TIMEZONE-SET-TABLE
# although not all variations may be possible on all operating systems.
# If running in a Windows environment this must be set to the same as your
# system time zone.
TIME_ZONE = 'America/Chicago'
# Language code for this installation. All choices can be found here:
# http://www.w3.org/TR/REC-html40/struct/dirlang.html#langcodes
# http://blogs.law.harvard.edu/tech/stories/storyReader$15
LANGUAGE_CODE = 'en-us'
SITE_ID = 1
# If you set this to False, Django will make some optimizations so as not
# to load the internationalization machinery.
USE_I18N = True
# Absolute path to the directory that holds media.
# Example: "/home/media/media.lawrence.com/"
MEDIA_ROOT = ''
# URL that handles the media served from MEDIA_ROOT.
# Example: "http://media.lawrence.com"
MEDIA_URL = ''
# URL prefix for admin media -- CSS, JavaScript and images. Make sure to use a
# trailing slash.
# Examples: "http://foo.com/media/", "/media/".
ADMIN_MEDIA_PREFIX = '/media/'
# Make this unique, and don't share it with anybody.
SECRET_KEY = 'viv2pz*cdam6v(*_8%99rmpmjl^ub0e)5+@wbu62ywcl7e1@=5'
# List of callables that know how to import templates from various sources.
TEMPLATE_LOADERS = (
'django.template.loaders.filesystem.load_template_source',
'django.template.loaders.app_directories.load_template_source',
# 'django.template.loaders.eggs.load_template_source',
)
MIDDLEWARE_CLASSES = (
'django.middleware.common.CommonMiddleware',
'django.contrib.sessions.middleware.SessionMiddleware',
'django.contrib.auth.middleware.AuthenticationMiddleware',
'django.middleware.doc.XViewMiddleware',
)
ROOT_URLCONF = 'Wartime.urls'
TEMPLATE_DIRS = (
# Put strings here, like "/home/html/django_templates" or "C:/www/django/templates".
# Always use forward slashes, even on Windows.
# Don't forget to use absolute paths, not relative paths.
"C:\My Projects\Wartime
)
INSTALLED_APPS = (
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.sites',
'Wartime.wartime',
'Wartime.wild',
)
| Python |
#!/usr/bin/python
# Copyright 2011 Google, Inc. All Rights Reserved.
# simple script to walk source tree looking for third-party licenses
# dumps resulting html page to stdout
import os, re, mimetypes, sys
# read source directories to scan from command line
SOURCE = sys.argv[1:]
# regex to find /* */ style comment blocks
COMMENT_BLOCK = re.compile(r"(/\*.+?\*/)", re.MULTILINE | re.DOTALL)
# regex used to detect if comment block is a license
COMMENT_LICENSE = re.compile(r"(license)", re.IGNORECASE)
COMMENT_COPYRIGHT = re.compile(r"(copyright)", re.IGNORECASE)
EXCLUDE_TYPES = [
"application/xml",
"image/png",
]
# list of known licenses; keys are derived by stripping all whitespace and
# forcing to lowercase to help combine multiple files that have same license.
KNOWN_LICENSES = {}
class License:
def __init__(self, license_text):
self.license_text = license_text
self.filenames = []
# add filename to the list of files that have the same license text
def add_file(self, filename):
if filename not in self.filenames:
self.filenames.append(filename)
LICENSE_KEY = re.compile(r"[^\w]")
def find_license(license_text):
# TODO(alice): a lot these licenses are almost identical Apache licenses.
# Most of them differ in origin/modifications. Consider combining similar
# licenses.
license_key = LICENSE_KEY.sub("", license_text).lower()
if license_key not in KNOWN_LICENSES:
KNOWN_LICENSES[license_key] = License(license_text)
return KNOWN_LICENSES[license_key]
def discover_license(exact_path, filename):
# when filename ends with LICENSE, assume applies to filename prefixed
if filename.endswith("LICENSE"):
with open(exact_path) as file:
license_text = file.read()
target_filename = filename[:-len("LICENSE")]
if target_filename.endswith("."): target_filename = target_filename[:-1]
find_license(license_text).add_file(target_filename)
return None
# try searching for license blocks in raw file
mimetype = mimetypes.guess_type(filename)
if mimetype in EXCLUDE_TYPES: return None
with open(exact_path) as file:
raw_file = file.read()
# include comments that have both "license" and "copyright" in the text
for comment in COMMENT_BLOCK.finditer(raw_file):
comment = comment.group(1)
if COMMENT_LICENSE.search(comment) is None: continue
if COMMENT_COPYRIGHT.search(comment) is None: continue
find_license(comment).add_file(filename)
for source in SOURCE:
for root, dirs, files in os.walk(source):
for name in files:
discover_license(os.path.join(root, name), name)
print "<html><head><style> body { font-family: sans-serif; } pre { background-color: #eeeeee; padding: 1em; white-space: pre-wrap; } </style></head><body>"
for license in KNOWN_LICENSES.values():
print "<h3>Notices for files:</h3><ul>"
filenames = license.filenames
filenames.sort()
for filename in filenames:
print "<li>%s</li>" % (filename)
print "</ul>"
print "<pre>%s</pre>" % license.license_text
print "</body></html>"
| Python |
#!/usr/bin/python
import sys
agl = []
agltab = []
aglmap = {}
print "/*"
f = open("glyphlist.txt", "r")
for line in f.readlines():
if line[0] == '#':
print line.strip()
continue
line = line[:-1]
name, list = line.split(';')
list = map(lambda x: int(x, 16), list.split(' '))
agl.append((name, list))
for name, ucslist in agl:
num = len(ucslist)
ucs = ucslist[0]
agltab.append((name, ucs))
if ucs not in aglmap:
aglmap[ucs] = []
aglmap[ucs].append(name)
print "*/"
print
def dumplist(list):
n = 0;
for item in list:
n += len(item) + 1
if n > 78:
sys.stdout.write("\n")
n = len(item) + 1
sys.stdout.write(item)
sys.stdout.write(",")
sys.stdout.write("\n")
agltab.sort()
namelist = []
codelist = []
for name, ucs in agltab:
namelist.append("\"%s\"" % name)
codelist.append("%d" % ucs)
keys = aglmap.keys()
keys.sort()
dupoffsets = []
dupnames = []
for ucs in keys:
list = aglmap[ucs]
ofs = len(dupnames)
if len(list) > 1:
dupoffsets.append("%d,%d" % (ucs, ofs))
for name in list:
dupnames.append("\"%s\"" % name)
dupnames.append("0")
print "static const char *agl_name_list[] = {"
dumplist(namelist)
print "};"
print
print "static const unsigned short agl_code_list[] = {"
dumplist(codelist)
print "};"
print
print "static const unsigned short agl_dup_offsets[] = {"
dumplist(dupoffsets)
print "};"
print
print "static const char *agl_dup_names[] = {"
dumplist(dupnames)
print "};"
| Python |
import sys, os, re
HEADER="""<head>
<style>
body { background-color:#fffff0; color:black; margin:16pt; }
a { text-decoration:none; color:darkblue; }
a.line { position:relative; padding-top:300px; }
.comment { color:green; font-style:italic; }
.comment a { color:darkgreen; }
</style>
</head>
<body><pre><pre>"""
FOOTER="""</pre></body>"""
prefixes = [ 'fz_', 'pdf_', 'xps_', 'cbz_', 'pdfapp_' ]
def is_public(s):
for prefix in prefixes:
if s.startswith(prefix):
return True
return False
def load_tags():
tags = {}
for line in open("tags-xref").readlines():
ident, type, line, file, text = line.split(None, 4)
if not is_public(ident):
continue
if type == 'function':
tags[ident] = '<a class="function" href="%s#%s">%s</a>' % (os.path.basename(file), line, ident)
if type == 'typedef' or type == 'struct':
tags[ident] = '<a class="typedef" href="%s#%s">%s</a>' % (os.path.basename(file), line, ident)
return tags
tags = load_tags()
def quote(s):
return s.replace('&','&').replace('<','<').replace('>','>')
print HEADER
N = 1
for line in sys.stdin.readlines():
# expand tabs, html-quote special characters and colorize comments
line = line.replace('\t', ' ').rstrip()
line = quote(line)
line = line.replace("/*", '<span class="comment">/*')
line = line.replace("*/", '*/</span>')
line = re.sub('^#include "([a-z-]*\.h)"', '#include "<a href="\\1">\\1</a>"', line)
# find identifiers and hyperlink to their definitions
words = re.split("(\W+)", line)
line = ""
for word in words:
if word in tags:
word = tags[word]
line += word
#print('<a class="line" name="%d">%4d</a> %s' % (N, N, line))
print('<a class="line" name="%d"></a>%s' % (N, line))
N = N + 1
print FOOTER
| Python |
'''
Module which prompts the user for translations and saves them.
TODO: implement
@author: Rodrigo Damazio
'''
class Translator(object):
'''
classdocs
'''
def __init__(self, language):
'''
Constructor
'''
self._language = language
def Translate(self, string_names):
print string_names | Python |
'''
Module which brings history information about files from Mercurial.
@author: Rodrigo Damazio
'''
import re
import subprocess
REVISION_REGEX = re.compile(r'(?P<hash>[0-9a-f]{12}):.*')
def _GetOutputLines(args):
'''
Runs an external process and returns its output as a list of lines.
@param args: the arguments to run
'''
process = subprocess.Popen(args,
stdout=subprocess.PIPE,
universal_newlines = True,
shell = False)
output = process.communicate()[0]
return output.splitlines()
def FillMercurialRevisions(filename, parsed_file):
'''
Fills the revs attribute of all strings in the given parsed file with
a list of revisions that touched the lines corresponding to that string.
@param filename: the name of the file to get history for
@param parsed_file: the parsed file to modify
'''
# Take output of hg annotate to get revision of each line
output_lines = _GetOutputLines(['hg', 'annotate', '-c', filename])
# Create a map of line -> revision (key is list index, line 0 doesn't exist)
line_revs = ['dummy']
for line in output_lines:
rev_match = REVISION_REGEX.match(line)
if not rev_match:
raise 'Unexpected line of output from hg: %s' % line
rev_hash = rev_match.group('hash')
line_revs.append(rev_hash)
for str in parsed_file.itervalues():
# Get the lines that correspond to each string
start_line = str['startLine']
end_line = str['endLine']
# Get the revisions that touched those lines
revs = []
for line_number in range(start_line, end_line + 1):
revs.append(line_revs[line_number])
# Merge with any revisions that were already there
# (for explict revision specification)
if 'revs' in str:
revs += str['revs']
# Assign the revisions to the string
str['revs'] = frozenset(revs)
def DoesRevisionSuperceed(filename, rev1, rev2):
'''
Tells whether a revision superceeds another.
This essentially means that the older revision is an ancestor of the newer
one.
This also returns True if the two revisions are the same.
@param rev1: the revision that may be superceeding the other
@param rev2: the revision that may be superceeded
@return: True if rev1 superceeds rev2 or they're the same
'''
if rev1 == rev2:
return True
# TODO: Add filename
args = ['hg', 'log', '-r', 'ancestors(%s)' % rev1, '--template', '{node|short}\n', filename]
output_lines = _GetOutputLines(args)
return rev2 in output_lines
def NewestRevision(filename, rev1, rev2):
'''
Returns which of two revisions is closest to the head of the repository.
If none of them is the ancestor of the other, then we return either one.
@param rev1: the first revision
@param rev2: the second revision
'''
if DoesRevisionSuperceed(filename, rev1, rev2):
return rev1
return rev2 | Python |
'''
Module which parses a string XML file.
@author: Rodrigo Damazio
'''
from xml.parsers.expat import ParserCreate
import re
#import xml.etree.ElementTree as ET
class StringsParser(object):
'''
Parser for string XML files.
This object is not thread-safe and should be used for parsing a single file at
a time, only.
'''
def Parse(self, file):
'''
Parses the given file and returns a dictionary mapping keys to an object
with attributes for that key, such as the value, start/end line and explicit
revisions.
In addition to the standard XML format of the strings file, this parser
supports an annotation inside comments, in one of these formats:
<!-- KEEP_PARENT name="bla" -->
<!-- KEEP_PARENT name="bla" rev="123456789012" -->
Such an annotation indicates that we're explicitly inheriting form the
master file (and the optional revision says that this decision is compatible
with the master file up to that revision).
@param file: the name of the file to parse
'''
self._Reset()
# Unfortunately expat is the only parser that will give us line numbers
self._xml_parser = ParserCreate()
self._xml_parser.StartElementHandler = self._StartElementHandler
self._xml_parser.EndElementHandler = self._EndElementHandler
self._xml_parser.CharacterDataHandler = self._CharacterDataHandler
self._xml_parser.CommentHandler = self._CommentHandler
file_obj = open(file)
self._xml_parser.ParseFile(file_obj)
file_obj.close()
return self._all_strings
def _Reset(self):
self._currentString = None
self._currentStringName = None
self._currentStringValue = None
self._all_strings = {}
def _StartElementHandler(self, name, attrs):
if name != 'string':
return
if 'name' not in attrs:
return
assert not self._currentString
assert not self._currentStringName
self._currentString = {
'startLine' : self._xml_parser.CurrentLineNumber,
}
if 'rev' in attrs:
self._currentString['revs'] = [attrs['rev']]
self._currentStringName = attrs['name']
self._currentStringValue = ''
def _EndElementHandler(self, name):
if name != 'string':
return
assert self._currentString
assert self._currentStringName
self._currentString['value'] = self._currentStringValue
self._currentString['endLine'] = self._xml_parser.CurrentLineNumber
self._all_strings[self._currentStringName] = self._currentString
self._currentString = None
self._currentStringName = None
self._currentStringValue = None
def _CharacterDataHandler(self, data):
if not self._currentString:
return
self._currentStringValue += data
_KEEP_PARENT_REGEX = re.compile(r'\s*KEEP_PARENT\s+'
r'name\s*=\s*[\'"]?(?P<name>[a-z0-9_]+)[\'"]?'
r'(?:\s+rev=[\'"]?(?P<rev>[0-9a-f]{12})[\'"]?)?\s*',
re.MULTILINE | re.DOTALL)
def _CommentHandler(self, data):
keep_parent_match = self._KEEP_PARENT_REGEX.match(data)
if not keep_parent_match:
return
name = keep_parent_match.group('name')
self._all_strings[name] = {
'keepParent' : True,
'startLine' : self._xml_parser.CurrentLineNumber,
'endLine' : self._xml_parser.CurrentLineNumber
}
rev = keep_parent_match.group('rev')
if rev:
self._all_strings[name]['revs'] = [rev] | Python |
#!/usr/bin/python
'''
Entry point for My Tracks i18n tool.
@author: Rodrigo Damazio
'''
import mytracks.files
import mytracks.translate
import mytracks.validate
import sys
def Usage():
print 'Usage: %s <command> [<language> ...]\n' % sys.argv[0]
print 'Commands are:'
print ' cleanup'
print ' translate'
print ' validate'
sys.exit(1)
def Translate(languages):
'''
Asks the user to interactively translate any missing or oudated strings from
the files for the given languages.
@param languages: the languages to translate
'''
validator = mytracks.validate.Validator(languages)
validator.Validate()
missing = validator.missing_in_lang()
outdated = validator.outdated_in_lang()
for lang in languages:
untranslated = missing[lang] + outdated[lang]
if len(untranslated) == 0:
continue
translator = mytracks.translate.Translator(lang)
translator.Translate(untranslated)
def Validate(languages):
'''
Computes and displays errors in the string files for the given languages.
@param languages: the languages to compute for
'''
validator = mytracks.validate.Validator(languages)
validator.Validate()
error_count = 0
if (validator.valid()):
print 'All files OK'
else:
for lang, missing in validator.missing_in_master().iteritems():
print 'Missing in master, present in %s: %s:' % (lang, str(missing))
error_count = error_count + len(missing)
for lang, missing in validator.missing_in_lang().iteritems():
print 'Missing in %s, present in master: %s:' % (lang, str(missing))
error_count = error_count + len(missing)
for lang, outdated in validator.outdated_in_lang().iteritems():
print 'Outdated in %s: %s:' % (lang, str(outdated))
error_count = error_count + len(outdated)
return error_count
if __name__ == '__main__':
argv = sys.argv
argc = len(argv)
if argc < 2:
Usage()
languages = mytracks.files.GetAllLanguageFiles()
if argc == 3:
langs = set(argv[2:])
if not langs.issubset(languages):
raise 'Language(s) not found'
# Filter just to the languages specified
languages = dict((lang, lang_file)
for lang, lang_file in languages.iteritems()
if lang in langs or lang == 'en' )
cmd = argv[1]
if cmd == 'translate':
Translate(languages)
elif cmd == 'validate':
error_count = Validate(languages)
else:
Usage()
error_count = 0
print '%d errors found.' % error_count
| Python |
'''
Module which compares languague files to the master file and detects
issues.
@author: Rodrigo Damazio
'''
import os
from mytracks.parser import StringsParser
import mytracks.history
class Validator(object):
def __init__(self, languages):
'''
Builds a strings file validator.
Params:
@param languages: a dictionary mapping each language to its corresponding directory
'''
self._langs = {}
self._master = None
self._language_paths = languages
parser = StringsParser()
for lang, lang_dir in languages.iteritems():
filename = os.path.join(lang_dir, 'strings.xml')
parsed_file = parser.Parse(filename)
mytracks.history.FillMercurialRevisions(filename, parsed_file)
if lang == 'en':
self._master = parsed_file
else:
self._langs[lang] = parsed_file
self._Reset()
def Validate(self):
'''
Computes whether all the data in the files for the given languages is valid.
'''
self._Reset()
self._ValidateMissingKeys()
self._ValidateOutdatedKeys()
def valid(self):
return (len(self._missing_in_master) == 0 and
len(self._missing_in_lang) == 0 and
len(self._outdated_in_lang) == 0)
def missing_in_master(self):
return self._missing_in_master
def missing_in_lang(self):
return self._missing_in_lang
def outdated_in_lang(self):
return self._outdated_in_lang
def _Reset(self):
# These are maps from language to string name list
self._missing_in_master = {}
self._missing_in_lang = {}
self._outdated_in_lang = {}
def _ValidateMissingKeys(self):
'''
Computes whether there are missing keys on either side.
'''
master_keys = frozenset(self._master.iterkeys())
for lang, file in self._langs.iteritems():
keys = frozenset(file.iterkeys())
missing_in_master = keys - master_keys
missing_in_lang = master_keys - keys
if len(missing_in_master) > 0:
self._missing_in_master[lang] = missing_in_master
if len(missing_in_lang) > 0:
self._missing_in_lang[lang] = missing_in_lang
def _ValidateOutdatedKeys(self):
'''
Computers whether any of the language keys are outdated with relation to the
master keys.
'''
for lang, file in self._langs.iteritems():
outdated = []
for key, str in file.iteritems():
# Get all revisions that touched master and language files for this
# string.
master_str = self._master[key]
master_revs = master_str['revs']
lang_revs = str['revs']
if not master_revs or not lang_revs:
print 'WARNING: No revision for %s in %s' % (key, lang)
continue
master_file = os.path.join(self._language_paths['en'], 'strings.xml')
lang_file = os.path.join(self._language_paths[lang], 'strings.xml')
# Assume that the repository has a single head (TODO: check that),
# and as such there is always one revision which superceeds all others.
master_rev = reduce(
lambda r1, r2: mytracks.history.NewestRevision(master_file, r1, r2),
master_revs)
lang_rev = reduce(
lambda r1, r2: mytracks.history.NewestRevision(lang_file, r1, r2),
lang_revs)
# If the master version is newer than the lang version
if mytracks.history.DoesRevisionSuperceed(lang_file, master_rev, lang_rev):
outdated.append(key)
if len(outdated) > 0:
self._outdated_in_lang[lang] = outdated
| Python |
'''
Module for dealing with resource files (but not their contents).
@author: Rodrigo Damazio
'''
import os.path
from glob import glob
import re
MYTRACKS_RES_DIR = 'MyTracks/res'
ANDROID_MASTER_VALUES = 'values'
ANDROID_VALUES_MASK = 'values-*'
def GetMyTracksDir():
'''
Returns the directory in which the MyTracks directory is located.
'''
path = os.getcwd()
while not os.path.isdir(os.path.join(path, MYTRACKS_RES_DIR)):
if path == '/':
raise 'Not in My Tracks project'
# Go up one level
path = os.path.split(path)[0]
return path
def GetAllLanguageFiles():
'''
Returns a mapping from all found languages to their respective directories.
'''
mytracks_path = GetMyTracksDir()
res_dir = os.path.join(mytracks_path, MYTRACKS_RES_DIR, ANDROID_VALUES_MASK)
language_dirs = glob(res_dir)
master_dir = os.path.join(mytracks_path, MYTRACKS_RES_DIR, ANDROID_MASTER_VALUES)
if len(language_dirs) == 0:
raise 'No languages found!'
if not os.path.isdir(master_dir):
raise 'Couldn\'t find master file'
language_tuples = [(re.findall(r'.*values-([A-Za-z-]+)', dir)[0],dir) for dir in language_dirs]
language_tuples.append(('en', master_dir))
return dict(language_tuples)
| Python |
#################################################################################
#
# (c) Copyright 2010 William Stein
#
# This file is part of PSAGE
#
# PSAGE is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# PSAGE is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
#
#################################################################################
# A setuptools-based build system. See the comment before the line
# "build_system.cythonize(ext_modules)" in setup.py about how this
# code can probably be replaced by code in Cython soon.
import os, sys
from setuptools import setup
import setuptools
def time_stamp(filename):
try:
return os.path.getmtime(filename)
except OSError, msg:
print msg
return 0
def cython(f_pyx, language, include_dirs, force):
assert f_pyx.endswith('.pyx')
# output filename
dir, f = os.path.split(f_pyx)
ext = 'cpp' if language == 'c++' else 'c'
outfile = os.path.splitext(f)[0] + '.' + ext
full_outfile = dir + '/' + outfile
if not force:
if os.path.exists(full_outfile) and time_stamp(f_pyx) <= time_stamp(full_outfile):
# Already compiled
return full_outfile, []
includes = ''.join(["-I '%s' "%x for x in include_dirs])
# call cython
cmd = "cd %s && python `which cython` --embed-positions --directive cdivision=False %s -o %s %s"%(
dir, includes, outfile, f)
return full_outfile, [cmd]
class Extension(setuptools.Extension):
def __init__(self, module, sources, include_dirs,
language="c", force=False, **kwds):
self.cython_cmds = []
for i in range(len(sources)):
f = sources[i]
if f.endswith('.pyx'):
sources[i], cmds = cython(f, language, include_dirs, force)
for c in cmds:
self.cython_cmds.append(c)
setuptools.Extension.__init__(self, module, sources, language=language,
include_dirs=include_dirs, **kwds)
def apply_pair(p):
"""
Given a pair p consisting of a function and a value, apply
the function to the value.
This exists solely because we can't pickle an anonymous function
in execute_list_of_commands_in_parallel below.
"""
return p[0](p[1])
def execute_list_of_commands_in_parallel(command_list, nthreads):
"""
INPUT:
command_list -- a list of pairs, consisting of a
function to call and its argument
nthreads -- integer; number of threads to use
OUTPUT:
Executes the given list of commands, possibly in parallel,
using nthreads threads. Terminates setup.py with an exit code of 1
if an error occurs in any subcommand.
WARNING: commands are run roughly in order, but of course successive
commands may be run at the same time.
"""
print "Execute %s commands (using %s threads)"%(len(command_list), min(len(command_list),nthreads))
from multiprocessing import Pool
p = Pool(nthreads)
print command_list
for r in p.imap(apply_pair, command_list):
if r:
print "Parallel build failed with status %s."%r
sys.exit(1)
def number_of_threads():
"""
Try to determine the number of threads one can run at once on this
system (e.g., the number of cores). If successful return that
number. Otherwise return 0 to indicate failure.
OUTPUT:
int
"""
if hasattr(os, "sysconf") and os.sysconf_names.has_key("SC_NPROCESSORS_ONLN"): # Linux and Unix
n = os.sysconf("SC_NPROCESSORS_ONLN")
if isinstance(n, int) and n > 0:
return n
try:
return int(os.popen2("sysctl -n hw.ncpu")[1].read().strip())
except:
return 0
def execute_list_of_commands_in_serial(command_list):
"""
INPUT:
command_list -- a list of commands, each given as a pair
of the form [command, argument].
OUTPUT:
the given list of commands are all executed in serial
"""
for f,v in command_list:
r = f(v)
if r != 0:
print "Error running command, failed with status %s."%r
sys.exit(1)
def cythonize(ext_modules):
cmds = sum([E.cython_cmds for E in ext_modules], [])
cmds = [(os.system, c) for c in cmds]
n = number_of_threads()
if n == 1:
execute_list_of_commands_in_serial(cmds)
else:
execute_list_of_commands_in_parallel(cmds, n)
| Python |
from sage.all import *
def examples():
r"""
Some more examples of xxx_rankbound() on high rank curves.
(See source for more.)
EXAMPLES:
We make sure that the examples all work.
::
sage: from psage.ellcurve.xxx.rankbound_examples import examples
sage: examples() # LONG TIME (lack of output indicates success)
"""
from psage.ellcurve.xxx.rankbound import xxx_rankbound
def check(E, Delta, answer, bad_primes = None):
# TODO: Is there a way to quickly compute the root number
# given the bad primes?
if bad_primes is not None:
# check that we actually have all of the bad primes
D = E.discriminant()
for p in bad_primes:
p = Integer(p)
assert(p.divides(D)), "p is not bad"
while p.divides(D):
D = D/p
assert abs(D) == 1, "Missing a bad prime."
a = xxx_rankbound(E, Delta, bad_primes)
assert abs(a - answer) < 1e-3, "FAIL"
E20 = EllipticCurve([1, 0, 0, -431092980766333677958362095891166, 5156283555366643659035652799871176909391533088196])
E21 = EllipticCurve([1, 1, 1, -215843772422443922015169952702159835, -19474361277787151947255961435459054151501792241320535])
E22 = EllipticCurve([1, 0, 1, -940299517776391362903023121165864, 10707363070719743033425295515449274534651125011362])
E23 = EllipticCurve([1, 0, 1, -19252966408674012828065964616418441723, 32685500727716376257923347071452044295907443056345614006])
E24 = EllipticCurve([1, 0, 1, -120039822036992245303534619191166796374, 504224992484910670010801799168082726759443756222911415116])
E28 = EllipticCurve([1, -1, 1, -20067762415575526585033208209338542750930230312178956502,
34481611795030556467032985690390720374855944359319180361266008296291939448732243429])
E23_bad_primes = [2, 3, 5, 11, 13, 17, 19, 23, 199, 17858193374841750901974789649, 1006218106634655545344494448610726356220703995276273]
E24_bad_primes = [2, 3, 5, 11, 13, 17, 29, 31, 41, 458619970494582607679296750333015081, 264240973182971699094661154229360236070105974082503]
E28_bad_primes = [2, 3, 5, 7, 11, 13, 17, 19, 48463, 20650099, 315574902691581877528345013999136728634663121, 376018840263193489397987439236873583997122096511452343225772113000611087671413]
check(E20, 2.0, 21.6907)
check(E21, 2.5, 22.6727)
check(E22, 2.0, 23.7047)
check(E23, 2.5, 24.4834, E23_bad_primes)
check(E24, 2.5, 25.5682, E24_bad_primes)
check(E28, 2.5, 33.4304, E28_bad_primes) # needs a larger delta to get a
# good bound, but that takes a
# while.
#check(E28, 3.2, 31.2984, E28_bad_primes) # this works, but takes about
# 6 minutes on my fast machine.
# (Is that too long for LONG?)
| Python |
#
| Python |
#################################################################################
#
# (c) Copyright 2011 William Stein
#
# This file is part of PSAGE
#
# PSAGE is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# PSAGE is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
#
"""
Computing L-series of elliptic curves over general number fields.
EXAMPLES::
sage: from psage.ellcurve.lseries.lseries_nf import lseries_dokchitser
sage: K.<a> = NumberField(x^2-x-1); E = EllipticCurve([0,-a,a,0,0])
sage: L = lseries_dokchitser(E,32); L
Dokchitser L-function of Elliptic Curve defined by y^2 + a*y = x^3 + (-a)*x^2 over Number Field in a with defining polynomial x^2 - x - 1
sage: L(1)
0.422214159
sage: L.taylor_series(1, 5)
0.422214159 + 0.575883865*z - 0.102163427*z^2 - 0.158119743*z^3 + 0.120350688*z^4 + O(z^5)
The sign of the functional equation is numerically determined when constructing the L-series::
sage: L.eps
1
AUTHORS:
- William Stein
- Adam Sorkin (very early version: http://trac.sagemath.org/sage_trac/ticket/9402)
"""
import math
from sage.all import (PowerSeriesRing, Integer, factor, QQ, ZZ,
RDF, RealField, Dokchitser, prime_range, prod, pari)
from sage.rings.all import is_NumberField
from psage.ellcurve.lseries.helper import extend_multiplicatively_generic
##################################################################################
# Optimized Special Case: Q(sqrt(5))
##################################################################################
def anlist_over_sqrt5(E, bound):
"""
Compute the Dirichlet L-series coefficients, up to and including
a_bound. The i-th element of the return list is a[i].
INPUT:
- E -- elliptic curve over Q(sqrt(5)), which must have
defining polynomial `x^2-x-1`.
- ``bound`` -- integer
OUTPUT:
- list of integers of length bound + 1
EXAMPLES::
sage: from psage.ellcurve.lseries.lseries_nf import anlist_over_sqrt5
sage: K.<a> = NumberField(x^2-x-1); E = EllipticCurve([0,-a,a,0,0])
sage: v = anlist_over_sqrt5(E, 50); v
[0, 1, 0, 0, -2, -1, 0, 0, 0, -4, 0, 3, 0, 0, 0, 0, 0, 0, 0, 5, 2, 0, 0, 0, 0, -4, 0, 0, 0, 11, 0, -6, 0, 0, 0, 0, 8, 0, 0, 0, 0, -1, 0, 0, -6, 4, 0, 0, 0, -6, 0]
sage: len(v)
51
This function isn't super fast, but at least it will work in a few
seconds up to `10^4`::
sage: t = cputime()
sage: v = anlist_over_sqrt5(E, 10^4)
sage: assert cputime(t) < 5
"""
import aplist_sqrt5
from psage.number_fields.sqrt5.prime import primes_of_bounded_norm, Prime
# Compute all of the prime ideals of the ring of integers up to the given bound
primes = primes_of_bounded_norm(bound+1)
# Compute the traces of Frobenius: this is supposed to be the hard part
v = aplist_sqrt5.aplist(E, bound+1)
# Compute information about the primes of bad reduction, in
# particular the integers i such that primes[i] is a prime of bad
# reduction.
bad_primes = set([Prime(a.prime()) for a in E.local_data()])
# We compute the local factors of the L-series as power series in ZZ[T].
P = PowerSeriesRing(ZZ, 'T')
T = P.gen()
# Table of powers of T, so we don't have to compute T^4 (say) thousands of times.
Tp = [T**i for i in range(5)]
# For each prime, we write down the local factor.
L_P = []
for i, P in enumerate(primes):
inertial_deg = 2 if P.is_inert() else 1
a_p = v[i]
if P in bad_primes:
# bad reduction
f = 1 - a_p*Tp[inertial_deg]
else:
# good reduction
q = P.norm()
f = 1 - a_p*Tp[inertial_deg] + q*Tp[2*inertial_deg]
L_P.append(f)
# Use the local factors of the L-series to compute the Dirichlet
# series coefficients of prime-power index.
coefficients = [0,1] + [0]*(bound-1)
i = 0
while i < len(primes):
P = primes[i]
if P.is_split():
s = L_P[i] * L_P[i+1]
i += 2
else:
s = L_P[i]
i += 1
p = P.p
# We need enough terms t so that p^t > bound
accuracy_p = int(math.floor(math.log(bound)/math.log(p))) + 1
series_p = s.add_bigoh(accuracy_p)**(-1)
for j in range(1, accuracy_p):
coefficients[p**j] = series_p[j]
# Using multiplicativity, fill in the non-prime power Dirichlet
# series coefficients.
extend_multiplicatively_generic(coefficients)
return coefficients
##################################################################################
# General case over number fields. Largely untouched from trac
# ticket. Once Q(sqrt(5)) case above is more optimized, revisit the
# three *_over_nf functions below and refactor and improve.
##################################################################################
def get_factor_over_nf(curve, prime_ideal, prime_number, conductor, accuracy):
"""
Returns the inverse of the factor corresponding to the given prime
ideal in the Euler product expansion of the L-function at
prime_ideal. Unless the accuracy doesn't need this expansion, and
then returns 1 in power series ring.
"""
P = PowerSeriesRing(ZZ, 'T')
T = P.gen()
q = prime_ideal.norm()
inertial_deg = Integer(q).ord(prime_number)
if inertial_deg > accuracy:
return P(1)
if prime_ideal.divides(conductor):
a = curve.local_data(prime_ideal).bad_reduction_type()
L = 1 - a*(T**inertial_deg)
else:
discriminant = curve.discriminant()
if prime_ideal.divides(discriminant):
a = q + 1 - curve.local_minimal_model(prime_ideal).reduction(prime_ideal).count_points()
else:
a = q + 1 - curve.reduction(prime_ideal).count_points()
L = 1 - a*(T**inertial_deg) + q*(T**(2*inertial_deg))
return L
def get_coeffs_p_over_nf(curve, prime_number, accuracy=20 , conductor=None):
"""
Computes the inverse of product of L_prime on all primes above prime_number,
then returns power series of L_p up to desired accuracy.
But will not return power series if need not do so (depends on accuracy).
"""
if conductor is None:
conductor = curve.conductor()
primes = curve.base_field().prime_factors(prime_number)
series_p = [get_factor_over_nf(curve, prime_id, prime_number, conductor, accuracy) for prime_id in primes]
return ( prod(series_p).O(accuracy) )**(-1)
def anlist_over_nf(E, bound):
"""
Caution: This method is slow, especially for curves of high
conductor, or defined over number fields of high degree.
The method is to take the Euler product form, and retrieve
the coefficients by expanding each product factor as a power
series. The bottleneck is counting points over good reductions.
TODO: Cache this method: it is computed when initializing the
class dokchitser, if cached would have .num_coeffs() of a_i stored.
EXAMPLE::
sage: K.<i> = NumberField(x^2+1)
sage: E = EllipticCurve(K,[0,-1,1,0,0])
sage: from psage.ellcurve.lseries.lseries_nf import anlist_over_nf
sage: anlist_over_nf(E, 20)
[0, 1, -2, 0, 2, 2, 0, 0, 0, -5, -4, 0, 0, 8, 0, 0, -4, -4, 10, 0, 4]
"""
conductor = E.conductor()
coefficients = [0,1] + [0]*(bound-1)
for p in prime_range(bound+1):
accuracy_p = int(math.floor(math.log(bound)/math.log(p))) + 1
series_p = get_coeffs_p_over_nf(E, p, accuracy_p, conductor)
for i in range(1, accuracy_p):
coefficients[p**i] = series_p[i]
extend_multiplicatively_generic(coefficients)
return coefficients
########################################################################
def anlist(E, bound):
r"""
Compute the Dirichlet L-series coefficients, up to and including
a_bound. The i-th element of the return list is a[i].
INPUT:
- E -- elliptic curve over any number field or the rational numbers
- ``bound`` -- integer
OUTPUT:
- list of integers of length bound + 1
EXAMPLES::
sage: from psage.ellcurve.lseries.lseries_nf import anlist
sage: anlist(EllipticCurve([1,2,3,4,5]),40)
[0, 1, 1, 0, -1, -3, 0, -1, -3, -3, -3, -1, 0, 1, -1, 0, -1, 5, -3, 4, 3, 0, -1, -6, 0, 4, 1, 0, 1, -2, 0, 2, 5, 0, 5, 3, 3, 7, 4, 0, 9]
sage: K.<a> = NumberField(x^2-x-1)
sage: anlist(EllipticCurve(K,[1,2,3,4,5]),40)
[0, 1, 0, 0, -3, -3, 0, 0, 0, -6, 0, -2, 0, 0, 0, 0, 5, 0, 0, 8, 9, 0, 0, 0, 0, 4, 0, 0, 0, -4, 0, 4, 0, 0, 0, 0, 18, 0, 0, 0, 0]
sage: K.<i> = NumberField(x^2+1)
sage: anlist(EllipticCurve(K,[1,2,3,4,5]),40)
[0, 1, 1, 0, -1, -6, 0, 0, -3, -6, -6, 0, 0, 2, 0, 0, -1, 10, -6, 0, 6, 0, 0, 0, 0, 17, 2, 0, 0, -4, 0, 0, 5, 0, 10, 0, 6, 14, 0, 0, 18]
Note that the semantics of anlist agree with the anlist method on
elliptic curves over QQ in Sage::
sage: from psage.ellcurve.lseries.lseries_nf import anlist
sage: E = EllipticCurve([1..5])
sage: v = E.anlist(10); v
[0, 1, 1, 0, -1, -3, 0, -1, -3, -3, -3]
sage: len(v)
11
sage: anlist(E, 10)
[0, 1, 1, 0, -1, -3, 0, -1, -3, -3, -3]
"""
if E.base_field() == QQ:
# Rational numbers -- use code built into Sage
v = E.anlist(bound)
elif list(E.base_field().defining_polynomial()) == [-1,-1,1]:
# An optimized special case -- Q(sqrt(5))
v = anlist_over_sqrt5(E, bound)
else:
# General number field -- very slow in general
v = anlist_over_nf(E, bound)
return v
def lseries_dokchitser(E, prec=53):
"""
Return the Dokchitser L-series object associated to the elliptic
curve E, which may be defined over the rational numbers or a
number field. Also prec is the number of bits of precision to
which evaluation of the L-series occurs.
INPUT:
- E -- elliptic curve over a number field (or QQ)
- prec -- integer (default: 53) precision in *bits*
OUTPUT:
- Dokchitser L-function object
EXAMPLES::
A curve over Q(sqrt(5)), for which we have an optimized implementation::
sage: from psage.ellcurve.lseries.lseries_nf import lseries_dokchitser
sage: K.<a> = NumberField(x^2-x-1); E = EllipticCurve([0,-a,a,0,0])
sage: L = lseries_dokchitser(E); L
Dokchitser L-function of Elliptic Curve defined by y^2 + a*y = x^3 + (-a)*x^2 over Number Field in a with defining polynomial x^2 - x - 1
sage: L(1)
0.422214159001667
sage: L.taylor_series(1,5)
0.422214159001667 + 0.575883864741340*z - 0.102163426876721*z^2 - 0.158119743123727*z^3 + 0.120350687595265*z^4 + O(z^5)
Higher precision::
sage: L = lseries_dokchitser(E, 200)
sage: L(1)
0.42221415900166715092967967717023093014455137669360598558872
A curve over Q(i)::
sage: K.<i> = NumberField(x^2 + 1)
sage: E = EllipticCurve(K, [1,0])
sage: E.conductor().norm()
256
sage: L = lseries_dokchitser(E, 10)
sage: L.taylor_series(1,5)
0.86 + 0.58*z - 0.62*z^2 + 0.19*z^3 + 0.18*z^4 + O(z^5)
More examples::
sage: lseries_dokchitser(EllipticCurve([0,-1,1,0,0]), 10)(1)
0.25
sage: K.<i> = NumberField(x^2+1)
sage: lseries_dokchitser(EllipticCurve(K, [0,-1,1,0,0]), 10)(1)
0.37
sage: K.<a> = NumberField(x^2-x-1)
sage: lseries_dokchitser(EllipticCurve(K, [0,-1,1,0,0]), 10)(1)
0.72
sage: E = EllipticCurve([0,-1,1,0,0])
sage: E.quadratic_twist(2).rank()
1
sage: K.<d> = NumberField(x^2-2)
sage: L = lseries_dokchitser(EllipticCurve(K, [0,-1,1,0,0]), 10)
sage: L(1)
0
sage: L.taylor_series(1, 5)
0.58*z + 0.20*z^2 - 0.50*z^3 + 0.28*z^4 + O(z^5)
You can use this function as an algorithm to compute the sign of the functional
equation (global root number)::
sage: E = EllipticCurve([1..5])
sage: E.root_number()
-1
sage: L = lseries_dokchitser(E,32); L
Dokchitser L-function of Elliptic Curve defined by y^2 + x*y = x^3 - x^2 + 4*x + 3 over Rational Field
sage: L.eps
-1
Over QQ, this isn't so useful (since Sage has a root_number
method), but over number fields it is very useful::
sage: K.<a> = NumberField(x^2 - x - 1)
sage: E1=EllipticCurve([0,-a-1,1,a,0]); E0 = EllipticCurve([0,-a,a,0,0])
sage: lseries_dokchitser(E1, 16).eps
-1
sage: E1.rank()
1
sage: lseries_dokchitser(E0, 16).eps
1
sage: E0.rank()
0
"""
# The code asssumes in various places that we have a global minimal model,
# for example, in anlist_sqrt5 above.
E = E.global_minimal_model()
# Check that we're over a number field.
K = E.base_field()
if not is_NumberField(K):
raise TypeError, "base field must be a number field"
# Compute norm of the conductor -- awkward because QQ elements have no norm method (they should).
N = E.conductor()
if K != QQ:
N = N.norm()
# We guess the sign epsilon in the functional equation to be +1
# first. If our guess is wrong then we just choose the other
# possibility.
epsilon = 1
# Define the Dokchitser L-function object with all parameters set:
L = Dokchitser(conductor = N * K.discriminant()**2,
gammaV = [0]*K.degree() + [1]*K.degree(),
weight = 2, eps = epsilon, poles = [], prec = prec)
# Find out how many coefficients of the Dirichlet series are needed
# to compute to the requested precision.
n = L.num_coeffs()
# print "num coeffs = %s"%n
# Compute the Dirichlet series coefficients
coeffs = anlist(E, n)[1:]
# Define a string that when evaluated in PARI defines a function
# a(k), which returns the Dirichlet coefficient a_k.
s = 'v=%s; a(k)=v[k];'%coeffs
# Actually tell the L-series / PARI about the coefficients.
L.init_coeffs('a(k)', pari_precode = s)
# Test that the functional equation is satisfied. This will very,
# very, very likely if we chose the sign of the functional
# equation incorrectly, or made any mistake in computing the
# Dirichlet series coefficients.
tiny = max(1e-8, 1.0/2**(prec-1))
if abs(L.check_functional_equation()) > tiny:
# The test failed, so we try the other choice of functional equation.
epsilon *= -1
L.eps = epsilon
# It is not necessary to recreate L -- just tell PARI the different sign.
L._gp_eval('sgn = %s'%epsilon)
# Once again, verify that the functional equation is
# satisfied. If it is, then we've got it. If it isn't, then
# there is definitely some other subtle bug, probably in computed
# the Dirichlet series coefficients.
if abs(L.check_functional_equation()) > tiny:
raise RuntimeError, "Functional equation not numerically satisfied for either choice of sign"
L.rename('Dokchitser L-function of %s'%E)
return L
| Python |
from sage.all import polygen, NumberField, EllipticCurve
from psage.modform.hilbert.sqrt5.tables import primes_of_bounded_norm, F
a = F.gen()
import psage.ellcurve.lseries.sqrt5 as sqrt5
import psage.modform.hilbert.sqrt5.sqrt5_fast as sqrt5_fast
def test_ap_via_enumeration(B=1000):
a4 = 6912*a - 5643
a6 = -131328*a + 298566
E = EllipticCurve([a4, a6])
D = E.discriminant()
for P in primes_of_bounded_norm(B):
if D.valuation(P) == 0:
R = sqrt5_fast.ResidueRing(P, 1)
ap0 = sqrt5.ap_via_enumeration(R(a4), R(a6))
k = P.residue_field(); E0 = E.change_ring(k); ap1 = k.cardinality() + 1 - E0.cardinality()
assert ap0 == ap1
| Python |
#
| Python |
#################################################################################
#
# (c) Copyright 2011 William Stein
#
# This file is part of PSAGE.
#
# PSAGE is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 2 of the License, or
# (at your option) any later version.
#
# PSAGE is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
#
#################################################################################
"""
Some general and probably very, very slow code for computing L-series
of elliptic curves over general number fields.
NOTE: This code could probably get moved into Sage at some point,
though it's not at all clear the API below is the best. For example,
instead of storing keys as ideals, I store them as pairs (Norm,
reduced gens), since (1) I was running into bugs where equal ideals
have different hashes and (2) this format is much easier to look at.
"""
from sage.all import ZZ
def ap(E, p):
"""
INPUT:
- `E` -- an elliptic curve over a number field, assumed in
minimal Weierstrass form
- `p` -- a prime of the ring of integers of base field of the
curve
OUTPUT:
- the number `a_p(E)`.
NOTE: This should be really slow.
"""
k = p.residue_field()
t = E.local_data(p)
if t.has_good_reduction():
Ebar = E.change_ring(k)
q = k.cardinality()
return ZZ(q + 1 - Ebar.cardinality())
elif t.has_split_multiplicative_reduction():
return ZZ(1)
elif t.has_nonsplit_multiplicative_reduction():
return ZZ(-1)
else:
return ZZ(0)
def primes_of_bounded_norm(F, B):
r"""
Returns an iterator over all prime ideals of norm `\leq B` in the ring
of integers of the number field F, with the primes ordered by
their norm.
INPUT:
- `F` -- a number field
- `B` -- a positive integer
OUTPUT:
iterator
NOTE: This could be really slow, since it iterates over all
ideals, and takes only those that are prime.
"""
v = F.ideals_of_bdd_norm(B)
for nm in sorted(v.keys()):
X = v[nm]
if len(X)>0 and ZZ(nm).is_prime_power():
if X[0].is_prime():
for p in X: yield p
def ap_list(E, B, primes=False):
r"""
The Dirichlet coefficients `a_p` of the L-series attached to this
elliptic curve, for all primes `p` with `N(p) \leq B`, where
`N(p)` is the norm of `p`.
INPUT:
- `E` -- an elliptic curve over a number field, assumed in
minimal Weierstrass form
- `B` -- integer
- ``primes`` -- bool (default: False); if True, also return
corresponding list of primes up to norm n.
OUTPUT: list of integers
NOTE: This should be really slow.
"""
P = list(primes_of_bounded_norm(E.base_field(), B))
v = [ap(E,p) for p in P]
if primes:
return v, P
return v
def ap_dict(E, B):
r"""
The Dirichlet coefficients `a_p` of the L-series attached to this
elliptic curve, for all primes `p` with `N(p) \leq n`, where
`N(p)` is the norm of `p`.
INPUT:
- `E` -- an elliptic curve over a number field, assumed in
minimal Weierstrass form
- `n` -- integer
OUTPUT: dictionary mapping reduced rep of primes (N(p),p.reduced_gens()) to integers
NOTE: This should be really slow.
"""
P = list(primes_of_bounded_norm(E.base_field(), B))
return dict([(reduced_rep(p),ap(E,p)) for p in P])
def reduced_rep(I):
return (I.norm(), I.gens_reduced())
def an_dict_from_ap(ap, N, B):
r"""
Give a dict ``ap`` of the `a_p`, for primes with norm up to `B`,
return the dictionary giving all `a_I` for all ideals `I` up to
norm `B`.
NOTE: This code is specific to Dirichlet series of elliptic
curves.
INPUT:
- ``ap`` -- dictionary of ap, as output, e.g., by the ap_dict function
- `N` -- ideal; conductor of the elliptic curve
- `B` -- positive integer
OUTPUT: dictionary mapping reduced rep of primes (N(p),p.reduced_gens()) of ideals to integers
NOTE: This should be really, really slow. It's really just a toy
reference implementation.
"""
from sage.all import prod # used below
F = N.number_field()
A = F.ideals_of_bdd_norm(B)
an = dict(ap)
for n in sorted(A.keys()):
X = A[n]
for I in X:
if an.has_key(reduced_rep(I)):
# prime case, already done
pass
else:
# composite case
fac = I.factor()
if len(fac) == 0:
# unit ideal
an[reduced_rep(I)] = ZZ(1)
elif len(fac) > 1:
# not a prime power, so just multiply together
# already known Dirichlet coefficients, for
# prime power divisors (which are all known).
an[reduced_rep(I)] = prod(an[reduced_rep(p**e)] for p, e in fac)
else:
p, e = fac[0]
# a prime power
if p.divides(N):
# prime divides level
an[reduced_rep(I)] = an[reduced_rep(p)]**e
else:
# prime doesn't divide conductor: a_{p^e} = a_p*a_{p^(e-1)} - Norm(p)*a_{p^(e-2)}
assert e >= 2
an[reduced_rep(I)] = (an[reduced_rep(p)] * an[reduced_rep(p**(e-1))]
- p.norm()*an[reduced_rep(p**(e-2))])
return an
def an_dict(E, B):
r"""
Give an elliptic curve `E` over a number field, return dictionary
giving the Dirichlet coefficient `a_I` for ideals of norm up to `B`.
INPUT:
- ``ap`` -- dictionary of ap, as output, e.g., by the ap_dict function
- `N` -- ideal; conductor of the elliptic curve
- `B` -- positive integer
OUTPUT: dictionary mapping reduced rep of ideals (N(p),p.reduced_gens()) to integers
NOTE: This should be really, really slow. It's really just a toy
reference implementation.
"""
return an_dict_from_ap(ap_dict(E, B), E.conductor(), B)
def test1(B=50):
"""
Tests that the functions all run without crashing over a specific number field.
Does not test that the output is correct. That should be in
another test.
"""
from sage.all import polygen, QQ, NumberField, EllipticCurve
x = polygen(QQ,'x')
F = NumberField(x**2 - x - 1,'a'); a = F.gen()
E = EllipticCurve([1,a+1,a,a,0])
ap(E,F.ideal(3))
primes_of_bounded_norm(F,B)
ap_list(E,B)
assert len(ap_list(E,B,primes=True)) == 2
apd = ap_dict(E,B)
reduced_rep(F.ideal(3))
assert an_dict(E,B) == an_dict_from_ap(apd, E.conductor(), B)
def _test_an_dict_over_Q(ainvs, B=100):
"""
Test that the an_dict function works and gives the correct answer
for an elliptic curve defined over QQ, by computing using the
generic code in this file, and comparing with the output of Sage's
anlist function for rational elliptic curves.
"""
from sage.all import polygen, QQ, NumberField, EllipticCurve
x = polygen(QQ,'x')
F = NumberField(x - 1,'a'); a = F.gen()
E = EllipticCurve(F, ainvs)
EQ = EllipticCurve(QQ, ainvs)
v = EQ.anlist(B)
an = an_dict(E, B)
for i, j in an.iteritems():
assert j == v[i[0]]
def test_an_dict_over_Q():
"""
Fully test correctness of an_dict for a few curves over QQ.
"""
_test_an_dict_over_Q([1,2,3,4,5], 50)
_test_an_dict_over_Q([0,1], 100) # j = 0
_test_an_dict_over_Q([4,0], 100) # j = 1728
| Python |
def test_nonsurj(v=range(1,50)):
"""
For each non CM curve of conductor in the list v, compute the
primes where the representation isn't surjective using both galrep
and Sage, and make sure the answers agree.
"""
from sage.all import cremona_curves, Integer
from wrapper import GalRep
G = GalRep()
for E in cremona_curves(v):
if E.has_cm(): continue
a = E.galois_representation().non_surjective()
F = E.short_weierstrass_model()
b = G.non_surjective_primes(Integer(F.a4()), Integer(F.a6()))
if a != b:
raise RuntimeError, "Test failed for %s!"%E.cremona_label()
| Python |
# Galrep
from wrapper import GalRep
| Python |
from wrapper import GalRep
| Python |
#
| Python |
#
| Python |
#*****************************************************************************
# Copyright (C) 2008 Nils-Peter Skoruppa <nils.skoruppa@uni-siegen.de>
#
# Distributed under the terms of the GNU General Public License (GPL)
# http://www.gnu.org/licenses/
#*****************************************************************************
r"""
Implementation of the category of finite quadratic modules.
A quadratic module is a pair $(M,Q)$, where $M$ is a finite abelian
group and where $Q:M\rightarrow \Q/Z$ is a quadratic form. The latter
means that $Q(tx)=t^2Q(x)$ for all integers $t$ and all $x$ in $M$,
and that $B(x,y):=Q(x+y)=Q(x)-Q(y)$ defines a bilinear map
$B: M \times M \rightarrow \Q/Z$. A morphism $f:A \rightarrow B$
between quadratic modules $A=(M,Q) and $B=(N,R)$ is a homomorphism
of abelian groups $F:M \rightarrow N$ such that $R \circ f = Q$.
Quadratic modules show up naturally in the theory of Weil
representations, which in turn are needed e.g. in the theory of Jacobi
forms or elliptic modular forms of integral or half integral
weight. This is due to the fact, that every irreducible representation of $SL(2,\ZZ)$
whose kernel is a congruence subgroup is contained in a Weil
representation.
TECHNICAL NOTE
A finite abelian group $M$ is given as a set of $n$
generators $a,b,c..,$ and an $n \times n$-matrix $R$ encoding the
relations among the generators: $(a,b,c,...)R = 0$. A (finite) quadratic form
on $M$ is then given by its Gram matrix
$$
G \equiv \frac 12
\begin{pmatrix}
B(a,a) & B(a,b) & B(a,c) & \dots
\\ B(b,a) & B(b,b) & B(b,c) \dots
\\
\dots \end{pmatrix}
\bmod \ZZ^{n \times n}.
$$
The finite quadratic module is thus isomorphic to
$$
(\ZZ^n/R\ZZ^n, x+R\ZZ^n \mapsto x^tGx)
$$
via the map$(x_a, x_b, \dots) + R\ZZ^n \mapsto x_a a + x_b b + \cdots.$
Accordingly a typical initialization of a finite quadratic module would
be to provide the integer matrix $R$ and the rational matrix $G$.
REMARK
Many of the mathematically more meaningful methods of the class FiniteQuadraticModule_ambient assume that the
represented finite quadratic module is nondegenerate (i.e. $B(x,y)=0$
for all $y$ in $M$ is only possible for $x=0$). Applying such a method
to a degenerate module will raise an exeption (TODO: what exception?).
REFERENCES
[Sko] Nils-Peter Skoruppa, Finite quadratic modules and Weil representations,
in preparation 2008
TODO: find other references
AUTHORS:
-- Hatice Boylan, <boylan@mathematik.uni-siegen.de>
-- Martin Frick, <frick@mathematik.uni-siegen.de>
-- Lars Fischer, <lars.fischer@student.uni-siegen.de>
-- Shuichi Hayashida, <hayashida@mathematik.uni-siegen.de>
-- Nils-Peter Skoruppa <nils.skoruppa@uni-siegen.de>
-- Fredrik Stroemberg <fredrik314@gmail.com>
-- Stephan Ehlen <ehlen@mathematik.tu-darmstadt.de>
The CN-Group started the development of this package as a seminar
project at the university of Siegen. Its initial members have been:
Hatice Boylan, Martin Frick, Lars Fischer, Shuichi Hayashida,
Saber Mbarek, Nils-Peter Skoruppa
\section{Tutorial}
TODO: Lots and lots of examples.
"""
from sage.rings.arith import divisors, is_prime, kronecker,lcm,gcd, prime_divisors,primitive_root,is_square,is_prime_power
from sage.rings.all import ZZ, QQ, Integer, PolynomialRing,CC
from sage.groups.group import AbelianGroup
from sage.modules.free_module_element import vector
from sage.matrix.matrix_space import MatrixSpace
from sage.matrix.constructor import matrix, diagonal_matrix, identity_matrix
from sage.rings.number_field.number_field import CyclotomicField
from sage.structure.sage_object import SageObject
from sage.structure.element import AdditiveGroupElement
from sage.structure.sequence import Sequence_generic
from sage.structure.all import Sequence
from sage.all import copy,cached_method,is_even,is_odd,Sequence,prod,uniq,valuation,randrange,is_fundamental_discriminant,xmrange,QuadraticField,xgcd,CartesianProduct
from sage.graphs.graph import DiGraph
from sage.rings.number_field.number_field_element import NumberFieldElement
###################################
## CLASS QUAD_MODULE
###################################
class FiniteQuadraticModule_ambient (AbelianGroup):
r"""
Describes a finite quadratic module $(A,Q)$. The abelian group $A$
is given by generators \code{(e_0,e_1,\dots)} and a matrix $R$ of relations
satisfied by the generators (hence $(a,b,\dots)\cdot R = 0$). The
quadratic form $Q$ is given by the Gram matrix w.r.t. the generators;
more precisely, the $(i,j)$-th entry $g_{i,j}$ is a rational number
such that $Q(e_i+e_j)-Q(r_i)-Q(e_j) = g_{i,j} + \ZZ$..
NOTES
The abelian group may also be thought of as $\ZZ^n/R\ZZ^n$,
and the generators as $e_i = c_i + R\ZZ^n$, where $c_i$ is
the canonical basis for $\ZZ^n$.
In our implementation we think of elements of $\ZZ^n$
as column vectors.
Use FiniteQuadraticModule() for more flexibility when creating
FiniteQuadraticModule_ambient objects.
EXAMPLES
sage: R = matrix(2,2,[2,1,1,2])
sage: G = 1/2 * R^(-1)
sage: A.<a,b> = FiniteQuadraticModule_ambient( R, G); A
Finite quadratic module in 2 generators:
gens: a, b
form: 1/3*x0^2 + 2/3*x0*x1 + 1/3*x1^2
sage: a == b
True
sage: a is b
False
sage: a + b in A
True
"""
def __init__(self, R, G, check = True, names = None):
r"""
Initialize a quadratic module from R and G.
INPUT
R -- an integral non-degenerate square matrix of size $n$
representing the finite abelien group $\ZZ^n/R\ZZ^n$.
G -- a symmetric rational matrix of same size as $R$ and such
that $R^tGR$ is half integral and $2*R*M$ is an
integer matrix, representing the quadratic
form $x + R\ZZ^n \mapsto G[x] + \ZZ$.
check -- True or False indicating whether R and G should be
checked to be a valid set of data for the definition of
a quadratic module.
names -- a string used to name the generators of
the underlying abelian group.
"""
if True == check:
#TODO: check if R, G are matrices over ZZ, QQ, admit nonsquare R with rank == size G
if False == hasattr( R, '_matrix_') or False == hasattr( G, '_matrix_'):
raise TypeError, "%s: not a matrix" %R
if False == R.is_square() or 0 == R.det() or R.denominator() != 1:
raise ValueError, "%s: list not a regular integral square matrix" %R
if False == G.is_square() or False == G.is_symmetric():
raise ValueError, "%s: list not a symmetric square matrix" %G
C0 = G*R; C = R.transpose()*C0; v = vector([C[i,i] for i in range(C.nrows())])
if C0.denominator() > 2 or C.denominator() > 2 or v.denominator() > 1:
raise ValueError, "(%s,%s): not a compatible pair" %(R,G)
AbelianGroup.__init__( self)
# There is a sort of bug:
## sage: M = matrix(ZZ,1,[1])
## sage: M1 = matrix(ZZ,1,1,{(0,0):1})
## sage: M.block_sum (M1)
## ---------------------------------------------------------------------------
## TypeError Traceback (most recent call last)
## ..............
## TypeError: Cannot convert sage.matrix.matrix_integer_sparse.Matrix_integer_sparse to sage.matrix.matrix_integer_dense.Matrix_integer_dense
# which we cure for the moment as follows:
MS = MatrixSpace (ZZ,R.nrows(),R.ncols())
R = MS(R)
# We keep the initializing pair $(R,G)$
self.__iM = R
self.__iG = self._reduce_mat(G);
# We replace $__iM$ by the unique $__R$ in $__iM * GL(n,\ZZ)$ which is
# in lower Hermite normal form (i.e. is lower triangular and the rows
# are reduced modulo their rightmost nonzero element).
self.__R = matrix( ZZ, self.__iM).transpose().echelon_form().transpose()
# For simplicity and effectiveness in various internal computations
# we use an equivalent form $(__E,__J)$ of our quadratic module,
# where $__E$ is the diagonal matrix formed from the elementary divisors of $__R$
# in descending order, and where superfluous $1$'s are thrown out.
# The system of generators $e_i + __E\ZZ^m$, where $e_i$ is the standard basis of $\ZZ^m$
# are in the sequel called 'the fundamental system of generators'.
# TODO: In addition, $J$ should be put in Jordan form
D,U,V = matrix( ZZ, self.__R).dense_matrix().smith_form();
# Hence we have $D = U * __R * V$
mask = []
for n in range(D.nrows()):
if D[n,n] > 1:
mask.append(n)
if 0 == len(mask):
mask.append(0)
self.__E = D.matrix_from_rows_and_columns( mask, mask).sparse_matrix()
T = U**(-1)
self.__J = self._reduce_mat(
(T.transpose()
*self.__iG
*T).matrix_from_rows_and_columns( mask, mask))
n = self.__E.nrows()
self.__elementary_divisors = tuple( [ self.__E[j,j] for j in range( n) ])
# Transformation matrices:
# can_sys = fun_gen * C2F, fun_sys = can_sys * F2C
self.__C2F = U.matrix_from_rows( mask)
self.__F2C = T.matrix_from_columns( mask)
# Set the relation, Gram matrix and ngens to be used for the output
# self.__R = self.__R
self.__G = self.__iG
self.__ngens = self.__R.ncols()
# define inerited ngens attribute
if None == names:
names = "e"
self._assign_names(names)
## Silly class identifier needed since our class does not keep its name in sage....
self._is_FiniteQuadraticModule_ambient=True
# zero of self
self._zero = FiniteQuadraticModuleElement(self, 0, can_coords = True)
# list of possible x_c's
self._xcs={}
###################################
## Introduce myself ...
###################################
def _latex_( self):
r"""
EXAMPLES
sage: A = FiniteQuadraticModule( '3^2.27^-3'); latex(A)
\left(\left\langle \Z^{5}/\left(\begin{array}{rrrrr}
3 & 0 & 0 & 0 & 0 \\
0 & 3 & 0 & 0 & 0 \\
0 & 0 & 27 & 0 & 0 \\
0 & 0 & 0 & 27 & 0 \\
0 & 0 & 0 & 0 & 27
\end{array}\right)\Z^{5} \right\rangle, \frac{1}{3} x_{0}^{2} + \frac{1}{3} x_{1}^{2} + \frac{2}{27} x_{2}^{2} + \frac{1}{27} x_{3}^{2} + \frac{1}{27} x_{4}^{2}\right)
"""
n = self.ngens()
v = vector( PolynomialRing(QQ, 'x', n).gens())
form = v.dot_product( self.gram() * v)
return '\\left(\\left\\langle \\Z^{%s}/%s\\Z^{%s} \\right\\rangle, %s\\right)'\
%(latex(n), latex(self.__R), latex(n), latex(form))
def _repr_(self):
r"""
EXAMPLES
sage: A = FiniteQuadraticModule('2^2'); A
Finite quadratic module in 2 generators:
gens: e0, e1
form: 1/2*x0*x1
"""
n = self.ngens()
v = vector( PolynomialRing(QQ, 'x', n).gens())
gens = ', '.join([x for x in self._names])
form = v.dot_product( self.gram() * v)
return 'Finite quadratic module in %s generators:\n gens: %s\n form: %s' \
%(n, gens, form)
###################################
## Providing struct. defining items
###################################
def ngens( self):
r"""
Return the number of generators of the underlying abelian group.
EXAMPLES
sage: F = matrix( QQ, 3, 3, [ 2, 1, 5, 1, 34, 19, 5, 19, 6]); F
[ 2 1 5]
[ 1 34 19]
[ 5 19 6]
sage: A = FiniteQuadraticModule( F); A
Finite quadratic module in 3 generators:
gens: e0, e1, e2
form: 157/1960*x0^2 + 891/980*x0*x1 + 13/1960*x1^2 + 151/980*x0*x2 + 33/980*x1*x2 + 1893/1960*x2^2
sage: A.ngens()
3
"""
return self.__ngens
def gen( self, i=0):
r"""
Return the $i$-th generator of the underlying abelian group.
EXAMPLES
sage: A = FiniteQuadraticModule( [2, 4, 8]); A
Finite quadratic module in 3 generators:
gens: e0, e1, e2
form: 1/8*x0^2 + 1/16*x1^2 + 1/32*x2^2
sage: A.gens()
(e0, e1, e2)
sage: A.1
e1
"""
x = [0]*self.ngens()
x[int(i)] = 1
return FiniteQuadraticModuleElement(self, x, can_coords = True)
def relations( self):
r"""
Return a matrix in Hermite normal form describing the relations
satisfied by the generators (see class dos string for details).
EXAMPLES
sage: A = FiniteQuadraticModule('2^-2'); A
Finite quadratic module in 2 generators:
gens: e0, e1
form: 1/2*x0^2 + 1/2*x0*x1 + 1/2*x1^2
sage: A.relations()
[2 0]
[0 2]
"""
return self.__R
def gram( self):
r"""
Return the Gram matrix with respect to the generators
(as rational matrix).
EXAMPLES NONE
"""
return self.__G
def elementary_divisors( self):
r"""
Return the orders of the generators of the underlying group.
EXAMPLES
sage: A = FiniteQuadraticModule([11,33]); A
Finite quadratic module in 2 generators:
gens: e0, e1
form: 1/44*x0^2 + 1/132*x1^2
sage: A.elementary_divisors ()
(66, 22)
"""
return self.__elementary_divisors
def fgens( self):
r"""
Return a fundamental system for the underlying abelian group.
NOTES
A fundamental system of a finite abelian group $A$ is a
set of generators $a_i$ such that $A$ equals the direct sum of
the cyclic subgroups $\langle a_i \rangle$ generated by the
$a_i$, and if, for each $i$, the order of $a_i$ equals the
$i$-th elementary divisor of $A$.
This method returns a fundamental system (which is, in fact,
the one which was chosen
when the quadratic module was initialized, and with respect to
which all internal computations are actually performed).
EXAMPLES NONE
"""
return tuple([ self( list(x), can_coords = False) for x in identity_matrix( ZZ, len(self.elementary_divisors())) ])
###################################
## Coercion
###################################
def __call__( self, x, can_coords = False):
r"""
Coerce object into an appopriate child object
of self if possible.
We ccoerce
- an element of this module,
- a list of coordinates with respect to the
fundamental generators,
- the integer $0$.
EXAMPLES NONE
"""
if isinstance( x, FiniteQuadraticModuleElement):
if x.parent() is self:
return x
if isinstance( x, list):
return FiniteQuadraticModuleElement( self, x, can_coords)
if isinstance( x, (Integer, int, long)) and 0 == x:
return FiniteQuadraticModuleElement( self, x)
raise TypeError, "cannot coerce %s to an element of %s" %(x, self)
###################################
## Invariants
###################################
def order( self):
r"""
If self is the quadratic module $(M,Q)$, return the order of $M$.
EXAMPLES
sage: A = FiniteQuadraticModule([11,33]);
sage: A.order()
1452
"""
return prod( e for e in self.elementary_divisors())
def exponent( self):
r"""
If self is the quadratic module $(M,Q)$, then return the exponent of the
abelian group $M$.
EXAMPLES
sage: A = FiniteQuadraticModule([11,33]);
sage: A.exponent()
66
"""
return max( self.elementary_divisors())
def level( self):
r"""
If self is the quadratic module $(M,Q)$, then return the smallest positive integer $l$
such that $l\cdotQ = 0$.
EXAMPLES
sage: A = FiniteQuadraticModule([11,33]);
sage: A.level()
132
"""
H = copy(self.__J)
for i in range(H.ncols()):
for j in range( i+1, H.ncols()):
H[i,j] = 2*H[i,j]
H[j,i] = H[i,j]
return H.denominator()
def tau_invariant( self, p = None):
r"""
Return +1 or -1 accordingly as the order of the underlying abelian group
(resp. the largest power of $p$ dividing this order)
is a perfect square or not.
EXAMPLES NONE
"""
q = self.order()
if p is None:
return +1 if q.is_square() else -1
return +1 if is_even(q.valuation(p)) else -1
@cached_method
def sigma_invariant( self, p = None):
r"""
If this quadratic module equals $A=(M,Q)$, return
$\sigma(A) = \sqrt{|M|}^{-1/2}\sum_{x\in M} \exp(-2\pi i Q(x))$
EXAMPLES NONE
"""
return self.char_invariant( -1, p)[0]
def witt_invariants(self):
r"""
Return the family $\{sigma( A(p)\}_p$ as dictionary,
where $A$ is this module, $A(p)$ its $p$-part,
and $p$ is running through the divisors of the exponent of $A$
(see also A.sigma_invariant()).
EXAMPLES NONE
## sage: A = FiniteQuadraticModule([11,33]);
## sage: A.witt_class()[3]
## zeta8^2
"""
P = prime_divisors( self.exponent())
d = dict()
for p in P:
s = self.sigma_invariant(p)
t = self.tau_invariant(p)
d[p] = (s, t);
return d
def char_invariant( self, s, p = None):
r"""
If this quadratic module equals $A = (M,Q)$, return
the characteristic function of $A$ (or $A(p)$ if $p$ is a prime)
at $s$, i.e. return
$$\chi_A (s)= |M|^{-1}\sum_{x\in M} \exp(2\pi i s Q(x))).$$
NOTE
We apply the formula in [Sko, Second Proof of Theorem 1.4.1].
EXAMPLES NONE
"""
s = s%self.level()
if s==0:
return 1,1
if not p is None and not is_prime(p):
raise TypeError
if p and 0 != self.order()%p:
return 1,1
_p = p
K = CyclotomicField (8)
z = K.gen()
jd = self.jordan_decomposition()
ci = ci1 = 1
for c in jd:
# c: basis, ( prime p, valuation of p-power n, dimension r, determinant d over p [, oddity o])
p,n,r,d = c[1][:4]
#print "c=",c
if _p and p != _p:
continue
o = None if 4 == len(c[1]) else c[1][4]
k = valuation( s, p)
s1 = Integer(s/p**k)
h = max(n-k,0)
q = p**h
if p!=2:
lci = z**((r*(1-q))%8) * d**(h%2) if h > 0 else 1
lci1 = q**(-r) if h > 0 else 1
elif k == n and o:
#print "t!"
return 0,0
else:
f = z**o if o else 1
lci = f * d**(h%2) if h > 0 else 1
lci1 = q**(-r) if h > 0 else 1
# print f, d, lci
if 2 == p: lci = lci**s1
#print "lci=",lci
ci *= lci * kronecker( s1, 1/lci1)
ci1 *= lci1
return ci, QQ(ci1).sqrt()
def signature(self,p=-1):
r"""
Compute the p-signature of self.
p=-1 is the real signature.
TODO 1): use the formulas (for example from above) for p-signatures and Milgram's formula
TODO 2): implement for other primes
"""
if p<>-1:
raise NotImplementedError,"Only real signature implemented!"
ev = self.gram().eigenvalues()
b_plus = len( filter(lambda x:x>0,ev))
b_minus= len(ev)-b_plus
return b_plus - b_minus
###################################
## Deriving quadratic modules
###################################
def __add__( self, B):
r"""
Return the orthogonal sum of quadratic modules $A + B$,
where $A$ is this quadratic module.
INPUT
B -- quadratic module
EXAMPLES NONE
## sage: A = FiniteQuadraticModule([11,33]);
## sage: B = A + A; B
"""
return FiniteQuadraticModule_ambient( self.relations().block_sum( B.relations()), \
self.gram().block_sum( B.gram()), \
False)
def __mul__( self, _n):
r"""
Return the $n$ fold orthogonal sum of this quadratic module..
EXAMPLES NONE
"""
n = int(_n)
if n != _n:
raise TypeError, "Argument n (= %s) must be an integer."%n
if n < 0:
raise ValueError, "Argument n (= %s) must be nonnegative."%n
if 0 == n:
return FiniteQuadraticModule()
if n > 0:
# TODO: Understand why
# 1) return sum( self for j in range( n))
# does not work, though it works for FiniteQuadraticModuleElements
# Explanation for TODO above:
# LF: it seems that sum works like tmp=int(0) (with a real int, not Integer),
# and then aggregate the sum in tmp
# that means the first addition is 0 + quadmodule_object,
# which was undefined until now ( implemented __radd__)
# _ For elements there must be some coercion (through inheritance?) or
# an inherited addition with ints
# 2) 3*A does not work, but 3*e does work for elements e.
# LF: thanks to _r_action 3*A works now, the elements seem to have
# an inherited _r_action()
# old implementation without using sum
#A = self
#for i in range(1, n):
# A = A + self
#return A
return sum( self for j in range( n))
# sum works now, but depends on an existing __radd__ implementation
def __radd__(self, thing_on_the_left):
r"""
TODO: what is this here?
Implements 0 + self = self.
Nothing more. This addition seems to be needed in the sum inside the
implementation of for example 3*FiniteQuadraticModule().
EXAMPLES NONE
"""
#print "in __radd__ with a", type(thing_on_the_left), thing_on_the_left
if (thing_on_the_left == 0):
return self # 0 + self should be self, right?
else:
return ValueError, "Argument n on the left (= %s) must be 0."%n
# what is for example 1 + FiniteQuadraticModule() ?
# neither _rmul_ nor __rmul__ work for 3*A
def _r_action(self, n):
r"""
TODO: whaT is this ?
Return the $n$ fold orthogonal sum of self.
This method is used for an expression like 3*A, where A is \emph{on the right}.
It calls self.__mul__.
EXAMPLES NONE
## sage: A=FiniteQuadraticModule();
## sage: 3*A == A*3
True
"""
# HINT:
# !less /usr/local/sage/devel/sage/sage/structure/element.pyx:
# __mul__ uses return coercion_model.bin_op_c(left, right, mul)
# with coercion_model = sage.structure.coerce.CoercionModel_cache_maps()
# then coercion_model??, look for bin_op_c(, then if op is mul, ....
if type(n) is Integer:
return self.__mul__(n)
else:
raise TypeError, "Argument n (= %s) must be an integer."%n
def __cmp__( self, other):
r"""
Return 1 if other is a quadratic module having the same generator names,
satisfying the same relations and having the same Gram matrix as this module.
EXAMPLES NONE
TODO: compare names
"""
# compare two quadmodules via their relations and Gram-Matrix
if type(other) is type(self):
if (self.__R == other.__R) and (self.gram() == other.gram()):
return 0
return -1
def twist( self, s):
r"""
If self is the quadratic module $A = (M,Q)$, return the twisted module $A^s = (M,s*G)$.
INPUT
s -- an integer
OUTPUT
quadratic module
EXAMPLES
sage: A = FiniteQuadraticModule( '11^-1'); A
Finite quadratic module in 1 generators:
gens: e
form: 10/11*x^2
sage: B = A^-1; B
Finite quadratic module in 1 generators:
gens: e
form: 1/11*x^2
sage: C = B^11; C
Finite quadratic module in 1 generators:
gens: e
form: 0
sage: D = FiniteQuadraticModule( '4^-2.5^2'); D
Finite quadratic module in 4 generators:
gens: e0, e1, e2, e3
form: 1/4*x0^2 + 1/4*x0*x1 + 1/4*x1^2 + 1/5*x2^2 + 1/5*x3^2
sage: E = D^2; E
Finite quadratic module in 4 generators:
gens: e0, e1, e2, e3
form: 1/2*x0^2 + 1/2*x0*x1 + 1/2*x1^2 + 2/5*x2^2 + 2/5*x3^2
sage: E.is_nondegenerate ()
False
"""
a = Integer(s)
if a != s:
raise TypeError, "Argument a (= %s) must be an integer."%a
return FiniteQuadraticModule_ambient( self.relations(), a*self.gram())
def orthogonal_basis( self, p = None):
r"""
Return an orthogonal system of generators for the
underlying group of this quadratic module, if $p$ is None,
respectively for the $p$-Sylow subgroup if $p$ is a prime.
NOTES
See FiniteQuadraticModule_subgroup.orthogonal_basis()
for detailed explanation.
EXAMPLES
sage: A.<a,b,c,d,e,f,g,h,j> = FiniteQuadraticModule( '11^-7.2^-2')
sage: A.orthogonal_basis (11)
[2*a, 2*b, c, d, e, f, g]
sage: A.orthogonal_basis (2)
[j, h]
sage: R.<X>= ZZ['X']
sage: K.<x> = NumberField( X^10 + X^9 - X^7 - X^6 - X^5 - X^4 - X^3 + X + 1)
sage: L = FiniteQuadraticModule( (1-x)/1001); L
Finite quadratic module in 10 generators:
gens: e0, e1, e2, e3, e4, e5, e6, e7, e8, e9
form: 1/91*x0^2 + 997/1001*x0*x1 + 1000/1001*x1^2 + 999/1001*x0*x2 + 2/1001*x1*x2 + 998/1001*x2^2 + 2/1001*x0*x3 + 995/1001*x1*x3 + 999/1001*x3^2 + 995/1001*x0*x4 + 997/1001*x2*x4 + 10/1001*x3*x4 + 1000/1001*x4^2 + 997/1001*x1*x5 + 10/1001*x2*x5 + 999/1001*x3*x5 + 993/1001*x4*x5 + 997/1001*x5^2 + 997/1001*x0*x6 + 10/1001*x1*x6 + 999/1001*x2*x6 + 993/1001*x3*x6 + 993/1001*x4*x6 + 12/1001*x5*x6 + 993/1001*x6^2 + 10/1001*x0*x7 + 999/1001*x1*x7 + 993/1001*x2*x7 + 993/1001*x3*x7 + 12/1001*x4*x7 + 985/1001*x5*x7 + 8/1001*x6*x7 + 1/1001*x7^2 + 999/1001*x0*x8 + 993/1001*x1*x8 + 993/1001*x2*x8 + 12/1001*x3*x8 + 985/1001*x4*x8 + 8/1001*x5*x8 + 2/1001*x6*x8 + 981/1001*x7*x8 + 1/1001*x8^2 + 993/1001*x0*x9 + 993/1001*x1*x9 + 12/1001*x2*x9 + 985/1001*x3*x9 + 8/1001*x4*x9 + 2/1001*x5*x9 + 981/1001*x6*x9 + 2/1001*x7*x9 + 989/1001*x8*x9 + 4/1001*x9^2
sage: og_b = L.orthogonal_basis(); og_b long time
[77*e0,
77*e0 + 462*e9,
77*e0 + 77*e8 + 693*e9,
77*e0 + 693*e7 + 385*e8 + 231*e9,
77*e0 + 693*e5 + 154*e7 + 308*e8 + 77*e9,
77*e0 + 693*e5 + 616*e6 + 231*e7 + 462*e8 + 77*e9,
77*e0 + 308*e4 + 462*e5 + 539*e6 + 616*e7 + 77*e8 + 462*e9,
77*e0 + 308*e3 + 154*e4 + 154*e5 + 924*e6 + 770*e7 + 462*e8 + 308*e9,
77*e0 + 770*e2 + 770*e3 + 231*e4 + 77*e5 + 693*e6 + 924*e7 + 77*e8 + 77*e9,
77*e0 + 77*e1 + 231*e2 + 308*e3 + 539*e4 + 847*e5 + 231*e6 + 539*e7 + 847*e8 + 385*e9,
91*e1,
91*e0 + 455*e9,
91*e0 + 819*e8 + 637*e9,
91*e0 + 819*e7 + 455*e8 + 546*e9,
91*e0 + 273*e6 + 637*e7 + 182*e8 + 455*e9,
91*e0 + 364*e5 + 364*e6 + 273*e7 + 455*e8 + 455*e9,
91*e0 + 364*e4 + 91*e5 + 364*e6 + 910*e8 + 455*e9,
91*e0 + 637*e3 + 182*e5 + 364*e6 + 728*e7 + 728*e8 + 182*e9,
91*e0 + 91*e2 + 455*e3 + 910*e4 + 728*e5 + 91*e6 + 455*e7 + 455*e8 + 819*e9,
91*e0 + 455*e1 + 455*e3 + 637*e4 + 364*e5 + 273*e6 + 455*e7 + 728*e8 + 819*e9,
143*e0,
143*e1 + 429*e9,
143*e0 + 715*e8 + 715*e9,
143*e0 + 858*e7 + 143*e8 + 429*e9,
143*e0 + 858*e4 + 286*e7 + 572*e8 + 715*e9,
143*e0 + 858*e4 + 858*e6 + 572*e7 + 429*e8 + 429*e9,
143*e0 + 429*e3 + 858*e4 + 572*e6 + 143*e7 + 572*e8 + 858*e9,
143*e0 + 429*e3 + 858*e4 + 143*e5 + 858*e6 + 572*e7 + 572*e8,
143*e0 + 858*e2 + 429*e3 + 858*e4 + 858*e5 + 429*e6 + 286*e7 + 286*e9,
143*e0 + 143*e1 + 286*e2 + 143*e3 + 572*e5 + 715*e6 + 143*e7 + 858*e8 + 143*e9]
"""
if not (self.is_nondegenerate()):
raise ValueError
if p is None:
U = self.subgroup( self.gens())
elif is_prime(p):
U = self.subgroup( p)
else:
raise TypeError
return U.orthogonal_basis()
def jordan_decomposition( self):
r"""
"""
try:
return self.__jd
except AttributeError:
self.__jd = JordanDecomposition( self)
return self.__jd
def spawn( self, gens, names = None):
r"""
Spawn the subgroup generated by the elements of the list
gens equipped with the quadratic form induced by this module as finite
quadratic module.
EXAMPLES NONE
"""
return self.subgroup( gens).as_ambient( names)
def quotient( self, U):
r"""
Return the quotient module $self/U$ for the isotropic subgroup
$U$ of self. If $U$ is not isotropic an excepion is thrown.
INPUT
U -- a subgroup of self
OUTPUT
quadratic module
EXAMPLES NONE
## sage: A = FiniteQuadraticModule([11,33]);
## sage: A2=A.quotient(list(A.isotropic_subgroups())[0]); A2
## Finite quadratic module ([33, 11], 1/33*x0^2 + 1/11*x0*x1 + 1/11*x1^2) with generators (e0, e1)
NOTES
Let $U^\sharp = K\ZZ^n/M\ZZ^n$ the dual of the subgroup $U =
H\ZZ^n/M\ZZ^n$ of $M$. The quotient module
$(U^\sharp/U, x + U \mapsto Q(x) + \ZZ)$
is then isomorphic to $(\ZZ^n/K^{-1}H\ZZ^n, G[Kx])$.
"""
if not isinstance(U, FiniteQuadraticModule_subgroup) or U.ambience() is not self or not U.is_isotropic():
raise ValueError, "%s: not an isotropic subgroup" %U
V = U.dual()
K = matrix( V)
return FiniteQuadraticModule( K**(-1)*matrix(U), K.transpose()*self.__J*K)
def __div__( self, U):
r"""
Return the quotient of $A/U$.
EAMPLES NONE
"""
return self.quotient( U)
def __pow__( self, s):
r"""
Return the twist $A^s$.
EXAMPLES NONE
"""
return self.twist( s)
def anisotropic_kernel( self):
r"""
Return the anisotropic quotient of this qudaratic module,
i.e. if this module is $A$ then return $A/U$, where $U$
is a maximal isotropic subgroup.
OUTPUT
(A/U, f, g), where $U$ is a maximal isotropic subgroup,
and, where $f:(U^#,Q) \rightarrow A$ and $g:(U^#,Q) \rightarrow A/U$
($Q$ denotes the quadratic form of $A$) are the natural morohisms of quadratic modules.
EXAMPLES NONE
TODO:
Just find a maximal isotropic subgroup
and return the quotient.
"""
raise NotImplementedError
###################################
## Deriving subgroups
###################################
def subgroup( self, arg = []):
r"""
Return a subgroup of the underlying abelian group $U$ of this quadratic module.
Return the subgroup of $U$ generated by the elements in arg if arg is a list or tuple.
Return the $p$-Sylow subgroup if $arg$ is a prime $p$.
INPUT
arg -- a list of elements of this quadratic module or a prime number
EXAMPLES
sage: A.<a,b,c,d,e,f,g> = FiniteQuadraticModule( '11^-3.2_2^4')
sage: A2 = A.subgroup (2); A2
< g, f, e, d >
sage: A3 = A.subgroup (3); A3
< 0 >
sage: A11 = A.subgroup (11); A11
< 2*a, 2*b, 2*c >
sage: A11.order()
1331
sage: A2.order()
16
"""
if isinstance( arg, (list, tuple)):
if [] == list(arg):
arg = [self(0)]
return FiniteQuadraticModule_subgroup( list(arg))
p = Integer(arg)
if is_prime(p):
U = FiniteQuadraticModule_subgroup( list( self.gens()))
U = U.split(p)[0] if 0 == U.order()%p else self.subgroup([self(0)])
return U
raise ValueError
def kernel( self):
r"""
Return the dual subgroup of the underlying group of this module,
i.e. return $\{y \in A : B(y,x) = 0 \text{ for all } x \in A \}$,
for this module $(A,Q)$.
EXAMPLES
sage: A.<a,b> = FiniteQuadraticModule( [3,3], [1/3,1/3,1/3]); A
Finite quadratic module in 2 generators:
gens: a, b
form: 1/3*x0^2 + 1/3*x0*x1 + 1/3*x1^2
sage: U = A.kernel(); U
< a + b >
sage: B = A.quotient(U); B
Finite quadratic module in 2 generators:
gens: e0, e1
form: 1/3*x0^2 + 1/3*x0*x1 + 1/3*x1^2
sage: e0,e1 = B.gens()
sage: e0
2*e1
sage: B.jordan_decomposition().genus_symbol()
'3^-1'
"""
return self.dual_group( self.subgroup(self.gens()))
def dual_group( self, U):
r"""
Return the dual subgroup
$U^\sharp = \{y \in A : B(y,x) = 0 \text{ for all } x \in U \}$
of the subgroup $U$ of $self = (A,Q)$
INPUT
U -- a subgroup of this quadratic module
EXAMPLES NONE
NOTES
If the dual group (w.r.t. the fundamental system) is given
as $K\ZZ^r/E\ZZ^n$ then the
columns of $K$ form a basis for the integral solutions of
$2H^tJx \in \ZZ^n$. We solve this by the trick of augmenting
$2H^tJx$ by the unit matrix and solving the corresonding
system of linear equations over $\ZZ$
"""
H = matrix( U)
X = 2*H.transpose()*self.__J
n = len(self.elementary_divisors())
Y = X.augment( MatrixSpace(QQ,n).identity_matrix())
K0 = matrix(ZZ, Y.transpose().integer_kernel().matrix().transpose())
K = K0.matrix_from_rows( range( n ))
l= [ FiniteQuadraticModuleElement(self, x.list() , can_coords=False ) for x in K.columns() ]
return self.subgroup(l)
def kernel_subgroup(self,c):
r"""
Return the subgroup D_c={ x in D | cx=0}
"""
l=[]
for x in self.list():
y = c*x
if y==self(0):
l.append(x)
return self.subgroup(l)
def power_subgroup(self,c):
r"""
Compute the subgroup D^c={c*x | x in D}
"""
l=[]
for x in self.list():
y = c*x
if y not in l:
l.append(y)
return self.subgroup(l)
def power_subset_star(self,c):
r"""
Compute the subset D^c*={x in D | cQ(y)+(x,y)=0, for all y in D_c}
Using D^c* = x_c + D^c
"""
xc = self.xc(c)
Dc = self.power_subgroup()
res=[]
if xc==self._zero:
return Dc.list()
for x in Dc.list():
res.append(x+xc)
return res
def xc(self,c):
r"""
Compute all non-zero values of the element x_c in the group D
INPUT:
- 'c'~- integer
OUTPUT:
- 'x_c' element of self such that D^{c*} = x_c + D^{c}
"""
if is_odd(c):
return self._zero
k = valuation(c,2)
return self._xc(k)
def _xc(self,k):
r"""
Compute $x_c such that D^{c*} = x_c + D^{c} for c s.t. 2^k || c$
"""
if self._xcs=={}:
self._compute_all_xcs()
if self._xcs.has_key(k):
return self._xcs[k]
return self._zero
def _compute_all_xcs(self):
r"""
Computes all non-zero values of the element x_c in the group D
OUPUT: dictionary k => x_c where 2^k || c
"""
J=self.jordan_decomposition()
res=dict()
res[0 ]=0
for c in J:
xc=0
p,k,r,d = c[1 ][:4 ]
t = None if 4 == len(c[1 ]) else c[1 ][4 ]
if(p<>2 or t==None):
continue
q=2**k # = 2^n
JC=J.constituent(q)
CL=JC[0 ]
# print "CL(",q,")=",JC[0]
HOM=JC[1 ]
# print "t=",t
# We have an odd component
for y in JC[0 ].orthogonal_basis():
# print "basis = ",y
z=JC[1 ](y)
# print "basis = ",z
xc=xc+(2 **(k-1 ))*z
res[k]=xc
self._xcs = res
###################################
## Predicates
###################################
def is_multiplicative( self):
r"""
Return False since finite quadratic modules are modules.
EXAMPLES
sage: var('x')
x
sage: K.<a> = NumberField( x^3-x+1)
sage: A = FiniteQuadraticModule(1/(a+11))
sage: jd = A.jordan_decomposition()
sage: jd.genus_symbol()
'1319'
sage: A.char_invariant(1)
(-zeta8^2, 1/sqrt(1319))
sage: A.is_multiplicative()
False
"""
return False
def is_nondegenerate( self):
r"""
Return True or False accordingly if this module is
non degenerate or not.
EXAMPLES
sage: N = FiniteQuadraticModule(); N
Finite quadratic module in 1 generators:
gens: 0
form: 0
sage: N.is_nondegenerate()
True
"""
return True if 1 == self.kernel().order() else False
def is_isomorphic( self, A):
r"""
Return True or False accordingly as this quadratic module
is isomorphic to $A$ or not.
EXAMPLES
sage: A = FiniteQuadraticModule( '2_2^4')
sage: B = FiniteQuadraticModule( '2_6^-4')
sage: A.is_isomorphic(B)
True
TODO
Extend this function so to include also degenerate modules.
Maybe wo do not need to check all divisors?
"""
if False == self.is_nondegenerate() or False == A.is_nondegenerate():
raise TypeError, 'the quadratic modules to compare must be non degenerate'
if self.elementary_divisors() != A.elementary_divisors():
return False
divs = self.level().divisors()
for t in divs:
if self.char_invariant(t) != A.char_invariant(t):
return False
return True
def is_witt_equivalent( self, A):
r"""
Return True or False accordingly as this quadratic module
is Witt equivalent to $A$ or not.
INPUT
A -- quadratic module
EXAMPLES NONE
TODO
Extend this function so to include also degenerate modules.
"""
if False == self.is_nondegenerate() or False == A.is_nondegenerate():
raise TypeError, 'the quadratic modules to compare must be non degenerate'
if self.tau_invariant() == A.tau_invariant():
a = self.witt_invariants()
b = A.witt_invariants()
if a == b:
return True
return False
###################################
## Deriving other structures
###################################
def as_discriminant_module( self):
r"""
Return a half-integral matrix $F$ such that
this quadratic module is isomorphic to the
discrimnant module
$$D_F = (\ZZ^n/2F\ZZ^n, x + 2F\ZZ^n \mapsto \frac 14 F^{-1}[x] + \ZZ).$$
EXAMPLES NONE
TODO: This will be fun !!! (Look up Wall if his poof is effective ...)
NOTE
If $D_F$ and $D_G$ are isomorphic then there exist even unimodular matrices $U$ and $V$ such that
$F+U$ and $G+V$ are equivalent (viewed as quadratic forms) over $\Z$ (see [Sko]).
"""
pass
def orthogonal_group( self):
r"""
Returns the orthogonal group of this
quadratic module.
EXAMPLES NONE
TODO
Nice topic for a master thesis.
"""
pass
###################################
## Iterators
###################################
def __iter__( self):
r"""
Return a generator over the elements of self.
EXAMPLES NONE return ( x for x in self if self.Q(x) == 0 )
"""
return( self(x, can_coords = False) for x in xmrange( self.elementary_divisors()) )
def values( self):
r"""
If this is $(M,Q)$, return the values of $Q(x)$ ($x \in M$) as a dictionary d.
OUTPUT
dictionary -- the mapping Q(x) --> the number of elements x with the same value Q(x)
EXAMPLES NONE
## sage: A=FiniteQuadraticModule([1,3])
## sage: A.values()[7/12]
## 2
TODO
Replace the code by theoretical formulas
using the Jordan decomposition.
"""
valueDict = {}
for x in self:
v= self.Q( x )
if valueDict.has_key( v ):
valueDict[v] +=1
else:
valueDict[v] = 1
return valueDict
def subgroups( self, d = None ):
r"""
Return a list of all subgroups of $M$ of order $d$, where $M$
is the underlying group of self, or of all subgroups if d is not set.
INPUT
d -- integer
OUTPUT
generator for a list of FiniteQuadraticModule_subgroup of order d
EXAMPLES
sage: A = FiniteQuadraticModule([1,3]); A
Finite quadratic module in 2 generators:
gens: e0, e1
form: 1/4*x0^2 + 1/12*x1^2
sage: list(A.subgroups())
[< e1, e0 >,
< e1 >,
< e0 + e1 >,
< 2*e1, e0 >,
< 2*e1 >,
< 3*e1, e0 >,
< 3*e1 >,
< e0 + 3*e1 >,
< e0 >,
< 0 >]
sage: B.<a> = FiniteQuadraticModule( '25^-1'); B
Finite quadratic module in 1 generators:
gens: a
form: 2/25*x^2
sage: I = [U for U in B.subgroups() if U.is_isotropic()]; I
[< 5*a >, < 0 >]
NOTES
Subgroups are internally represented by lower triangular
matrices in Hermite normal form dividing $M$.
Any subgroup $U$ of a finite abelian group $\ZZ^n/R\ZZ^n$ is of the form
$N\ZZ^n/R\ZZ^n$, where $N$ is a regular integral square
matrix of size $n$ such that $N$ left divides $M$, (i.e. such
that $N^{-1}M$ is an integer matrix). The coset $N
GL(n,\ZZ)$ is uniquely determined by $U$. Recall that any
such coset contains exactly one lower triangular matrix
$H = (h_[ij})$ in Hermite normal form (i.e. $h_{ii}>0$ and
$0\le h_{ij}$ < h_{ii}$ for $j < i$).
Accordingly, this function sets up an iterator over all
matrices in lower Hermite normal form left dividing the diagonal
matrix whose diagonal entries are the elementary divisors of
the underlying abelian group of this module
(and whose determinants equal $self.order()/d$).
TODO
Find a more effective implementation.
Introduce optional arguments which allow to iterate in addition effectively
over all subgroups contained in or containig a certain subgroup, being isotropic etc.
One can use short cuts using e.g. that $N$ defines
an isotropic subgroups if and only if $N^tJN$ is half integral (where $J$ is the Gram matrix
w.r.t the fundamental generators of this module.
"""
elementary_divisors = self.elementary_divisors()
N = len( elementary_divisors)
Mat = ZZ_N_times_N = MatrixSpace(ZZ, N )
def __enumerate_echelon_forms():
"""
Return an iterator over all matrices in HNF
left dividing self.__E.
"""
# If e1, e_2, ... denote the elemetary divisors of self,
# we define a string like
# ( [ [d_0,0], [n_10,d_1], ...]
# for d_0 in divisors(e1)
# for d_1 in divisors(e2)
# for n_10 in range(d_1), ... )
# and evaluate it to obtain our generator.
genString = '['
forStringN = ''
forStringD = ''
for r in range(N):
genString += ' ['
for c in range(N):
if c < r:
v= 'n_'+str(r)+str(c)
genString+= v+','
forStringN+= 'for '+v+' in '+'xrange(d_'+str(r)+') '
elif c==r:
v = 'd_'+str(r)
genString+= v+','
forStringD+= 'for '+v+' in '+'divisors('+str(elementary_divisors[r])+') '
else:
genString+= '0,'
genString = genString[:-1]+ '] ,'
genString = genString[:-1] + ' ] '
genExpression='( ' + genString + forStringD + forStringN +') '
#print genExpression
#print "evaluating:", genExpression
return eval( genExpression )
for h in __enumerate_echelon_forms():
h1 = Mat(h)
if FiniteQuadraticModule_subgroup._divides( h1, self.__E):
f= FiniteQuadraticModule_subgroup( [FiniteQuadraticModuleElement( self, list(x), can_coords = False) for x in h1.transpose()])
if d:
if f.order() == d:
yield f
else:
# d == None means we return every subgroup
yield f
###################################
## Auxiliary functions
###################################
@staticmethod
def _reduce( r):
r"""
Return the fractional part of $x$.
EXAMPLES
sage: FiniteQuadraticModule_ambient._reduce( 297/100)
97/100
"""
return r - r.floor()
@staticmethod
def _reduce_mat( A):
r"""
Return the fractional part of the symmetric matrix $A$.
EXAMPLES
sage: F = matrix(3,3,[1,1/2,3/2,1/2,2,1/9,3/2,1/9,1]); F
[ 1 1/2 3/2]
[1/2 2 1/9]
[3/2 1/9 1]
sage: FiniteQuadraticModule_ambient._reduce_mat(F)
[ 0 0 0]
[ 0 0 1/9]
[ 0 1/9 0]
"""
B = matrix(QQ, A.nrows(), A.ncols())
for i in range(A.nrows()):
for j in range(A.ncols()):
if i == j:
B[i,j] = FiniteQuadraticModule_ambient._reduce( A[i,j])
else:
B[i,j] = FiniteQuadraticModule_ambient._reduce( 2*A[i,j])/2
return B
@staticmethod
def _rdc( R, x):
r"""
Returns the $y \equiv x \bmod R\,ZZ^n$ in the fundamental
mesh $\{R\zeta : 0 \le \zeta_i < 1\}$.
INPUT
x --- an integral vector of length n
R --- a regular nxn matrix in lower Hermite normal form
NOTE
It is absolutely necessary that $R$ comes in lower Hermite
normal form.
EXAMPLES NONE
"""
y=[0]*R.nrows()
k=[0]*R.nrows()
k[0],y[0] = divmod( Integer( x[0]), Integer( R[0,0]))
for i in range(1,R.nrows()):
k[i],y[i] = divmod( Integer( x[i] - sum(R[i,j]*k[j] for j in range(i))), Integer( R[i,i]))
return y
def _f2c( self, x):
r"""
Transform coordinates w.r.t. to the internal fundamental system to the coordinates w.r.t. the generators.
EXAMPLES NONE
"""
v = self.__F2C*vector(ZZ,x)
return list( self._rdc( self.__R, v))
def _c2f( self, x):
r"""
Transform coordinates w.r.t. the generators to coordinates w.r.t. the internal fundamental system.
EXAMPLES NONE
"""
v = self.__C2F*vector(ZZ,x)
return list( self._rdc( self.__E, v))
def Q( self, x):
r"""
Return the value $Q(x)$ (as rational reduced mod $\ZZ$).
INPUT
x -- an FiniteQuadraticModuleElement of self (e.g. x = self.0*17 )
OUTPUT
rational number -- the value of the quadratic form on x
EXAMPLES NONE
"""
c = vector(x.list())
return self._reduce( c.dot_product( self.__J * c))
def B( self, x, y):
r"""
Return the value $B(x,y) = Q(x+y)-Q(x)-Q(y)$ (as rational reduced mod $\ZZ$).
INPUT
x, y -- FiniteQuadraticModuleElements of self
OUTPUT
rational number -- the value of the bilinear form on x and y
EXAMPLES NONE
"""
c = vector( x.list()); d = vector( y.list())
return self._reduce( 2 * c.dot_product( self.__J * d))
# TODO: Adapt Shuichi's Jordan decomposition to implement this
@staticmethod
def _diagonalize( G, n):
r"""
Diagonalizes the matrix $G$ over the localisation $Z_(n)$.
INPUT
G --- a matrix with entries in $Z$
n --- an integer
OUTPUT
A matrix $H$ and a matrix $T$ in $GL(r,Z_(n))$
such that $H = T^tGT$ is in {\em Jordan decomposition form}.
NOTES
Here {\em $H$ is in Jordan decomposition form} means the following:
o $H$ is a block sum of matrices $B_j$ of size 1 or 2
o For each prime power $q=p^l$ dividing $n$, one has
- $H \bmod q$ is diagonal,
- the sequence $gcd(q,H[i,i])$ is increasing,
- for $i > 1$ one has $H[i,i] \equiv p^k \bmod q$ for some $k$
unless $gcd(q, H[i-1,i-1]) < gcd(q, H[i,i])$,
o if $q=2^l$ is the exact 2-power dividing $n$, then
- $B_j$ is scalar or
$B_j \equiv p^k [2,1;1,2] \bmod q$
or $B_j \equiv p^k [0,1;1,0] \bmod q$ for some $k$.
(- maybe later also a sign walk and oddity fusion normalisation)
o An implementation could follow:
[Sko 1] Nils-Peter Skoruppa, Reduction mod $\ell$ of Theta Series of Level $\ell^n$,
arXiv:0807.4694
"""
# matrices over $Z/nZ$: matrix( IntegerModRing(n), r, [...])
# see also: http://www.sagemath.org/doc/html/ref/module-sage.rings.polynomial-quotient-ring-element.html
pass
###################################
## Misc
###################################
def random_element(self, bound=None):
"""
Return a random element of this group.
EXAMPLES NONE
"""
L= [ randrange(0, ed ) for ed in self.__elementary_divisors ]
return FiniteQuadraticModuleElement( self, L )
def cayley_graph(self):
"""
Returns the cayley graph for this finite group, as a SAGE
DiGraph object. To plot the graph with different colors
EXAMPLES
sage: A.<a,b> = FiniteQuadraticModule( matrix( QQ, 2, [2,1,1,6])); A
Finite quadratic module in 2 generators:
gens: 5*b, b
form: 3/11*x0^2 + 10/11*x0*x1 + 1/11*x1^2
sage: D = A.cayley_graph (); D
Digraph on 11 vertices
sage: g = D.plot(color_by_label=True, edge_labels=True)
TODO
Make the following work:
D.show3d(color_by_label=True, edge_size=0.01, edge_size2=0.02, vertex_size=0.03)
Adjust by options so that images is less cluttered
NOTE
Copied from sage.groups.group.FiniteGroup.cayley_graph().
"""
#from sage.graphs.graph import DiGraph
arrows = {}
for x in self:
arrows[x] = {}
for g in self.gens():
xg = x+g
if not xg == x:
arrows[x][xg] = g
return DiGraph(arrows, implementation='networkx')
def _is_valid_homomorphism_(self, codomain, im_gens):
r"""
Return True if \code{im_gens} defines a valid homomorphism
from self to codomain; otherwise return False.
EXAMPLES NONE
NOTE
If $A = \ZZ^n/R$ and $B = \ZZ^m/S$, then \code{im_gens}
defines a valid homomorphism if $S^-1MS$ is an integral
matrix, where $M$ is the matrix whose colums are the coordinates
of the elements of \code{im_gens} w.r.t. the can. system.
"""
if not isinstance( im_gens, (tuple, list)):
x = Sequence( [im_gens])
x = Sequence( im_gens)
if not x.universe() is codomain:
raise TypeError, 'im_gens (=%s) must belong to %s' %( im_gens, codomain)
m = matrix([ x[i].c_list() for i in range(len(im_gens))]).transpose()
return FiniteQuadraticModule_subgroup._divides( codomain.relations(), m *self.relations())
def _Hom_(self, B, cat = None):
r"""
Return the set of morphism from this quadratic module to $B$.
EXAMPLES
sage: A = FiniteQuadraticModule( matrix( QQ, 2, [2,1,1,2]))
sage: B = 2*A
sage: S = A._Hom_(B)
Set of Homomorphisms from Finite quadratic module in 2 generators:
gens: e1, e1
form: 1/3*x0^2 + 2/3*x0*x1 + 1/3*x1^2 to Finite quadratic module in 4 generators:
gens: e1, e1, e3, e3
form: 1/3*x0^2 + 2/3*x0*x1 + 1/3*x1^2 + 1/3*x2^2 + 2/3*x2*x3 + 1/3*x3^2
"""
if not (cat is None or (cat is B.category() and cat is self.category())):
raise NotImplementedError
# if not isinstance( B, FiniteQuadraticModule_ambient):
if not hasattr(B,'_is_FiniteQuadraticModule_ambient'):
raise TypeError, "B (=%s) must be finte quadratic module."%B
return FiniteQuadraticModuleHomset(self, B)
def hom(self, x):
r"""
Return the homomorphism from this module to the parent module of the
elements in the list which maps the $i$-th generator of this module
to the element \code{x[i]}.
INPUT
x -- a list of $n$ elements of a quadratic module, where $n$ is the number
of generators of this quadratic module.
EXAMPLES NONE
"""
v = Sequence(x)
B = v.universe()
#if not isinstance( B, FiniteQuadraticModule_ambient):
if not hasattr(B,'_is_FiniteQuadraticModule_ambient'):
raise TypeError, "B (=%s) must have universe a FiniteQuadraticModule."%B
return self.Hom(B)(x)
###################################
## MORPHISMS
###################################
from sage.groups.group_homset import GroupHomset_generic
from sage.categories.homset import HomsetWithBase
from sage.categories.commutative_additive_groups import CommutativeAdditiveGroups
from sage.categories.morphism import Morphism
class FiniteQuadraticModuleHomset (GroupHomset_generic):
r"""
Implements the set of morphisms of a quadratic module into another.
EXAMPLES NONE
"""
def __init__( self, A, B):
r"""
INPUT
A, B -- finite quadratic modules
EXAMPLES NONE
"""
HomsetWithBase.__init__(self, A, B, CommutativeAdditiveGroups(), base = A.base_ring())
def __call__(self, im_gens, check=True):
"""
EXAMPLES NONE
"""
try:
return FiniteQuadraticModuleHomomorphism_im_gens( self, im_gens, check = check)
except (NotImplementedError, ValueError), err:
print err
raise TypeError, "images (=%s) do not define a valid homomorphism"%im_gens
class FiniteQuadraticModuleHomomorphism_im_gens (Morphism):
r"""
Implements elements of the set of morphisms between two quadratic modules.
EXAMPLES
sage: A = FiniteQuadraticModule( matrix( QQ, 2, [2,1,1,2])); B = 2*A; S=A._Hom_(B); u,v = A.gens(); a,b,c,d = B.gens();
sage: f = S([a,b]); f
Homomorphism : Finite quadratic module in 2 generators:
gens: e1, e1
form: 1/3*x0^2 + 2/3*x0*x1 + 1/3*x1^2 --> Finite quadratic module in 4 generators:
gens: e1, e1, e3, e3
form: 1/3*x0^2 + 2/3*x0*x1 + 1/3*x1^2 + 1/3*x2^2 + 2/3*x2*x3 + 1/3*x3^2
sage: f(u),f(v),f(2*v),f(0)
(e1, e1, 2*e1, 0)
"""
def __init__( self, homset, im_gens, check = True):
r"""
INPUT
homset -- a set of modphisms between two quadratic modules
im_gens -- a list of elements of the codomain.
EXAMPLES NONE
"""
Morphism.__init__( self, homset) # sets the parent
if not isinstance(im_gens, Sequence_generic):
if not isinstance(im_gens, (tuple, list)):
im_gens = [im_gens]
#print im_gens[0].parent() is homset.codomain()
im_gens = Sequence( im_gens, homset.codomain())
if check:
if len(im_gens) != homset.domain().ngens():
raise ValueError, "number of images must equal number of generators"
t = homset.domain()._is_valid_homomorphism_( homset.codomain(), im_gens)
if not t:
raise ValueError, "relations do not all (canonically) map to 0 under map determined by images of generators."
self.__im_gens = im_gens
# For effeciency, we compute the images of the fundamental generators of the domain
n = len( im_gens)
self.__c_im_gens = []
for x in homset.domain().fgens():
cos = x.c_list()
y = sum( im_gens[i]*cos[i] for i in range( n))
self.__c_im_gens.append( y)
def kernel(self):
r"""
Return the kernel of this morphism.
EXAMPLES NONE
"""
pass
def image(self, J):
r"""
Return the image of this morphism.
EXAMPLES NONE
"""
pass
def _repr_(self):
r"""
EXAMPLES NONE
"""
return "Homomorphism : %s --> %s"%(self.domain(),self.codomain())
def _latex_(self):
r"""
EXAMPLES NONE
"""
return "%s \\rightarrow{} %s"%(latex(self.domain()), latex(self.codomain()))
def __call__( self, x):
r"""
EXAMPLES NONE
"""
if not x in self.domain():
raise TypeError, 'x (=%s) must be in %s' %(x,self.domain())
n = len(self.__c_im_gens)
cos = x.list()
return sum( self.__c_im_gens[i]*cos[i] for i in range(n))
###################################
## CONVENIENCE FUNCTION
###################################
def _A( q, s = 1, **args):
r"""
Return the quadratic module $A_q^s$ as defined in [Sko].
EXAMPLES
sage: A = _A(3); A
Finite quadratic module in 1 generators:
gens: e
form: 1/3*x^2
sage: B = _A(5,-2); B
Finite quadratic module in 1 generators:
gens: e
form: 3/5*x^2
sage: C.<a> = _A(2^5); C
Finite quadratic module in 1 generators:
gens: a
form: 1/64*x^2
sage: a.order()
32
"""
q = Integer(q)
s = Integer(s)
if q > 1 and q.is_prime_power() and 1 == q.gcd(s):
if is_odd(q):
return FiniteQuadraticModule( [q], [s/q], **args)
else:
return FiniteQuadraticModule( [q], [s/(2*q)], **args)
raise ValueError, 'q (=%s) must be prime power and s (=%s) relatively prime to q' %(q,s)
def _B( q, **args):
r"""
Return the quadratic module $C_q$ as defined in [Sko].
EXAMPLES
sage: B.<a,b> = _B(2^3); B
Finite quadratic module in 2 generators:
gens: a, b
form: 1/8*x0^2 + 1/8*x0*x1 + 1/8*x1^2
sage: (a+b).order()
8
"""
q = Integer(q)
if is_even(q) and q.is_prime_power():
return FiniteQuadraticModule( [q,q], matrix( QQ, 2, [1/q, 1/(2*q), 1/(2*q), 1/q]), **args)
raise ValueError, 'q = (%s) must be q power of 2'%q
def _C( q, **args):
r"""
Return the quadratic module $C_q$ as defined in [Sko].
EXAMPLES
sage: C.<a,b> = _C(2); C
Finite quadratic module in 2 generators:
gens: a, b
form: 1/2*x0*x1
sage: C.exponent()
2
"""
q = Integer(q)
if is_even(q) and q.is_prime_power():
return FiniteQuadraticModule( [q,q], matrix( QQ, 2, [0, 1/(2*q), 1/(2*q), 0]), **args)
raise ValueError, 'q = (%s) must be q power of 2'%q
def _FiniteQuadraticModule_from_string( S, **args ):
r"""
Return the quadratic module described by the string S.
INPUT
S -- a string representing Jordan constituents of a finite quadratic modules
NOTES
The strings which will be accepted have the form
$$
'a^{\pm k}.b^{\pm l}.c^{\pm m}. \dots',
$$
where $a$, $b$, $c$, \dots are prime powers, and where $k$, $l$, etc.
are positive integers (if an exponent $\pm k$ equals 1 it can be ommitted).
If the $a$, $b$, \dots are powers of $2$ we admit also subscripts $t$, i.e. symbols
of the form $a_t^{\pm k}$, where $0\le t < 8$ is an integer.
The dot corresponds to the direct sum of quadratic modules, and the symbols $a^{\pm k}$, \dots
have the following meaning:
For a $2$-power $a$, the symbol $a^{+k}$, indicates the $k/2$-fold direct sum of the module $B = (\ZZ^2/a\ZZ^2, xy/a)$,
whereas the symbol $a^{-k}$ denotes the module $(\ZZ^2/a\ZZ^2, (x^2+xy+y^2)/a)$ plus the $k/2-1$-fold sum of $(\ZZ^2/a\ZZ^2, xy/a)$.
A symbol $a^{\pm k}$, for an odd prime power $a$, indicates the quadratic module
$A_a^e+(k-1)A_a$, where $e$ is an integer such that the Legendre symbol $2^k e$ over $p$ equals $\pm 1$.
A symbold $a_t^{\pm k}$, for a $2$-power $a$, indicates the quadratic module
$A_a^{c_1}+\cdots + A_a^{c_k}$, where the $c_i$ are odd integers such that
$D := c_1 \cdots c_k$ is a quadratic residue or non-residue modulo $8$ according to
the sign $\pm$, and where $c_1 + \cdots + c_k \equiv t \bmod 8$. Here, for even $a$, we
use $A_a = (\ZZ/a\ZZ, x^2/2a)$.
Note that, for a symol $2^{\pm k}$, the $k$ must be even.
Furthermore, a solution $(c_1,\dots,c_k)$ of the equations $\sum c_i \equiv t \bmod 8$ and
legendre symbol of 8 over $\prod c_i$ equal to $\pm 1$ exists if and only if
$t \equiv k \bmod 2$, legendre symbol of $8$ over $t$ equal to $\pm 1$ for $k=1$,
if $t\equiv 0 \bmod 8$ then $\pm 1 = +1$ and if $t\equiv 4 \bmod 8$ then \pm 1 = -1$
for $k=2$. If any of these conditions is not fullfilled an error is raised.
EXAMPLES
sage: A.<a,b,c,d> =_FiniteQuadraticModule_from_string ('3^-1.3.5^2'); A
Finite quadratic module in 4 generators:
gens: a, b, c, d
form: 2/3*x0^2 + 1/3*x1^2 + 1/5*x2^2 + 1/5*x3^2
sage: A =_FiniteQuadraticModule_from_string ('8^+6'); A
Finite quadratic module in 6 generators:
gens: e0, e1, e2, e3, e4, e5
form: 1/8*x0*x1 + 1/8*x2*x3 + 1/8*x4*x5
sage: A.elementary_divisors ()
(8, 8, 8, 8, 8, 8)
sage: A =_FiniteQuadraticModule_from_string ('8_1^+3'); A
Finite quadratic module in 3 generators:
gens: e0, e1, e2
form: 1/16*x0^2 + 1/16*x1^2 + 15/16*x2^2
sage: A.elementary_divisors ()
(8, 8, 8)
sage: D.<a,b,c,d,e> = _FiniteQuadraticModule_from_string ('8_1^3.4^-2'); D
Finite quadratic module in 5 generators:
gens: a, b, c, d, e
form: 1/16*x0^2 + 1/16*x1^2 + 15/16*x2^2 + 1/4*x3^2 + 1/4*x3*x4 + 1/4*x4^2
sage: D.level(), D.exponent(), D.order(), D.elementary_divisors ()
(16, 8, 8192, (8, 8, 8, 4, 4))
sage: E.<a,b,c,d,e,f,g> = _FiniteQuadraticModule_from_string ('8_1^3.4^-2.3^-1.11^-1'); E
Finite quadratic module in 7 generators:
gens: a, b, c, d, e, f, g
form: 1/16*x0^2 + 1/16*x1^2 + 15/16*x2^2 + 1/4*x3^2 + 1/4*x3*x4 + 1/4*x4^2 + 1/3*x5^2 + 1/11*x6^2
sage: E.elementary_divisors ()
(264, 8, 8, 4, 4)
TECHNICAL NOTES
The accepted strings can be described in BNF as follows:
\begin{verbatim}
<S> ::= <symbol_list>
<symbol_list> ::= <symbol_list> "." <symbol> | <symbol>
<symbol> ::= <p-power> | <p-power>"^"<exponent> |
<2-power> "_" type | <2-power> "_" <type> "^" <exponent>
<p-power> ::= number
<2-power> ::= number
<type> ::= number
<exponent> ::= number | "+"number | "-"number
\end{verbatim}
Of course, we impose the additional requirements that
number is a positive integer, and number and type satisfy the above requierements.
"""
S= S.replace(' ','') # filter out spaces
List= S.split('.')
ElementList = []
for item in List:
L1 = item.split("^")
if len(L1) > 2: # more than one ^ in item
raise ValueError
elif len(L1) == 2:
k = Integer(L1[1])
else:
k = 1
L1= L1[0].split("_")
a = Integer(L1[0])
if len(L1) > 2: # more than one _ in item
raise ValueError
elif len(L1) == 2:
if Integer(L1[1]) in range(8):
t = Integer(L1[1])
else:
raise ValueError, "Type given, which ist not in 0..7: %s"%(L1[1] )
else:
t = None
if not (k != 0 and a != 1 and a.is_prime_power()
and ( None == t or (is_even(a) and t%2 == k%2))
and ( not (None == t and is_even(a)) or 0 == k%2)
):
raise ValueError,"{0} is not a valid signature!".format(S)
c = None
if is_odd(a):
c = [1]*abs(k)
p = a.factor()[0][0]
s = kronecker(2,p)**k
if s*k < 0:
c[0] = -1 if 3 == p%4 else primitive_root(p)
if is_even(a) and t != None:
if 1 == abs(k):
if k == kronecker(t,2):
c = [t]
else:
raise ValueError
if abs(k) > 1:
CP= eval( "CartesianProduct(" + "[1,3,5,7]," *(abs(k)-1) + ")" )
# TODO: find better algorithm
e = 1 if k > 0 else -1
for x in CP:
s = sum(x)%8
if kronecker( prod(x)*(t-s),2) == e:
x.append(t-s)
c = x
break
if not c:
raise ValueError
entry = {'a':a, 'k':k, 't':t, 'c':c}
ElementList.append( entry )
names = args.pop('names', None)
# TODO: Once the 0-module is cached replace the next 6 lines by: A = FiniteQuadraticModule()
sym = ElementList[0]
q = sym['a']; t = sym['t']; k = sym['k']
if is_odd(q) or t != None:
A = sum( _A(q,s,**args) for s in sym['c'])
if is_even(q) and None == t:
A = _C(q, **args)*(k//2) if k > 0 else _B(q, **args)
if (-k)//2 > 1:
A += _C(q, **args)*((-k)//2 - 1)
for sym in ElementList[1:]:
q = sym['a']; t = sym['t']; k = sym['k']
if is_odd(q) or t != None:
A += sum( _A(q,s,**args) for s in sym['c'])
if is_even(q) and None == t:
A += _C(q, **args)*(k//2) if k > 0 else _B(q, **args)
if (-k)//2 > 1:
A += _C(q, **args)*((-k)//2 - 1)
A = FiniteQuadraticModule_ambient( A.relations(), A.gram(), names = names, **args)
return A
def FiniteQuadraticModule( arg0=None, arg1=None, **args):
r"""
Create an instance of the class FiniteQuadraticModule_ambient.
INPUT
Supported formats:
N. FiniteQuadraticModule():
the trivial quadratic module
S. FiniteQuadraticModule( string):
the quadratic module $(L^#/L, B(x,x)/2)$, where $(L,B)$
is a $\Z_p$-lattice encoded by the string as described
in Conway-Sloane, p.???. TODO: look up ???
L. FiniteQuadraticModule( list):
discriminant module constructed from the diagonal matrix
with $2*x$ and $x$ running through list on its diagonal.
M. FiniteQuadraticModule( matrix):
discriminant module constructed from a regular
symmetric even integral matrix.
F. FiniteQuadraticModule( number_field_element):
For a nonzero $\omega$ in a numberfield $K$,
the quadratic module $(\ZZ_K/A, x+A \mapsto tr( \omega x^2) + \ZZ)$,
where $A$ is determined by
$\omega D = B/A$ with relatively prime ideals $A$, $B$,
and with $D$ denoting the different of $K$.
LL. FiniteQuadraticModule( list_of_orders, list_of_coeffs):
for a list of orders $[e_i]$ of size $n$ and a list of
coeficients $[a_{ij}]$, the quadratic module
$(\ZZ/e_1\times\cdots\times\ZZ/e_n,class(x)\mapsto\sum_{i\le j} a_{ij} x_i x_j)$.
LM. FiniteQuadraticModule( list_of_orders, Gram_matrix):
for a list of orders $[e_i]$ of size $n$ and a
symmetric matric $G$, the quadratic module
$(\ZZ/e_1 \times \cdots \times \ZZ/e_n, class(x) \mapsto G[x] + \ZZ)$.
ML. FiniteQuadraticModule( matrix, list_of_coeffs):
for a matrix $R$ of size $n$ and a list of coefficients
$[a_{ij}]$, the quadratic module
$(\ZZ^n/R\ZZ^n, x+R\ZZ^n \mapsto \sum_{i\le j} a_{ij} x_i x_j)$.
MM. FiniteQuadraticModule( matrix, Gram_matrix):
for a matrix $R$ and a symmetric matric $G$, the
quadratic module $(\ZZ^n/R\ZZ^n, x+R\ZZ^n \mapsto G[x] + \ZZ)$.
EXAMPLES
sage: N.<n> = FiniteQuadraticModule(); N
Finite quadratic module in 1 generators:
gens: 0
form: 0
sage: n.order()
1
sage: S.<x,y,z> = FiniteQuadraticModule( '7^-1.3.2_3^-1'); S
Finite quadratic module in 3 generators:
gens: x, y, z
form: 6/7*x0^2 + 1/3*x1^2 + 3/4*x2^2
sage: L.<w> = FiniteQuadraticModule( [13]); L
Finite quadratic module in 1 generators:
gens: w
form: 1/52*x^2
sage: E8 = matrix( ZZ, 8, [4,-2,0,0,0,0,0,1,-2,2,-1,0,0,0,0,0,0,-1,2,-1,0,0,0,0,0,0,-1,2,-1,0,0,0,0,0,0,-1,2,-1,0,0,0,0,0,0,-1,2,-1,0,0,0,0,0,0,-1,2,0,1,0,0,0,0,0,0,2]); E8
[ 4 -2 0 0 0 0 0 1]
[-2 2 -1 0 0 0 0 0]
[ 0 -1 2 -1 0 0 0 0]
[ 0 0 -1 2 -1 0 0 0]
[ 0 0 0 -1 2 -1 0 0]
[ 0 0 0 0 -1 2 -1 0]
[ 0 0 0 0 0 -1 2 0]
[ 1 0 0 0 0 0 0 2]
sage: M.<a,b,c,d,e,f,g,h> = FiniteQuadraticModule( 3*F); M
Finite quadratic module in 8 generators:
gens: a, b, c, d, e, f, g, h
form: 1/3*x0^2 + 2/3*x0*x2 + 2/3*x1*x2 + 1/3*x0*x3 + 1/3*x1*x3 + 1/3*x3^2 + 2/3*x0*x5 + 2/3*x1*x5 + 1/3*x3*x5 + 2/3*x4*x5 + 1/3*x0*x6 + 1/3*x1*x6 + 2/3*x3*x6 + 1/3*x4*x6 + 1/3*x6^2 + 2/3*x0*x7 + 2/3*x2*x7 + 1/3*x3*x7 + 2/3*x5*x7 + 1/3*x6*x7 + 2/3*x7^2
sage: X = QQ['X'].0
sage: K.<x> = NumberField(X^4-8*X^3+1); K
Number Field in x with defining polynomial X^4 - 8*X^3 + 1
sage: F.<a,b,c,d> = FiniteQuadraticModule((x^2-4)/7); F
Finite quadratic module in 4 generators:
gens: a, b, c, d
form: 6/7*x0^2 + 1/7*x0*x1 + 5/7*x1*x2 + 5/7*x0*x3 + 6/7*x2*x3 + 3/7*x3^2
sage: LL = FiniteQuadraticModule([3,4,30],[1/3,0,1/3,1/8,5/2,7/60]); LL
Finite quadratic module in 3 generators:
gens: e0, e1, e2
form: 1/3*x0^2 + 1/8*x1^2 + 1/3*x0*x2 + 1/2*x1*x2 + 7/60*x2^2
sage: LL.elementary_divisors ()
(60, 6)
sage: LL2.<u,v> = FiniteQuadraticModule( [5,5], [3/5,1/5,4/5]); LL2
Finite quadratic module in 2 generators:
gens: u, v
form: 3/5*x0^2 + 1/5*x0*x1 + 4/5*x1^2
sage: LL2.is_nondegenerate ()
True
sage: G = matrix(3,3,[1,1/2,3/2,1/2,2,1/9,3/2,1/9,1]); G
[ 1 1/2 3/2]
[1/2 2 1/9]
[3/2 1/9 1]
sage: LM = FiniteQuadraticModule([4,9,18],G); LM
Finite quadratic module in 3 generators:
gens: e0, e1, e2
form: 2/9*x1*x2
sage: LM.is_nondegenerate ()
False
sage: M = matrix( 2, [4,1,1,6]); M
[4 1]
[1 6]
sage: ML.<s,t> = FiniteQuadraticModule( M, [3/23,-1/23,2/23]); ML
Finite quadratic module in 2 generators:
gens: 17*t, t
form: 3/23*x0^2 + 22/23*x0*x1 + 2/23*x1^2
sage: E = matrix( 2, [8,3,3,10]); E
[ 8 3]
[ 3 10]
sage: MM.<x,y> = FiniteQuadraticModule( E, 1/2 * E^-1); MM
Finite quadratic module in 2 generators:
gens: 44*y, y
form: 5/71*x0^2 + 68/71*x0*x1 + 4/71*x1^2
"""
if arg0 is None:
#N. FiniteQuadraticModule():
if not 'check' in args:
args['check'] = False
return FiniteQuadraticModule_ambient( matrix(1,[1]), matrix(1,[0]), **args)
elif hasattr(arg0,"_is_FiniteQuadraticModule_ambient"):
return copy(arg0)
if arg1 is None:
if isinstance( arg0, str):
#S FiniteQuadraticModule( string)
if not 'check' in args:
args['check'] = False
return _FiniteQuadraticModule_from_string( arg0, **args )
elif isinstance(arg0, list):
#L. FiniteQuadraticModule( list_of_orders):
M = matrix( ZZ, len(arg0), len(arg0), \
dict([((i,i),2*arg0[i]) for i in range(len(arg0))]))
G= QQ(1)/QQ(2) * M**(-1)
elif isinstance(arg0,(int,Integer)):
M = matrix(ZZ,1,1,[arg0])
G= QQ(1)/QQ(2) * M**(-1)
elif hasattr(arg0, '_matrix_'):
#M. FiniteQuadraticModule( matrix):
M = matrix( ZZ, arg0)
G = QQ(1)/QQ(2) * M**(-1)
elif isinstance( arg0,NumberFieldElement):
#F. FiniteQuadraticModule( number_field_element):
if arg0.is_zero():
raise ValueError, "%s: must be nonzero" %arg0
K = arg0.parent()
d = K.different()
n = K.degree()
l = K.integral_basis()
# Find G:
G = matrix(QQ,n,n)
for i in range(n):
for j in range(n):
G[i,j]=(arg0*l[j]*l[i]).trace()
# Compute the denominator ideal of omega*different:
p = arg0*d
s = p.factor()
A=K.ideal([1])
for i in range(len(s)):
s_factor=s[i]
if s_factor[1] < 0:
A=A*s_factor[0]**(-s_factor[1])
# Compute M as the product of two matrices:
L=matrix(QQ,n,n)
for j in range(n):
for i in range(n):
L[j,i]=A.integral_basis()[i].list()[j]
E=matrix(QQ,n,n)
for j in range(n):
for i in range(n):
E[j,i]=l[i].list()[j]
M=E**(-1)*L
else:
raise ValueError,"Can not construct finite quadratic module from {0}".format(arg0)
else:
if isinstance(arg0, list):
M = matrix( ZZ, len(arg0), len(arg0), dict([((i,i),arg0[i]) for i in range(len(arg0))]))
elif hasattr(arg0, '_matrix_'):
M = matrix( ZZ, arg0);
else:
raise TypeError, "%s: should be None, a matrix or a list" %arg0
if isinstance(arg1, list):
#LL./ML. FiniteQuadraticModule( list_of_orders/matrix, list_of_coeffs):
n = M.nrows()
G = matrix(QQ,n,n)
i = j = 0
for g in arg1:
if i == j:
G[i,j] = g - g.floor();
else:
G[i,j] = G[j,i] = QQ(g - g.floor())/QQ(2);
j += 1
if n == j:
i += 1; j = i
elif hasattr(arg1, '_matrix_'):
#LM./.MM FiniteQuadraticModule( list_of_orders/matrix, Gram matrix):
G = matrix(QQ, arg1);
else:
raise TypeError, "%s: should be None, a matrix or a list" %arg1
return FiniteQuadraticModule_ambient( M, G, **args)
# comments reviewed up to here
###################################
## CLASS QUAD_MODULE_ELEMENT
###################################
class FiniteQuadraticModuleElement(AdditiveGroupElement):
r"""
Describes an element of a quadratic module.
EXAMPLES NONE
## sage: p = FiniteQuadraticModule([3,3])
## sage: g0,g1 = p.gens()
## sage: x = g0 + g1*5; x
## e0 + 5*e1
## sage: -x
## 5*e0 + e1
## sage: x*1001 + g1
## 5*e0 + 2*e1
## sage: p.Q(x)
## 1/6
NOTES
Code partly grabbed from sage.structure.element.AbelianGroupElement.
"""
def __init__( self, A, x, can_coords = False):
r"""
Create the element of the FiniteQuadraticModule_ambient A whose coordinates
with respect to the generators of $A$ (resp. fundamental
generators if can_ccords = False)
are given by the list x; create the zero element if $x=0$.
INPUT
A -- quadratic module
x -- list or 0
OUTPUT
an element of the quadratic module A
EXAMPLES NONE
## sage: q = FiniteQuadraticModule( [2,4]);
## sage: x = FiniteQuadraticModuleElement( q, [1,1])
## sage: x
## e0 + e1
"""
AdditiveGroupElement.__init__( self, A)
self.__repr = None
ed = A.elementary_divisors()
n = len(ed)
if isinstance(x, (int, Integer)) and 0 == x:
self.__intl_rep = [ 0 for i in range(n) ]
elif isinstance(x, list):
y = A._c2f( x) if can_coords == True else x
self.__intl_rep = [ y[i]%ed[i] for i in range(n) ]
else:
raise TypeError, "Argument x (= %s) is of wrong type."%x
###################################
## Introduce myself ...
###################################
def _latex_( self):
r"""
EXAMPLES NONE
"""
s = ""
A = self.parent()
x = A.variable_names()
n = len( A.variable_names())
v = A._f2c( self.list())
for i in range(n):
if v[i] == 0:
continue
elif v[i] == 1:
if len(s) > 0: s += " + "
s += "%s"%x[i]
else:
if len(s) > 0: s += " + "
s += "%s \cdot %s"%(latex(v[i]),x[i])
if len(s) == 0: s = "0"
return s
def _repr_( self):
r"""
EXAMPLES NONE
"""
s = ""
A = self.parent()
x = A.variable_names()
n = len( A.variable_names())
v = A._f2c( self.list())
for i in range(n):
if v[i] == 0:
continue
elif v[i] == 1:
if len(s) > 0: s += " + "
s += "%s"%x[i]
else:
if len(s) > 0: s += " + "
s += "%s*%s"%(v[i],x[i])
if len(s) == 0: s = "0"
return s
###################################
## Providing struct. defining items
###################################
def list( self):
r"""
Return the cordinates of self w.r.t. the fundamental
generators of self.parent() as a list.
EXAMPLES NONE
"""
return self.__intl_rep
def c_list( self):
r"""
Return the cordinates of self w.r.t. the fundamental
generators of self.parent() as a list.
EXAMPLES NONE
"""
return self.parent()._f2c( self.__intl_rep)
def _vector_( self):
r"""
Return the cordinates of self w.r.t. the fundamental
generators of self.parent() as a vector.
EXAMPLES NONE
"""
return vector( self.list())
###################################
## Operations
###################################
def _add_( self, y):
r"""
EXAMPLES NONE
"""
# Same as _mul_ in FreeAbelianMonoidElement except that the
# exponents get reduced mod the invariant.
invs = self.parent().elementary_divisors()
n = len( invs)
z = FiniteQuadraticModuleElement( self.parent(), 0)
xelt = self.__intl_rep
yelt = y.__intl_rep
zelt = [ xelt[i]+yelt[i] for i in range(len(xelt)) ]
if len(invs) >= n:
L = []
for i in range(len(xelt)):
if invs[i]!=0:
L.append(zelt[i]%invs[i])
if invs[i]==0:
L.append(zelt[i])
z.__intl_rep = L
if len(invs) < n:
L1 = []
for i in range(len(invs)):
if invs[i]!=0:
L1.append(zelt[i]%invs[i])
if invs[i]==0:
L1.append(zelt[i])
L2 = [ zelt[i] for i in range(len(invs),len(xelt)) ]
z.__intl_rep = L1+L2
return z
#TODO use l_action, r_action and _mule_ for the scalar product
def __mul__( self, _n):
r"""
requires that len(invs) = n
EXAMPLES NONE
"""
n = int(_n)
if n != _n:
raise TypeError, "Argument n (= %s) must be an integer."%n
invs = self.parent().elementary_divisors()
N = len( invs)
z = FiniteQuadraticModuleElement( self.parent(), 0)
if n < 0:
L =[(n*self.__intl_rep[i])%invs[i] for i in range(N)]
z.__intl_rep = L
return z
elif n == 0:
return z
elif n == 1:
return self
elif n == 2:
return self + self
k = n//2
return self*k + self*(n-k)
def __neg__( self):
r"""
EXAMPLES NONE
"""
return self.__mul__(-1)
def __sub__( self, x):
r"""
EXAMPLES NONE
"""
return self._add_( -x)
def __cmp__( self, other,):
r"""
EXAMPLES NONE
"""
if(not isinstance(other,type(self))): return False
return self.__intl_rep == other.__intl_rep
def __eq__(self,other):
r"""
Test if two FQMElements are equal.
"""
if not isinstance(other,type(self)): return False
if not self.parent()==other.parent(): return False
return self.__intl_rep == other.__intl_rep
def __ne__(self,other):
r"""
Test if two FQMElements are equal.
"""
return not self.__eq__(other)
###################################
## Associated quantities
###################################
def order( self):
r"""
Returns the order of this element.
EXAMPLES
sage: F.<a,b,c> = FiniteQuadraticModule([2,12,34]); F
Finite quadratic module in 3 generators:
gens: a, b, c
form: 1/8*x0^2 + 1/48*x1^2 + 1/136*x2^2
sage: x = a - b
sage: x.order()
24
"""
A = self.parent()
if self == FiniteQuadraticModuleElement( A, 0):
return Integer(1)
invs = A.elementary_divisors()
L = list(self.__intl_rep)
N = lcm([invs[i]/gcd(invs[i],L[i]) for i in range(len(invs)) if L[i]!=0])
return N
def norm( self):
r"""
If this element is $a$ and belongs to the module $(M,Q)$ then
return $Q(a)$.
EXAMPLES NONE
"""
return self.parent().Q( self)
def dot( self, b):
r"""
If this element is $a$ and belongs a module with associated
bilinear form $B$ then return $B(a,b)$.
EXAMPLES NONE
"""
return self.parent().B( self, b)
###################################
## CLASS QUAD_MODULE_SUBGROUP
###################################
class FiniteQuadraticModule_subgroup(AbelianGroup):
r"""
Descibes a subgroup of the underlying group of a finite quadratic module.
EXAMPLES NONE
## sage: p=FiniteQuadraticModule([2,3,10])
## sage: U = FiniteQuadraticModule_subgroup( [p.0*30])
## sage: U.is_isotropic()
## True
## sage: p1 = U.quotient(); p1
## Finite quadratic module ([30, 2, 2], 7/30*x0^2 + 1/2*x0*x1 + 1/2*x1^2 + 1/4*x2^2) with generators (e0, e1, e2)
## sage: V = p1( matrix( ZZ, 3, 2, range(6))); V
## Subgroup generated by [e0 + e1 + e2] of the Finite quadratic module ([30, 2, 2], 7/30*x0^2 + 1/2*x0*x1 + 1/2*x1^2 + 1/4*x2^2) with generators (e0, e1, e2).
## sage: W = V.dual(); W
## Subgroup generated by [15*e0 + e2, e1 + e2] of the Finite quadratic module ([30, 2, 2], 7/30*x0^2 + 1/2*x0*x1 + 1/2*x1^2 + 1/4*x2^2) with generators (e0, e1, e2).
## sage: V.order(), W.order(), p1.order()
## (30, 4, 120)
"""
def __init__( self, gens):
r"""
Construct the subgroup generated by the list gens of
elements of the quadratic module class.
INPUT
gens -- nonempty list of elements from the class quadratic module
EXAMPLES NONE
"""
try:
x = Sequence( gens)
ambience = self.__ambient_module = x.universe()
# Does not work: if not isinstance( ambience, __main__.FiniteQuadraticModule_ambient):
if not hasattr(ambience,'_is_FiniteQuadraticModule_ambient'):
raise TypeError
except TypeError:
raise TypeError, "%s: must be a list of elements of a quadratic module."%gens[0]
AbelianGroup.__init__( self)
# save fun. coordinates of initializing list of gens as columns in the matrix __iMatrix
self.__iMatrix = matrix( ZZ, [ gens[i].list() for i in range(len(gens))]).transpose()
# Get lattice generated by the columns of __iMatrix and the relations of the fundamental system.
self.__lattice = self.__iMatrix.column_module() + diagonal_matrix( ZZ, list(ambience.elementary_divisors())).column_module()
self.__hnf_gens = [ ambience( list( x), can_coords = False) for x in self.__lattice.matrix()]
Mat = MatrixSpace( ZZ, len( self.__hnf_gens))
# TODO: why is this coercion necessary? (SAGE returns rat. matrices for ZZ-lattices)
self.__hnf_matrix = Mat( self.__lattice.matrix().transpose())
# throw out 0's, if list becomes empty set to [ambience(0)]
z = ambience(0); self.__hnf_gens = [ g for g in self.__hnf_gens if g != z ]
if 0 == len( self.__hnf_gens): self.__hnf_gens = [z]
###################################
## Iterators
###################################
def __iter__( self):
r"""
Return a generator over the elements of self.
TODO: Smarter implementation(?)
"""
orders = [x.order() for x in self.gens()]
res = [ sum( self.gens()[i]*x[i] for i in range(len(self.gens()))) for x in xmrange(orders)]
return list(uniq(res))
###################################
## Introduce myself
###################################
def _latex_( self):
r"""
EXAMPLES NONE
"""
gens = ', '.join([latex(x) for x in self.gens()])
return '\\langle %s \\rangle' %gens
def _repr_( self):
r"""
EXAMPLES NONE
"""
gens = ', '.join([x._repr_() for x in self.gens()])
return '< %s >' %gens
###################################
## Providing struct. defining items
###################################
def _matrix_( self):
r"""
EXAMPLES NONE
"""
return self.__hnf_matrix
def ngens( self):
r"""
EXAMPLES NONE
"""
return len( self.__hnf_gens)
def gen( self, i):
r"""
EXAMPLES NONE
"""
return self.__hnf_gens[i]
def ambience( self):
r"""
Return the ambient finite quadratic module.
EXAMPLES NONE
"""
return self.__ambient_module
def _relations( self):
r"""
Return the $nxn$-matrix $R$ in lower HNF such that
$\\Z^n \riightarrow \langle \code{self.ngens()} \rangle$,
$x \mapsto \code{self.ngens()}\cdot x$ defines an isomorphosm
of abelian groups.
EXAMPLES NONE
"""
H = matrix( [x.list() for x in self.gens()]).transpose()
Hp = H.augment( diagonal_matrix( list(self.ambience().elementary_divisors())))
Rp = matrix(ZZ, Hp.transpose().integer_kernel().matrix().transpose())
R = Rp.matrix_from_rows( range( self.ngens()))
return R.transpose().echelon_form().transpose()
def as_ambient( self, names = None):
r"""
Return a pair $B, f$, where $B$ is a finite quadratic module whose underlying
group is isomorphic to self and whose quadratic form is
the one induced by the ambient finite quadratic module $A$,
and where $f: B \rightarrow A$ is the morphism of finite quadratic modules
corresponding to the inclusion of self in $A$.
EXAMPLES
sage: A = FiniteQuadraticModule( matrix( QQ, 2, [2,1,1,2]))
sage: B = 2*A
sage: a,b,c,d = B.gens()
sage: U = B.subgroup( [b+d])
sage: C,f = U.as_ambient(); f
Homomorphism : Finite quadratic module in 1 generators:
gens: e
form: 2/3*x^2 --> Finite quadratic module in 4 generators:
gens: e1, e1, e3, e3
form: 1/3*x0^2 + 2/3*x0*x1 + 1/3*x1^2 + 1/3*x2^2 + 2/3*x2*x3 + 1/3*x3^2
sage: f(C.0)
e1 + e3
"""
R = self._relations()
def g(x,y):
return x.norm() if x == y else x.dot(y)/2
G = matrix( QQ, self.ngens(), [ g(a,b) for a in self.gens() for b in self.gens()])
B = FiniteQuadraticModule_ambient( R, G, names = names)
f = B.hom( self.gens())
return B, f
###################################
## Associated quantities
###################################
def order( self):
r"""
Return the order of this subgroup.
EXAMPLES NONE
BUG
determinant is buggy (workaround: set option 'proof = False'
"""
return Integer(self.ambience().order()/matrix(self).determinant( proof = False))
def level( self):
r"""
Return the level of this subgroup (viewed as quadratic module w.r.t.
to the quadratic form inherited from its ambient module).
EXAMPLES NONE
"""
n = self.ngens()
gens = self.gens()
v = [ x.norm() for x in gens]
w = [ gens[i].dot( gens[j]) for i in range(n) for j in range(i+1,n)]
return vector( v + w).denominator()
###################################
## Operations
###################################
def dual( self):
r"""
Return the dual subgroup in the ambient module.
EXAMPLES NONE
"""
return self.ambience().dual_group( self)
def __add__( self, other):
r"""
Return the sum of this module and the other.
EXAMPLES NONE
"""
return FiniteQuadraticModule_subgroup( self.gens() + other.gens())
def cap( self, V):
r"""
Return the intersection of this subgroup with the subgroup $V$.
EXAMPLES
sage: A.<a,b,c,d> = FiniteQuadraticModule( '3^-4')
sage: U = A.subgroup( [a+b,c])
sage: V = A.subgroup( [a+b,d])
sage: W = U.cap(V); W
< a + b >
sage: A.<a,b,c,d> = FiniteQuadraticModule( '2_2^-4'); A
Finite quadratic module in 4 generators:
gens: a, b, c, d
form: 1/4*x0^2 + 3/4*x1^2 + 3/4*x2^2 + 3/4*x3^2
sage: U = A.subgroup( [a,b])
sage: V = U.dual(); V
< c, d >
sage: U.cap(V)
< 0 >
"""
ambience = self.ambience()
if not ambience is V.ambience():
raise ValueError
lat0 = diagonal_matrix( ZZ, list(ambience.elementary_divisors())).column_module()
lat1 = matrix( self).column_module() + lat0
lat2 = matrix( V).column_module() + lat0
lat = lat1.intersection( lat2)
return ambience.subgroup( [ ambience( list( x), can_coords = False) for x in lat.matrix()])
def quotient( self):
r"""
If this is $U$ and the ambient module $A$ then return $A/U$.
EXAMPLES NONE
"""
return self.ambience().quotient( self)
def split( self, n):
r"""
Return the splitting $U+V$ of this subgroup
where the exponent of $U$ divides $n^\infty$ and the exponent of
$V$ is relatively prime to $n$.
INPUT
n -- an integer
NOTE
$U$ and $V$ are orthogonal to each other.
If $n$ is a prime then $U$ is the Sylow $p$-subgroup of self.
EXAMPLES
sage: A.<a,b,c,d,e,f,g,h,j> = FiniteQuadraticModule( '23^4.2_2^4.3'); A
Finite quadratic module in 9 generators:
gens: a, b, c, d, e, f, g, h, j
form: 1/23*x0^2 + 1/23*x1^2 + 1/23*x2^2 + 1/23*x3^2 + 1/4*x4^2 + 1/4*x5^2 + 1/4*x6^2 + 3/4*x7^2 + 1/3*x8^2
sage: U = A.subgroup( A.gens()); U
< a + h + 2*j, b + g, c + f, d + e >
sage: U2 = U.split(2); U2
(< h, g, f, e >, < 2*a + j, 2*b, 2*c, 2*d >)
sage: U3 = U.split(3); U3
(< 2*j >, < 3*a + h, b + g, c + f, d + e >)
sage: U23 = U.split(23); U23
(< 6*a, 2*b, 2*c, 2*d >, < h + j, g, f, e >)
sage: V = U2[0] + U3[0] + U23[0]
sage: U == V
True
sage: U is V
False
"""
# Let e be the exponent of self, write e=e1e2 with gcd(e1,n)=1, e2 | n^infty,
# choose x, y such that 1 = e1x+e2y, set u=e1x and v=e2y. If a in A,
# then a = u*a + v*a is the decomposition of a with respect to self = U + V.
# In fact, if q dnotes the order of a, let q=q1q2 with gcd(q1,n)=1, q2 | n^infty.
# Then the order of u*a is q/gcd(q,u) = q/gcd(q,e1x) = q/q1 = q2, and
# the order of v*a is q/gcd(q,v) = = q/gcd(q,e2y) = q/q2 = q1.
e = self.level()
e2 = gcd( e, n); e1 = Integer(e/e2)
while not 1 == e1.gcd(e2):
n = n**2; e2 = gcd( e,n); e1 = Integer(e/e2)
g, x, y = xgcd( e1, e2)
u = x*e1; v = y*e2
ul =[]; vl =[]
for a in self.gens():
ul.append(u*a); vl.append(v*a)
return FiniteQuadraticModule_subgroup(ul), FiniteQuadraticModule_subgroup(vl)
###################################
## Predicates
###################################
def is_multiplicative( self):
r"""
EXAMPLES NONE
"""
return False
def is_isotropic( self):
r"""
EXAMPLES NONE
"""
return 1 == self.level()
###################################
## Relations
###################################
def __lt__( self, other):
return self.__le( other) and not self == other
def __le__( self, other):
return self._divides( matrix( other), matrix( self))
def __eq__( self, other):
return matrix( self) == matrix( other)
def __ne__( self, other):
return matrix( self) != matrix( other)
def __gt__( self, other):
return self.__ge( other) and not self == other
def __ge__( self, other):
r"""
EXAMPLES NONE
Test here all of the above
"""
return self._divides( matrix( self), matrix( other))
###################################
## Misc
###################################
def orthogonal_basis( self):
r"""
Return an orthogonal system for this subgroup
if this subgroup is nondegenerate
w.r.t. the scalar product induced from the ambient module.
Otherwise raise an exception.
NOTE
An orthonormal system for a subgroup is a system of pairwise
orthogonal generators $a_i$ of $p$-order, possibly extended by pairs
of genertors $b_j,c_j$ which are orthogonal to the $a_i$ and such that
the subgroups $\langle b_j,c_j \rangle$ are pairwise orthogonal and do no possess
orthogonal generators.
EXAMPLES
sage: A.<a,b,c,d,e,f,g> = FiniteQuadraticModule( '11^-7')
sage: U = A.subgroup( [a+b,b+c,c+d,d+e,e+f,f+g]); U
< a + 10*g, b + g, c + 10*g, d + g, e + 10*g, f + g >
sage: matrix( len(U.gens()), [ x.dot(y) for x in U.gens() for y in U.gens()])
[ 0 9/11 2/11 9/11 2/11 9/11]
[9/11 4/11 9/11 2/11 9/11 2/11]
[2/11 9/11 4/11 9/11 2/11 9/11]
[9/11 2/11 9/11 4/11 9/11 2/11]
[2/11 9/11 2/11 9/11 4/11 9/11]
[9/11 2/11 9/11 2/11 9/11 4/11]
sage: og_b = U.orthogonal_basis(); og_b
[b + g,
b + 9*f + 10*g,
b + 3*e + f + 10*g,
b + 7*d + 10*e + f + 10*g,
b + 5*c + d + 10*e + f + 10*g,
a + 2*b + 9*c + 2*d + 9*e + 2*f + 9*g]
sage: matrix( len(og_b), [ x.dot(y) for x in og_b for y in og_b])
[4/11 0 0 0 0 0]
[ 0 1/11 0 0 0 0]
[ 0 0 2/11 0 0 0]
[ 0 0 0 7/11 0 0]
[ 0 0 0 0 5/11 0]
[ 0 0 0 0 0 2/11]
"""
if not self.as_ambient()[0].is_nondegenerate():
raise TypeError
pl = prime_divisors( self.order())
og_b = []
V = self
while pl != []:
p = pl.pop()
if pl != []:
U,V = V.split(p)
else:
U = V
og_b += U._orthogonal_basis()
return og_b
def _orthogonal_basis( self):
r"""
See FiniteQuadraticModule_subgroup.orthogonal_basis().
Apply only for nondegenerate $p$-groups.
Do not use this method directly, you may run in an infinite
loop for degenerate subgroups. Use orthogonal_basis()
instead.
NOTE
The proof that the algorithm implemented here works is as
follows (see also [Sko]): Let $U$ be a $p$-subgroup of a
quadratic module $A$ such that the the scalar product of
$A$ induces a nondegenerate on on $U$. The value subgroup,
i.e. the subgroup generated by the values $B(x,y)$ ($x,y$
in $U$), is (as every subgroup of $\QQQ/\ZZ$) cyclic,
hence generated by a fixed value $B(x,y)$. We may assume
that $x$ and $y$ are in $U.gens()$ (since $B(x,y)$ beeing
a generator is equivalent to the statement that $B(x,y)$
has the largest denominator among all values). If $x=y$
then $U = \langle x \rangle + V$, where $V$ is the dual of
$\langle x \rangle$ in $U$: in fact, $z - tx$, with an
integer $t$ such that $B(z,x) = tB(x,x)$, is in $V$ for
every $z$ in $U$. Assume now that $x != y$ and $B(z,z)$
never generates the value subgroup for some $z$ in
$U.gens()$. Then there are two cases. If $p$ is odd then
$B(x+y,x+y)$ generates the value subgroup and we can do
the same argument as before with $x$ replaced by $x+y$.
However, if $p=2$ then $U = \langle x,y \rangle + V$,
where $V$ is the orthogonal complement of $\langle x,y
\rangle$ in $U$. Namely, if $z$ in $U$ then we can find
integers $t$ and $s$ such that $z - tx -sy$ is in $V$,
i.e. such that $B(z,x) = t B(x,x) - s B(x,y)$ and $B(z,y)
= t B(x,y) - s B(y,y)$. Since $U$ is nondegenerate we know
that the sums here are all direct (since $|X||Y| = |U|$
for any subgroup $X$ in $U$ with $Y$ denoting its
dual). But then $V$ is nondegenerate too and we can
proceed by induuction.
"""
if 1 == self.order():
return []
g = self.gens()
d = 0
for x in g:
e = x.dot(x).denominator()
if e > d:
d = e
og_b = [x]
for x in g:
i = list(g).index(x)
for y in g[i+1:]:
e = x.dot(y).denominator()
if e > d:
d = e
og_b = [x+y] if is_odd(d) else [x,y]
V = self.cap( self.ambience().subgroup( og_b).dual())
return og_b + V._orthogonal_basis()
###################################
## Auxiliary functions
###################################
@staticmethod
def _normal_form( gens):
r"""
Assuming that $gens = [x,y]$ and $x$ and $y$ span a type II quadratic module
return a normalized basis $u$, $v$ for the subgroup generated by $x$ and $y$,
i.e. generators such that either $x.norm() = x.dot(y) = y.norm()$ or
$x.norm() = y.norm() = 0$ and $x.dot(y) =1/2^n$.
"""
M = matrix( [x.norm()])
pass
@staticmethod
def _divides( A, B):
r"""
Return True or False accordingly as the rational matrix
$A^{-1}*B$ is an integer matrix or not.
EXAMPLES NONE
"""
ZZ_N_times_N = MatrixSpace(ZZ, A.nrows(), B.ncols())
return A**(-1)*B in ZZ_N_times_N
###################################
## CLASS JordanDecomposition
###################################
class JordanDecomposition( SageObject):
r"""
A container class for the Jordan constituents of a
finite quadratic module.
EXAMPLES NONE
"""
def __init__( self, A):
r"""
INPUT
A -- a finite quadratic module
"""
self.__A = A
if not A.is_nondegenerate():
raise TypeError
U = A.subgroup( A.gens())
og_b = U.orthogonal_basis()
jd = dict()
ol = []
primary_comps = uniq( map(lambda x: x.order(), og_b))
for q in primary_comps:
basis = tuple( [x for x in og_b if x.order() == q])
p = q.factor()[0][0]
n = valuation( q, p)
r = len( basis)
def f(x,y):
return x.norm()*2*q if x == y else x.dot(y)*q
F = matrix( ZZ, r,r, [ f(x,y) for x in basis for y in basis])
eps = kronecker( F.det(), p)
genus = [p, n, r, eps]
if 2 == p and self.is_type_I(F):
t = F.trace()%8
#TODO: print F,t what happens for p=2?
genus.append( t)
jd[q] = ( basis, tuple(genus))
ol.append( (p,n))
self.__jd = jd
self.__ol = ol
def _repr_( self):
r"""
EXAMPLES NONE
"""
return 'Jordan decomposition'
def _latex_( self):
r"""
EXAMPLES NONE
"""
return 'Jordan decomposition'
def __iter__( self):
r"""
Return the Jordan decomposition as iterator.
NOTE
The following is guaranteed. Returned is a list of pairs
basis, ( prime p, valuation of p-power n, dimension r, determinant e over p[, oddity o]),
where $n > 0$, ordered lexicographically by $p$, $n$.
EXAMPLES NONE
"""
return ( self.__jd[p**n] for p,n in self.__ol )
def genus_symbol( self, p = None):
r"""
Return the genus symbol of the Jordan constituents
whose exponent is a power of the prime $p$.
Return the concatenation of all local genus symbols
if no argument is given.
EXAMPLES NONE
"""
n = self.__A.order()
if not p:
_P = n.prime_divisors()
_P.sort( reverse = True)
elif is_prime(p):
_P = [p] if p.divides(n) else []
else:
raise TypeError
s = ''
while [] != _P:
p = _P.pop()
s += self._genus_symbol( p)
if [] != _P:
s += '.'
return s
def _genus_symbol( self, p):
r"""
Return the genus symbol of the Jordan constituent
whose exponent is a power of the prime $p$.
Do not use directly, use genus_symbol() instead.
EXAMPLES NONE
"""
l = [q for q in self.__jd.keys() if 0 == q%p]
if [] == l:
return ''
l.sort( reverse = True)
s = ''
while l != []:
q = l.pop()
s += str(q)
gs = self.__jd[q][1]
e = gs[2]*gs[3]
if len(gs) > 4:
s += '_' + str(gs[4])
if 1 != e:
s += '^' + str(e)
if l != []:
s += '.'
return s
def constituent( self, q, names = None):
r"""
Return the Jordan constituent whose exponent is the
prime power "q".
EXAMPLES NONE
"""
if not is_prime_power(q):
raise TypeError
gens = self.__jd.get( q, ((),()))[0]
return self.__A.spawn( gens, names)
def finite_quadratic_module(self):
r"""
Return the finite quadratic module who initialized
this Jordan decomposition.
EXAMPLES NONE
"""
return self.__A
def basis( p =None):
r"""
"""
pass
@staticmethod
def is_type_I(F):
r"""
EXAMPLES NONE
"""
for i in range( F.nrows()):
if is_odd( F[i,i]):
return True
return False
r"""
o: For elements return tuples instad of lists. Are their immutable matrices?
o A.quotient(U) should return B, f, g where B is V/U (V = dual of U), f:V-->A and g:V-->B are
the natural mophims.
o Implementation details should appear as NOTES not as comments
o Trivial madule + A should return A.
o If U is of type I the U.orthogonal_basis() should really give an OG basis
o Type II should return hyp's or hyp's + a single non hyp
o Less confusing for use: if a basis is already orthogonal the return it.
o The og basis should correspond to a 'normalized' genus_symbol
BUGS:
"""
### Testing routines ###
def FiniteQuadraticModuleRandom(discbound=100,normbound=100,verbose=0):
"""
Returns a random finite quaratic module with discriminant within the discriminant bound.
"""
D = 0
while False == is_fundamental_discriminant(D):
D = ZZ.random_element( -discbound, discbound)
K=QuadraticField(D,names='a')
a = K.gens()[0]
beta = 0
while 0 == beta:
beta = K.random_element()
alpha = 0
while 0 == alpha:
alpha = K.random_element()
om = beta/alpha
if verbose>0:
print "D=",D
print "K=",K
print "om=",om
if om.denominator_ideal().absolute_norm()>normbound:
return FiniteQuadraticModuleRandom(discbound,normbound,verbose)
#A.<x,y> =
A = FiniteQuadraticModule( om/om.parent().gen())
x,y = A.gens()
N = A.kernel()
if verbose>0:
print "A=",A
print "|A.list()|=",len(A.list())
print "N=",N
if False == N.is_isotropic():
return FiniteQuadraticModuleRandom(discbound,normbound,verbose)
if len(A.list()) == 1:
return FiniteQuadraticModuleRandom(discbound,normbound,verbose)
#if False == A.is_nondegenerate():
# return FiniteQuadraticModuleRandom(bound)
B = A.quotient(N)
if False == B.is_nondegenerate():
if verbose>0:
print "A / N is nondegenerate!"
print "A=",A
print "N=A.kernel()=",N
raise ValueError,"Quotient is nondegenerate!"
return B
def test_fqm_random(fqbound=100,nbound=10,cbound=10,size_bd=50,verbose=0):
r"""
Check nbound different random finite quadratic modules
The tests we do are:
1) Compute Jordan block
2) Compute sigma invariant
"""
# first get a random FQM
ntest=0
for i in range(nbound):
l=size_bd+1
while l>size_bd:
FQ=FiniteQuadraticModuleRandom(fqbound,nbound,verbose-1)
l=len(FQ.list())
#info=get_factors2(FQ.jordan_decomposition())
t = _test_one_F(FQ)
if t<>True:
return t
ntest+=1
#assert s0 == si[0]/si[1]
if verbose>0:
print "Tested {0} modules!".format(ntest)
return True
def test_one_F(FQ='4_1'):
if not hasattr(FQ,"Q"):
FQ = FiniteQuadraticModule(FQ)
N = FQ.level()
z = CyclotomicField(N).gens()[0]
for a in range(1,N):
s0 = FQ.char_invariant(a)
s1 = naive_Gauss_sum(FQ,a)
if abs(CC(s0[0])*CC(s0[1])-CC(s1[0])/CC(s1[1]**2))>1e-10:
if verbose>0:
print "s0=",s0,CC(s0[0]*s0[1])
print "s1=",s1,CC(s1[0]/s1[1]**2)
return False,a,FQ
return True
# if(FQ.level() % 4 <> 0 or is_odd(info['sign'])):
# continue
# if verbose>0:
# print "FQ=",FQ," size=",l," level=",FQ.level()," sigma^4=",FQ.sigma_invariant()^4
# print "Genus symbol=",FQ.jordan_decomposition().genus_symbol()
# if test_epd_one_fqm(FQ,cbound):
# print "ok for FQ=",i
# else:
# print "*Not* ok for FQ=",i
# return False
## Functions for testing
def naive_Gauss_sum(FQ,a):
r"""
If this quadratic module equals $A = (M,Q)$, return
the characteristic function of $A$ at $s$, i.e. return
$$\chi_A (s)= |M|^{-1}\sum_{x\in M} \exp(2\pi i s Q(x)))$$
computed naively by summing.
NOTE: This is slow and should only be used for testing purposes.
"""
N = FQ.level()
z = CyclotomicField(N).gens()[0]
res = 0
for x in FQ.list():
res += z**(a*(FQ.Q(x)*N))
return res,ZZ(len(FQ.list())).sqrt()
| Python |
#
from vector_complex_dense import Vector_complex_dense
from finite_quadratic_module import FiniteQuadraticModule,FiniteQuadraticModuleRandom
from weil_module import WeilModule,sigma_cocycle,kubota_cocycle
| Python |
# libs
| Python |
def SmallJac(f):
try:
d = f.degree()
except TypeError:
d = f.degree(f.variables()[0])
g = (d - 1) // 2
if g == 1:
import wrapper1
return wrapper1.SmallJac(f)
elif g == 2:
import wrapper2
return wrapper2.SmallJac(f)
elif g == 3:
import wrapper3
return wrapper3.SmallJac(f)
raise NotImplementedError
| Python |
def test1(B=10**4):
from sage.all import polygen, primes, QQ, EllipticCurve
import psage.libs.smalljac.wrapper
x = polygen(QQ, 'x')
J = psage.libs.smalljac.wrapper.SmallJac(x**3 + 17*x + 3)
E = EllipticCurve([17,3])
N = E.conductor()
for p in primes(B):
if N%p:
assert E.ap(p) == J.ap(p)
def test2(B=500):
from sage.all import polygen, primes, QQ, GF, HyperellipticCurve
import psage.libs.smalljac.wrapper
x = polygen(QQ, 'x')
J = psage.libs.smalljac.wrapper.SmallJac(x**5 + 17*x + 3)
N = 97*3749861
for p in primes(45,B): # 45 comes from "(2g+1)(2N-1) = 45"
if N%p:
x = polygen(GF(p), 'x')
C = HyperellipticCurve(x**5 + 17*x + 3)
assert C.frobenius_polynomial() == J.frob(p).charpoly()
| Python |
# smalljac -- Drew Sutherland's code for point counting on Jacobians of curves over finite fields
| Python |
from sage.all import prime_range, I
class J_E:
def __init__(self, E, N, K):
self.E = E
self.ap = [K(ap) for ap in E.aplist(N)]
self.N = N
self.primes = [K(p) for p in prime_range(N)]
self.K = K
self.log_primes = [p.log() for p in self.primes]
self.I = K(I)
def F0(self, t, N):
assert N <= self.N
K = self.K
s = 1 + t*self.I # 1 is the center
ans = 0
i = 0
while self.primes[i] < N:
ap = self.ap[i]
p = self.primes[i]
X = p**(-s)
ans += (ap - 2*p) / (1 - ap*X + p*X*X) * X * self.log_primes[i]
i += 1
return ans
class J_generic:
def __init__(self, K, N_max=10**5):
"""
Compute J working over the field K.
"""
self.N_max = N_max
self.K = K
from sage.all import prime_powers, factor
PP = prime_powers(N_max+1)[1:]
n = len(PP)
self.a = [K(0)]*n
self.s = [K(0)]*n
self.pv = [0]*n
i = 0
for pv in PP:
F = factor(pv)
p, v = F[0]
self.pv[i] = K(pv)
logp = K(p).log()
self.a[i] = logp/K(pv).sqrt()
self.s[i] = v*logp
i += 1
def __repr__(self):
return "The function J(t,N) over %s of the Mazur-Stein game with N_Max=%s"%(
self.K, self.N_max)
def F(self, t, N):
K = self.K
t = K(t)
ans = K(0)
i = 0
if N > self.N_max:
raise ValueError, "J not defined for N > %s"%self.N_max
while 1:
if self.pv[i] >= N:
return ans
ans += self.a[i] * (self.s[i]*t).cos()
i += 1
def e(self, t, N):
K = self.K
return K(N).sqrt() / (.25 + t*t) * \
( (K(t*K(N).log())).cos() + 2*t*(K(t*K(N).log())).sin() )
def H(self, t, N):
K = self.K
ans = K(0); F = K(0)
i = 0
if N > self.N_max:
raise ValueError, "J not defined for N > %s"%self.N_max
n = 1
while 1:
if self.pv[i] > N:
# time to return. But first we have to add a few more
# values to ans up to N (where F is constant).
while n <= N:
ans += F + self.e(t,n)
n += 1
# Finally return after dividing by N.
return ans / N
# At this point, F is equal to self.F(t, self.pv._values[i]),
# and now we add to our running total a range of values of
# F(t, n) + e(t,n)
while n <= self.pv[i]:
ans += F + self.e(t,n)
n += 1
F += self.a[i] * cos(self.s[i]*t)
# move to next prime power
i += 1
def J(self, t, N):
K = self.K
return self.H(t,N) / K(N).log()
def __call__(self, t, N):
return self.J(t,N)
######################################################
# Cesaro of Cesaro...
######################################################
def Jc(self, t, N):
K = self.K
ans = K(0); F = K(0); ans2 = K(0)
i = 0
if N > self.N_max:
raise ValueError, "J not defined for N > %s"%self.N_max
n = 1
while 1:
if self.pv[i] > N:
# time to return. But first we have to add a few more
# values to ans up to N (where F is constant).
while n <= N:
ans += F + self.e(t,n)
if n >= 2:
ans2 += ans / (n*K(n).log())
#print (n, F, self.e(t,n))
n += 1
# Finally return after dividing by N.
return ans2 / N
# At this point, F is equal to self.F(t, self.pv._values[i]),
# and now we add to our running total a range of values of
# F(t, n) + e(t,n)
while n <= self.pv[i]:
ans += F + self.e(t,n)
if n >= 2:
ans2 += ans / (n*K(n).log())
#print (n, F, self.e(t,n))
n += 1
F += self.a[i] * (self.s[i]*t).cos()
# move to next prime power
i += 1
| Python |
#################################################################################
#
# (c) Copyright 2011 William Stein
#
# This file is part of PSAGE.
#
# PSAGE is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 2 of the License, or
# (at your option) any later version.
#
# PSAGE is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
#
#################################################################################
r"""
"""
import math, os, sys
from sage.all import (
arrow,
bar_chart,
cached_function, cached_method,
CDF,
ceil,
divisors,
e,
Ei,
ellipsis_range as erange,
exp,
factor,
finance,
floor,
gcd,
Graphics,
graphics_array,
is_prime, is_prime_power, is_pseudoprime,
latex,
Li,
line,
log, sin, cos,
maxima,
moebius,
parallel,
pi,
plot,
point,
points,
polygon,
prime_divisors,
prime_range,
prime_pi,
prime_powers,
primes,
prod,
randint,
random,
save,
set_random_seed,
spline,
sqrt,
SR,
text,
var,
walltime,
zeta,
zeta_zeros,
ZZ
)
##############################################################
# Drawing figures (one or all)
##############################################################
def draw(fig=None, dir='illustrations/',ext='pdf', in_parallel=True):
if not os.path.exists(dir):
os.makedirs(dir)
if isinstance(fig, str):
print "Drawing %s... "%fig,
sys.stdout.flush()
t = walltime()
G = eval('fig_%s(dir,ext)'%fig)
print " (time = %s seconds)"%walltime(t)
return G
if fig is None:
figs = ['_'.join(x.split('_')[1:]) for x in globals() if x.startswith('fig_')]
elif isinstance(fig, list):
figs = fig
if in_parallel:
@parallel
def f(x):
return draw(x, dir=dir, ext=ext, in_parallel=False)
for x in f(figs):
print x
else:
for fig in figs:
draw(fig)
return
##############################################################
# Factorization trees
##############################################################
def fig_factor_tree(dir, ext):
g = FactorTree(6).plot(labels={'fontsize':60},sort=True)
g.save(dir + '/factor_tree_6.%s'%ext, axes=False, axes_pad=0.1)
g = FactorTree(12).plot(labels={'fontsize':50},sort=True)
g.save(dir + '/factor_tree_12.%s'%ext, axes=False, axes_pad=0.1)
set_random_seed(3)
g = FactorTree(12).plot(labels={'fontsize':50},sort=False)
g.save(dir + '/factor_tree_12b.%s'%ext, axes=False,axes_pad=0.1)
set_random_seed(0)
for w in ['a', 'b']:
g = FactorTree(300).plot(labels={'fontsize':40},sort=False)
g.save(dir + '/factor_tree_300_%s.%s'%(w,ext), axes=False, axes_pad=0.1)
set_random_seed(0)
g = FactorTree(6469693230).plot(labels={'fontsize':14},sort=False)
g.save(dir + '/factor_tree_big.%s'%ext, axes=False, axes_pad=0.1)
class FactorTree:
"""
A factorization tree.
EXAMPLES::
sage: FactorTree(100)
Factorization trees of 100
sage: R.<x> = QQ[]
sage: FactorTree(x^3-1)
Factorization trees of x^3 - 1
"""
def __init__(self, n):
"""
INPUT:
- `n` -- number of element of polynomial ring
"""
self.__n = n
def value(self):
"""
Return the n such that self is FactorTree(n).
EXAMPLES::
sage: FactorTree(100).value()
100
"""
return self.__n
def __repr__(self):
"""
EXAMPLES::
sage: FactorTree(100).__repr__()
'Factorization trees of 100'
"""
return "Factorization trees of %s"%self.__n
def plot(self, lines=None, labels=None, sort=False):
"""
INPUT:
- ``lines`` -- optional dictionary of options passed
to the line command
- ``labels`` -- optional dictionary of options passed to
the text command for the divisor labels
- ``sort`` -- bool (default: False); if True, the primes
divisors are found in order from smallest to largest;
otherwise, the factor tree is draw at random
EXAMPLES::
sage: FactorTree(2009).plot(labels={'fontsize':30},sort=True)
We can make factor trees of polynomials in addition to integers::
sage: R.<x> = QQ[]
sage: F = FactorTree((x^2-1)*(x^3+2)*(x-5)); F
Factorization trees of x^6 - 5*x^5 - x^4 + 7*x^3 - 10*x^2 - 2*x + 10
sage: F.plot(labels={'fontsize':15},sort=True)
"""
if lines is None:
lines = {'rgbcolor':(.5,.5,1)}
if labels is None:
labels = {'fontsize':16}
n = self.__n
rows = []
v = [(n,None,0)]
self._ftree(rows, v, sort=sort)
return self._plot_ftree(rows, lines, labels)
def _ftree(self, rows, v, sort):
"""
A function that is used recurssively internally by the plot function.
INPUT:
- ``rows`` -- list of lists of integers
- ``v`` -- list of triples of integers
- ``sort`` -- bool (default: False); if True, the primes
divisors are found in order from smallest to largest;
otherwise, the factor tree is draw at random
EXAMPLES::
sage: F = FactorTree(100)
sage: rows = []; v = [(100,None,0)]; F._ftree(rows, v, True)
sage: rows
[[(100, None, 0)],
[(2, 100, 0), (50, 100, 0)],
[(None, None, None), (2, 50, 1), (25, 50, 1)],
[(None, None, None), (None, None, None), (5, 25, 2), (5, 25, 2)]]
sage: v
[(100, None, 0)]
"""
if len(v) > 0:
# add a row to g at the ith level.
rows.append(v)
w = []
for i in range(len(v)):
k, _,_ = v[i]
if k is None or ZZ(k).is_irreducible():
w.append((None,None,None))
else:
div = divisors(k)
if sort:
d = div[1]
else:
z = divisors(k)[1:-1]
d = z[randint(0,len(z)-1)]
w.append((d,k,i))
e = k//d
if e == 1:
w.append((None,None))
else:
w.append((e,k,i))
if len(w) > len(v):
self._ftree(rows, w, sort=sort)
def _plot_ftree(self, rows, lines, labels):
"""
Used internally by the plot method.
INPUT:
- ``rows`` -- list of lists of triples
- ``lines`` -- dictionary of options to pass to lines commands
- ``labels`` -- dictionary of options to pass to text command to label factors
EXAMPLES::
sage: F = FactorTree(100)
sage: rows = []; v = [(100,None,0)]; F._ftree(rows, v, True)
sage: F._plot_ftree(rows, {}, {})
"""
g = Graphics()
for i in range(len(rows)):
cur = rows[i]
for j in range(len(cur)):
e, f, k = cur[j]
if not e is None:
if ZZ(e).is_irreducible():
c = (1,0,0)
else:
c = (0,0,.4)
g += text("$%s$"%latex(e), (j*2-len(cur),-i), rgbcolor=c, **labels)
if not k is None and not f is None:
g += line([(j*2-len(cur),-i), (k*2-len(rows[i-1]),-i+1)], axes=False, **lines)
return g
##############################################################
# Bag of primes
##############################################################
def bag_of_primes(steps):
"""
This works up to 9. It took a day using specialized factoring
(via GMP-ECM) to get step 10.
EXAMPLES::
sage: bag_of_primes(5)
[2, 3, 7, 43, 13, 139, 3263443]
"""
bag = [2]
for i in range(steps):
for p in prime_divisors(prod(bag)+1):
bag.append(p)
print bag
##############################################################
# Questions about numbers
##############################################################
def fig_questions(dir, ext):
g = questions(100,17,20)
g.save(dir + '/questions.%s'%ext, axes=False)
def questions(n=100,k=17,fs=20):
set_random_seed(k)
g = text("?",(5,5),rgbcolor='grey', fontsize=200)
g += sum(text("$%s$"%p,(random()*10,random()*10),rgbcolor=(p/(2*n),p/(2*n),p/(2*n)),fontsize=fs)
for p in primes(n))
return g
##############################################################
# Sieve of Eratosthenes
##############################################################
def fig_erat(dir,ext):
# sieving out 2,3,5,7
for p in [2,3,5,7]:
sieve_step(p,100).save(dir+'/sieve100-%s.%s'%(p,ext))
sieve_step(13,200).save(dir+'/sieve200.%s'%ext)
def number_grid(c, box_args=None, font_args=None, offset=0):
"""
INPUT:
c -- list of length n^2, where n is an integer.
The entries of c are RGB colors.
box_args -- additional arguments passed to box.
font_args -- all additional arguments are passed
to the text function, e.g., fontsize.
offset -- use to fine tune text placement in the squares
OUTPUT:
Graphics -- a plot of a grid that illustrates
those n^2 numbers colored according to c.
"""
if box_args is None: box_args = {}
if font_args is None: font_args = {}
try:
n = sqrt(ZZ(len(c)))
except ArithmeticError:
raise ArithmeticError, "c must have square length"
G = Graphics()
k = 0
for j in reversed(range(n)):
for i in range(n):
col = c[int(k)]
R = line([(i,j),(i+1,j),(i+1,j+1),(i,j+1),(i,j)],
thickness=.2, **box_args)
d = dict(box_args)
if 'rgbcolor' in d.keys():
del d['rgbcolor']
P = polygon([(i,j),(i+1,j),(i+1,j+1),(i,j+1),(i,j)],
rgbcolor=col, **d)
G += P + R
if col != (1,1,1):
G += text(str(k+1), (i+.5+offset,j+.5), **font_args)
k += 1
G.axes(False)
G.xmin(0); G.xmax(n); G.ymin(0); G.ymax(n)
return G
def sieve_step(p, n, gone=(1,1,1), prime=(1,0,0), \
multiple=(.6,.6,.6), remaining=(.9,.9,.9),
fontsize=11,offset=0):
"""
Return graphics that illustrates sieving out multiples of p.
Numbers that are a nontrivial multiple of primes < p are shown in
the gone color. Numbers that are a multiple of p are shown in a
different color. The number p is shown in yet a third color.
INPUT:
p -- a prime (or 1, in which case all points are colored "remaining")
n -- a SQUARE integer
gone -- rgb color for integers that have been sieved out
prime -- rgb color for p
multiple -- rgb color for multiples of p
remaining -- rgb color for integers that have not been sieved out yet
and are not multiples of p.
"""
if p == 1:
c = [remaining]*n
else:
exclude = prod(prime_range(p)) # exclude multiples of primes < p
c = []
for k in range(1,n+1):
if k <= p and is_prime(k):
c.append(prime)
elif k == 1 or (gcd(k,exclude) != 1 and not is_prime(k)):
c.append(gone)
elif k%p == 0:
c.append(multiple)
else:
c.append(remaining)
# end for
# end if
return number_grid(c,{'rgbcolor':(0.2,0.2,0.2)},{'fontsize':fontsize, 'rgbcolor':(0,0,0)},offset=offset)
##############################################################
# Similar rates of growth
##############################################################
def fig_simrates(dir,ext):
# similar rates
G = similar_rates()
G.save(dir + "/similar_rates.%s"%ext,figsize=[8,3])
def similar_rates():
"""
Draw figure fig:simrates illustrating similar rates.
EXAMPLES::
sage: similar_rates()
"""
X = var('X')
A = 2*X**2 + 3*X - 5
B = 3*X**2 - 2*X + 1
G = plot(A/B, (1,100))
G += text("$A(X)/B(X)$", (70,.58), rgbcolor='black', fontsize=14)
H = plot(A, (X,1,100), rgbcolor='red') + plot(B, (X,1,100))
H += text("$A(X)$", (85,8000), rgbcolor='black',fontsize=14)
H += text("$B(X)$", (60,18000), rgbcolor='black',fontsize=14)
a = graphics_array([[H,G]])
return a
def same_rates():
"""
Draw figure fig:samerates illustrating same rates.
EXAMPLES::
sage: similar_rates()
"""
X = var('X')
A = X**2 + 3*X - 5
B = X**2 - 2*X + 1
G = plot(A/B, (1,100))
G += text("$A(X)/B(X)$", (70,.58), rgbcolor='black', fontsize=14)
H = plot(A, (X,1,100), rgbcolor='red') + plot(B, (X,1,100))
H += text("$A(X)$", (70,8500), rgbcolor='black',fontsize=14)
H += text("$B(X)$", (90,5000), rgbcolor='black',fontsize=14)
a = graphics_array([[H,G]])
return a
def fig_same_rates(dir,ext):
# similar rates
G = same_rates()
G.save(dir + "/same_rates.%s"%ext,figsize=[8,3])
##############################################################
# Proportion of Primes to to X
##############################################################
def fig_log(dir, ext):
g = plot(log, 1/3.0, 100, thickness=2)
g.save(dir + '/log.%s'%ext, figsize=[8,3], gridlines=True)
def fig_proportion_primes(dir,ext):
for bound in [100,1000,10000]:
g = proportion_of_primes(bound)
g.save(dir + '/proportion_primes_%s.%s'%(bound,ext))
def plot_step_function(v, vertical_lines=True, **args):
r"""
Return the line that gives the plot of the step function f defined
by the list v of pairs (a,b). Here if (a,b) is in v, then f(a) = b.
INPUT:
- `v` -- list of pairs (a,b)
EXAMPLES::
sage: plot_step_function([(i,sin(i)) for i in range(5,20)])
"""
# make sorted copy of v (don't change in place, since that would be rude).
v = list(sorted(v))
if len(v) <= 1:
return line([]) # empty line
if vertical_lines:
w = []
for i in range(len(v)):
w.append(v[i])
if i+1 < len(v):
w.append((v[i+1][0],v[i][1]))
return line(w, **args)
else:
return sum(line([v[i],(v[i+1][0],v[i][1])], **args) for i in range(len(v)-1))
def proportion_of_primes(bound, **args):
"""
Return a graph of the step function that assigns to X the
proportion of numbers between 1 and X of primes.
INPUTS:
- `bound` -- positive integer
- additional arguments are passed to the line function.
EXAMPLES::
sage: proportion_of_primes(100)
"""
v = []
k = 0.0
for n in range(1,bound+1):
if is_prime(n):
k += 1
v.append((n,k/n))
return plot_step_function(v, **args)
##############################################################
# Prime Gaps
##############################################################
@cached_function
def prime_gaps(maxp):
"""
Return the sequence of prime gaps obtained using primes up to maxp.
EXAMPLES::
sage: prime_gaps(100)
[1, 2, 2, 4, 2, 4, 2, 4, 6, 2, 6, 4, 2, 4, 6, 6, 2, 6, 4, 2, 6, 4, 6, 8]
"""
P = prime_range(maxp+1)
return [P[i+1] - P[i] for i in range(len(P)-1)]
@cached_function
def prime_gap_distribution(maxp):
"""
Return list v such that v[i] is how many times i is a prime gap
among the primes up to maxp.
EXAMPLES::
sage: prime_gap_distribution(100)
[0, 1, 8, 0, 7, 0, 7, 0, 1]
sage: prime_gap_distribution(1000)
[0, 1, 35, 0, 40, 0, 44, 0, 15, 0, 16, 0, 7, 0, 7, 0, 0, 0, 1, 0, 1]
"""
h = prime_gaps(maxp)
v = [0]*(max(h)+1)
for gap in h: v[gap] += 1
return v
def fig_primegapdist(dir,ext):
v = prime_gap_distribution(10**7)[:50]
bar_chart(v).save(dir+"/primegapdist.%s"%ext, figsize=[9,3])
def prime_gap_plots(maxp, gap_sizes):
"""
Return a list of graphs of the functions Gap_k(X) for 0<=X<=maxp,
for each k in gap_sizes. The graphs are lists of pairs (X,Y) of
integers.
INPUT:
- maxp -- positive integer
- gap_sizes -- list of integers
"""
P = prime_range(maxp+1)
v = [[(0,0)] for i in gap_sizes]
k = dict([(g,i) for i, g in enumerate(gap_sizes)])
for i in range(len(P)-1):
g = P[i+1] - P[i]
if g in k:
w = v[k[g]]
w.append( (P[i+1],w[-1][1]) )
w.append( (P[i+1],w[-1][1]+1) )
return v
def fig_primegap_race(dir, ext):
"""
Draw plots showing the race for gaps of size 2, 4, 6, and 8.
"""
X = 7000
gap_sizes = [2,4,6,8]
#X = 100000
#gap_sizes = [i for i in range(2,50) if i%2==0]
v = prime_gap_plots(X, gap_sizes)
P = sum(line(x) for x in v)
P += sum( text( "Gap %s"%gap_sizes[i], (v[i][-1][0]*1.04, v[i][-1][1]), color='black', fontsize=8)
for i in range(len(v)))
P.save(dir + '/primegap_race.%s'%ext, figsize=[9,3], gridlines=True)
return P
##############################################################
# Multiplicatively even and odd table
##############################################################
def mult_even_odd_count(bound):
"""
Return list v of length bound such that v[n] is a pair (a,b) where
a is the number of multiplicatively even positive numbers <= n and b is the
number of multiplicatively odd positive numbers <= n.
INPUT:
- ``bound`` -- a positive integer
EXAMPLES::
We make the table in the paper::
sage: mult_even_odd_count(17)
[(0, 0), (1, 0), (1, 1), (1, 2), (2, 2), (2, 3), (3, 3), (3, 4), (3, 5), (4, 5), (5, 5), (5, 6), (5, 7), (5, 8), (6, 8), (7, 8), (8, 8)]
"""
par = mult_parities(bound)
a = 0; b = 0
v = [(a,b)]
for n in range(1,bound):
if par[n] == 0: # mult even
a += 1
else:
b += 1
v.append((a,b))
return v
def fig_multpar(dir,ext):
for n in [10**k for k in reversed([1,2,3,4,5,6])]:
file = dir + '/liouville-%s.%s'%(n,ext)
if n >= 1000:
time_series = True
else:
time_series = False
g = race_mult_parity(n, time_series=time_series)
g.save(file, frame=True)
def race_mult_parity(bound, time_series=False, **kwds):
"""
Return a plot that shows race between multiplicatively even and
odd numbers. More precisely it shows the function f(X) that
equals number of even numbers >= 2 and <=X minus the number of odd
numbers >= 2 and <= X.
EXAMPLES::
sage: race_mult_parity(10^5,time_series=True)
sage: race_mult_parity(10^5)
"""
par = mult_parities(bound)[2:]
if not time_series:
v = [(2,0)]
for n in range(bound-2):
if par[n] == 0:
b = v[-1][1]+1
else:
b = v[-1][1]-1
v.append((v[-1][0], b))
v.append((v[-1][0]+1, b))
return line(v, **kwds)
else:
v = [0,0,0]
for n in range(bound-2):
if par[n] == 0:
v.append(v[-1]+1)
else:
v.append(v[-1]-1)
return finance.TimeSeries(v).plot()
def mult_parities_python(bound, verbose=False):
"""
Return list v of length bound such that v[n] is 0 if n is
multiplicative even, and v[n] is 1 if n is multiplicatively odd.
Also v[0] is None.
This goes up to bound=`10^7` in about 30 seconds.
"""
v = [None]*bound
v[0] = None
v[1] = int(0)
P = [int(p) for p in prime_range(bound)]
for p in P:
v[p] = int(1)
last = P
last_parity = int(1)
loops = floor(log(bound,2))+1
bound = int(bound)
for k in range(loops):
cur = []
cur_parity = (last_parity+int(1))%int(2)
if verbose:
print "loop %s (of %s); last = %s"%(k,loops, len(last))
for n in last:
for p in P:
m = n * p
if m >= bound:
break
if v[m] is None:
v[m] = cur_parity
cur.append(m)
last_parity = cur_parity
last = cur
return v
##############################################################
# LogX over X in "Probabilistic first guess" chapter
##############################################################
def fig_logXoverX(dir, ext):
file = dir + '/logXoverX.%s'%ext
x = var('x')
xmax = 250
G = plot(x/(log(x)-1), 4, xmax, color='blue')
G += prime_pi.plot(4, xmax, color='red')
G.save(file, figsize=[7,3])
##############################################################
# The devil is in the details.
##############################################################
def committee_pi(X, error_prob=0.1):
num_primes = 0
for N in range(1, X+1):
N_is_prime = is_pseudoprime(N)
if random() < error_prob:
# make a mistake
if not N_is_prime:
# incorrectly count it
num_primes += 1
else:
# do not make a mistake
if N_is_prime:
num_primes += 1
return num_primes
##############################################################
# Prime pi plots
##############################################################
def fig_prime_pi_aspect1(dir,ext):
for n in [25, 100]:
p = plot(lambda x: prime_pi(floor(x)), 1,n,
plot_points=10000,rgbcolor='red',
fillcolor=(.9,.9,.9),fill=True)
file = dir + '/prime_pi_%s_aspect1.%s'%(n,ext)
p.save(file, aspect_ratio=1, gridlines=True)
def fig_prime_pi(dir,ext):
for n in [1000, 10000, 100000]:
p = plot(lambda x: prime_pi(floor(x)), 1,n,
plot_points=10000,rgbcolor='red',
fillcolor=(.9,.9,.9),fill=True)
file = dir + '/prime_pi_%s.%s'%(n,ext)
p.save(file)
def fig_prime_pi_nofill(dir,ext):
for n in [25,38,100,1000,10000,100000]:
g = plot_prime_pi(n, rgbcolor='red', thickness=2)
g.save(dir + '/PN_%s.%s'%(n,ext))
def plot_prime_pi(n = 25, **args):
v = [(0,0)]
k = 0
for p in prime_range(n+1):
k += 1
v.append((p,k))
v.append((n,k))
return plot_step_function(v, **args)
##############################################################
# Sieving
##############################################################
def fig_sieves(dir,ext):
plot_three_sieves(100, shade=False).save(dir + '/sieve_2_100.%s'%ext, figsize=[9,3])
plot_all_sieves(1000, shade=True).save(dir + '/sieve1000.%s'%ext,figsize=[9,3])
m=100
for z in [3,7]:
save(plot_multiple_sieves(m,k=[z]) ,dir+'/sieves%s_100.%s'%(z,ext), xmax=m, figsize=[9,3])
def plot_sieve(n, x, poly={}, lin={}, label=True, shade=True):
"""
Return a plot of the number of integer up to x that are coprime to n.
These are the integers that are sieved out using the primes <= n.
In n is 0 draw a graph of all primes.
"""
v = range(x+1) # integers 0, 1, ..., x
if n == 0:
v = prime_range(x)
else:
for p in prime_divisors(n):
v = [k for k in v if k%p != 0 or k==p]
# eliminate non-prime multiples of p
v = set(v)
j = 0
w = [(0,j)]
for i in range(1,x+1):
w.append((i,j))
if i in v:
j += 1
w.append((i,j))
w.append((i,0))
w.append((0,0))
if n == 0:
t = "Primes"
pos = x,.7*j
elif n == 1:
t = "All Numbers"
pos = x, 1.03*j
else:
P = prime_divisors(n)
if len(P) == 1:
t = "Sieve by %s"%P[0]
else:
t = "Sieve by %s"%(', '.join([str(_) for _ in P]))
pos = x,1.05*j
F = line(w[:-2], **lin)
if shade:
F += polygon(w, **poly)
if label:
F += text(t, pos, horizontal_alignment="right", rgbcolor='black')
return F
def plot_three_sieves(m, shade=True):
s1 = plot_sieve(1, m, poly={'rgbcolor':(.85,.9,.7)},
lin={'rgbcolor':(0,0,0), 'thickness':1}, shade=shade)
s2 = plot_sieve(2, m, poly={'rgbcolor':(.75,.8,.6)},
lin={'rgbcolor':(0,0,0),'thickness':1}, shade=shade)
s3 = plot_sieve(0, m, poly={'rgbcolor':(1,.7,.5)},
lin={'rgbcolor':(1,0,0), 'thickness':1}, shade=shade)
return s1+s2+s3
def plot_multiple_sieves(m=100, k = [2,3,5], shade=True):
g = Graphics()
n = len(k)
for i in range(n):
c = (1-float(i+1)/n)*0.666
if k[i] == 0:
z = 0
else:
z = prod(prime_range(k[i]+1))
r = float(i)/n
clr = (.85 + 0.15*r,0.9 -0.2*r, 0.9 -0.4*r)
if z == 0:
clrlin=(1,0,0)
else:
clrlin=(0,0,0)
s = plot_sieve(z, m,
poly={'rgbcolor':clr},
lin={'rgbcolor':clrlin, 'thickness':1},
label=(i==0 or i==n-1), shade=shade)
g += s
return g
def plot_all_sieves(x, shade=True):
P = [1] + prime_range(int(sqrt(x))+1) + [0]
G = plot_multiple_sieves(x, P, shade=shade)
return G
##############################################################
# Area under plot of 1/log(x)
##############################################################
#auto
def area_under_inverse_log(m, **args):
r"""
This function returns a graphical illustration of `Li(x)` for `x
\leq m` viewed as the integral of `1/\log(t)` from 2 to `t`. We
also plot primes on the `x`-axis and display the area as text.
EXAMPLES::
"""
f = plot(lambda x: 1/math.log(x), 2, m) # TODO: weird.
P = polygon([(2,0)]+list(f[0])+[(m,0)], hue=0.1,alpha=0.4)
if False:
T = sum([text(str(p),(p,-0.08),vertical_alignment="top",\
horizontal_alignment="center", fontsize=6, rgbcolor=(.6,0,0)) \
for p in prime_range(m+1)])
else:
T = Graphics()
pr = sum([point((p,0), rgbcolor=(.6,0,0), pointsize=100/log(p)) for p in prime_range(m+1)])
L = 'quad_qag(1/log(x), x, 2,%s, 0)'%m
fs = 36
area = text('Area ~ %f'%(float(maxima(L)[0])),(.5*m,.75),fontsize=fs,rgbcolor='black')
primes = text('%s Primes'%len(prime_range(m+1)), (.5*m,-0.3),fontsize=fs,rgbcolor='black')
fun = text('1/log(x)',(m/8.0,1.4),fontsize=fs,rgbcolor='black', horizontal_alignment='left')
G = pr + f+P+area+T+primes +fun
G.xmax(m+1)
return G
def fig_inverse_of_log(dir,ext):
for m in [30, 100, 1000]:
area_under_inverse_log(m).save(dir+'/area_under_log_graph_%s.%s'%(m,ext), figsize=[7,7])
##############################################################
# Comparing Li, pi, and x/log(x)
##############################################################
def fig_li_pi_loginv(dir,ext):
plot_li_pi_loginv(xmax=200).save(dir+'/three_plots.%s'%ext,figsize=[8,3])
def plot_li_pi_loginv(xmax=200):
x = var('x')
P = plot(x/log(x), (2, xmax))
P+= plot(Li, (2, xmax), rgbcolor='black')
P+= plot(prime_pi, 2, xmax, rgbcolor='red')
return P
##############################################################
# Perspective
##############################################################
def fig_primes_line(dir,ext):
xmin=1; xmax=38; pointsize=90
g = points([(p,0) for p in prime_range(xmax+1)], pointsize=pointsize, rgbcolor='red')
g += line([(xmin,0), (xmax,0)], rgbcolor='black')
eps = 1/2.0
for n in range(xmin, xmax+1):
g += line([(n,eps), (n,-eps)], rgbcolor='black', thickness=0.5)
g += text("$%s$"%n, (n,-6), rgbcolor='black')
g.save(dir + '/primes_line.%s'%ext, axes=False,figsize=[9,.7], ymin=-10, ymax=2)
##############################################################
# Plots of Psi function
##############################################################
def psi_data(xmax):
from math import log, pi
v = [(0,0), (1,0), (1,log(2*pi))]
y = v[-1][1]
for pn in prime_powers(2,xmax+1):
y += log(factor(pn)[0][0])
v.append( (pn,y) )
v.append((xmax,y))
return v
def plot_psi(xmax, **kwds):
v = psi_data(xmax)
return plot_step_function(v, **kwds)
def fig_psi(dir,ext):
for m in [9,38,100,200]:
g = plot_psi(m, thickness=2)
g.save(dir+'/psi_%s.%s'%(m,ext), aspect_ratio=1, gridlines=True,
fontsize=20)
g = plot(lambda x:x,1,1000,rgbcolor='red')+plot_psi(1000,alpha=0.8)
g.save(dir+'/psi_diag_%s.%s'%(1000,ext),aspect_ratio=1, fontsize=20, gridlines=True)
def plot_Psi(xmax, **kwds):
v = psi_data(xmax)
v = [(log(a),b) for a, b in v if a]
return plot_step_function(v, **kwds)
def fig_Psi(dir, ext):
m = 38
g = plot_Psi(m, thickness=2)
g.save(dir+'/bigPsi_%s.%s'%(m,ext), gridlines=True,
fontsize=20, figsize=[6.1,6.1])
def fig_Psiprime(dir, ext):
g = line([(0,0),(0,100)], rgbcolor='black')
xmax = 20
ymax = 50
for n in range(1, xmax+1):
if is_prime_power(n):
if n == 1:
h = log(2*pi)
else:
h = log(factor(n)[0][0])
c = (float(h)/log(xmax), 0, 1-float(h)/log(xmax))
g += arrow((log(n),-1),(log(n),ymax), width=2, rgbcolor=c)
if n <= 3 or n in [5, 8, 13, 19]:
g += text("log(%s)"%n, (log(n),-5), rgbcolor='black', fontsize=12)
g += line([(log(n),-2), (log(n),0)], rgbcolor='black')
g += line([(-1/2.0,0), (xmax+1,0)], thickness=2)
g.save(dir+'/bigPsi_prime.%s'%ext,
xmin=-1/2.0, xmax=log(xmax), ymax=ymax,
axes=False, gridlines=True, figsize=[8,3])
def fig_Phi(dir=0, ext=0):
g = line([(0,0),(0,100)], rgbcolor='black')
xmax = 20
ymax = 50
for n in range(1, xmax+1):
if is_prime_power(n):
if n == 1:
h = log(2*pi)
else:
h = log(factor(n)[0][0])
h *= exp(-log(n)/2)
c = (float(h)/log(xmax), 0, 1-float(h)/log(xmax))
g += arrow((log(n),-1),(log(n),ymax), width=2, rgbcolor=c)
g += arrow((-log(n),-1),(-log(n),ymax), width=2, rgbcolor=c)
if n in [2, 5, 16]:
g += text("log(%s)"%n, (log(n),-5), rgbcolor='black', fontsize=12)
g += line([(log(n),-2), (log(n),0)], rgbcolor='black')
g += text("log(%s)"%n, (-log(n),-5), rgbcolor='black', fontsize=12)
g += line([(-log(n),-2), (-log(n),0)], rgbcolor='black')
g += line([(-log(xmax)-1,0), (log(xmax)+1,0)], thickness=2)
g.save(dir+'/bigPhi.%s'%ext,
xmin=-log(xmax), xmax=log(xmax), ymax=ymax,
axes=False, gridlines=True, figsize=[8,3])
##############################################################
# Sin, etc. waves
##############################################################
def fig_waves(dir,ext):
g = plot(sin, -2.1*pi, 2.1*pi, thickness=2)
g.save(dir+'/sin.%s'%ext)
x = var('x')
c = 5
# See for why this is right http://www.phy.mtu.edu/~suits/notefreqs.html
g = plot(sin(x), 0, c*pi) + plot(sin(329.0/261*x), 0, c*pi, color='red')
g.save(dir+'/sin-twofreq.%s'%ext)
g = plot(sin(x) + sin(329.0/261*x), 0, c*pi)
g.save(dir+'/sin-twofreq-sum.%s'%ext)
c=5
g = plot(sin(x), -2, c*pi) + plot(sin(x + 1.5), -2, c*pi, color='red')
g += text("Phase", (-3,.5), fontsize=14, rgbcolor='black')
g += arrow((-2.5,.4), (-1.5,0), width=1, rgbcolor='black')
g += arrow((-2,.4), (0,0), width=1, rgbcolor='black')
g.save(dir+'/sin-twofreq-phase.%s'%ext, xmin=-5)
g = plot(sin(x) + sin(329.0/261*x + 0.4), 0, c*pi)
g.save(dir+'/sin-twofreq-phase-sum.%s'%ext)
f = (sin(x) + sin(329.0/261*x + 0.4)).function(x)
g = points([(i,f(i)) for i in erange(0,0.1,Ellipsis,5*pi)])
g.save(dir+'/sin-twofreq-phase-sum-points.%s'%ext)
g = points([(i,f(i)) for i in erange(0,0.1,Ellipsis,5*pi)])
g += plot(f, (0, 5*pi), rgbcolor='black')
g.save(dir+'/sin-twofreq-phase-sum-fill.%s'%ext)
f = (0.7*sin(x) + sin(329.0/261*x + 0.4)).function(x)
g = plot(f, (0, 5*pi))
g.save(dir+'/sound-ce-general_sum.%s'%ext)
B = bar_chart([0,0,0,0.7, 0, 1])
B += text("C", (3.2,-0.05), rgbcolor='black', fontsize=18)
B += text("D", (4.2,-0.05), rgbcolor='black', fontsize=18)
B += text("E", (5.2,-0.05), rgbcolor='black', fontsize=18)
B.save(dir+'/sound-ce-general_sum-blips.%s'%ext, axes=False, xmin=0)
f = (0.7*sin(x) + sin(329.0/261*x + 0.4) + 0.5*sin(300.0/261*x + 0.7) + 0.3*sin(1.5*x + 0.2) + 1.1*sin(4*x+0.1)).function(x)
g = plot(f, (0, 5*pi))
g.save(dir + '/complicated-wave.%s'%ext)
##############################################################
# Pure Tone
##############################################################
def pure_tone(a=2, b=1, theta=1/2.0, tmin=-15, tmax=15):
t = var('t')
return plot(a*cos(b+theta*t), (t,tmin,tmax))
def fig_pure_tone(dir,ext):
g = pure_tone()
g.save(dir + '/pure_tone.%s'%ext, figsize=[8,2])
def mixed_tone3(a=[2,3,5], b=[1,4,-2], theta=[1/2.0,2,-1], tmin=-15, tmax=15):
t = var('t')
f = sum(a[i]*cos(b[i]+theta[i]*t) for i in range(3))
return plot(f, (t,tmin,tmax)), f
def fig_mixed_tone3(dir,ext):
g, f = mixed_tone3()
g.save(dir + '/mixed_tone3.%s'%ext, figsize=[8,2])
##############################################################
# Sawtooth
##############################################################
def fig_sawtooth(dir,ext):
g = plot_sawtooth(3)
g.save(dir+'/sawtooth.%s'%ext, figsize=[10,2])
g = plot_sawtooth_spectrum(18)
g.save(dir+'/sawtooth-spectrum.%s'%ext, figsize=[8,3])
def plot_sawtooth(xmax):
v = []
for x in range(xmax+1):
v += [(x,0), (x+1,1), (x+1,0)]
return line(v)
def plot_sawtooth_spectrum(xmax):
# the spectrum is a spike of height 1/k at k
return sum([line([(k,0),(k,1.0/k)],thickness=3) for k in range(1,xmax+1)])
##############################################################
# Fourier Transforms: second visit
##############################################################
def fig_even_function(dir, ext):
x = var('x')
f = cos(x) + sin(x**2) + sqrt(x)
def g(z):
return f(x=abs(z))
h = plot(g,-4,4)
h.save(dir + '/even_function.%s'%ext, figsize=[9,3])
def fig_even_pi(dir, ext):
g1 = prime_pi.plot(0,50, rgbcolor='red')
g2 = prime_pi.plot(0,50, rgbcolor='red')
g2[0].xdata = [-a for a in g2[0].xdata]
g = g1 + g2
g.save(dir + '/even_pi.%s'%ext, figsize=[10,3],xmin=-49,xmax=49)
def fig_oo_integral(dir, ext):
t = var('t')
f = (1/(t**2+1)*cos(t)).function(t)
a = f.find_root(1,2.5)
b = f.find_root(4,6)
c = f.find_root(7,8)
g = plot(f,(t,-13,13), fill='axis', fillcolor='yellow', fillalpha=1, thickness=2)
g += plot(f,(t,-a,a), fill='axis', fillcolor='grey', fillalpha=1, thickness=2)
g += plot(f,(t,-c,-b), fill='axis', fillcolor='grey', fillalpha=1, thickness=2)
g += plot(f,(t,b,c), fill='axis', fillcolor='grey', fillalpha=1, thickness=2)
g += text(r"$\int_{-\infty}^{\,\infty} f(x) dx$", (-7,0.5), rgbcolor='black', fontsize=30)
#g.show(figsize=[9,3], xmin=-10,xmax=10)
g.save(dir+'/oo_integral.%s'%ext, figsize=[9,3], xmin=-10,xmax=10)
def fig_fourier_machine(dir, ext):
g = text("$f(t)$", (-1/2.0, 1/2.0), fontsize=20, rgbcolor='black')
g += text(r"$\hat{f}(\theta)$", (3/2.0, 1/2.0), fontsize=20, rgbcolor='black')
g += line([(0,0),(0,1),(1,1),(1,0),(0,0)],rgbcolor='black',thickness=3)
g += arrow((-1/2.0 + 1/9.0, 1/2.0), (-1/16.0, 1/2.0), rgbcolor='black')
g += arrow((1 + 1/16.0, 1/2.0), (1 + 1/2.0 - 1/9.0, 1/2.0), rgbcolor='black')
t = var('t')
g += plot((1/2.0)*t*cos(14*t) + 1/2.0, (t,0,1), fill='axis', thickness=0.8)
g.save(dir+'/fourier_machine.%s'%ext, axes=False, axes_pad=0.1)
##############################################################
# Distribution section
##############################################################
def fig_simple_staircase(dir,ext):
v = [(-1,0), (0,1), (1,3), (2,3)]
g = plot_step_function(v, thickness=3, vertical_lines=True)
g.save(dir+'/simple_staircase.%s'%ext)
##############################################################
# Plots of Fourier transform Phihat_even.
##############################################################
def fig_mini_phihat_even(dir,ext):
G = plot_symbolic_phihat(5, 1, 100, 10000, zeros=False)
G.save(dir + "/mini_phihat_even.%s"%ext, figsize=[9,3], ymin=0)
def fig_phihat_even(dir,ext):
for bound in [5, 20, 50, 500]:
G = plot_symbolic_phihat(bound, 2, 100,
plot_points=10**5)
G.save(dir+'/phihat_even-%s.%s'%(bound,ext), figsize=[9,3], ymin=0)
def fig_phihat_even_all(dir, ext):
p = [plot_symbolic_phihat(n, 2,100) for n in [5,20,50,500]]
[a.ymin(0) for a in p]
g = graphics_array([[a] for a in p],4,1)
g.save(dir+'/phihat_even_all.%s'%ext)
def symbolic_phihat(bound):
t = var('t')
f = SR(0)
for pn in prime_powers(bound+1):
if pn == 1: continue
p, e = factor(pn)[0]
f += - log(p)/sqrt(pn) * cos(t*log(pn))
return f
def plot_symbolic_phihat(bound, xmin, xmax, plot_points=1000, zeros=True):
f = symbolic_phihat(bound)
P = plot(f, (t,xmin, xmax), plot_points=plot_points)
if not zeros:
return P
ym = P.ymax()
Z = []
for y in zeta_zeros():
if y > xmax: break
Z.append(y)
zeros = sum([arrow((x,ym),(x,0),rgbcolor='red',width=0.5,arrowsize=2)
for i, x in enumerate(Z)])
return P + zeros
##############################################################
# Calculus pictures
##############################################################
def fig_aplusone(dir,ext):
a = var('a')
g = plot(a+1, -5,8, thickness=3)
g.save(dir + '/graph_aplusone.%s'%ext, gridlines=True, frame=True)
def fig_calculus(dir,ext):
x = var('x')
t = 8; f = log(x); fprime = f.diff()
fontsize = 14
g = plot(f, (0.5,t))
g += plot(x*fprime(x=4)+(f(x=4)-4*fprime(x=4)), (.5,t), rgbcolor='black')
g += point((4,f(x=4)), pointsize=20, rgbcolor='black')
g += plot(fprime, (0.5,t), rgbcolor='red')
g += text("What is the slope of the tangent line?", (3.5,2.2),
fontsize=fontsize, rgbcolor='black')
g += text("Here it is!",(5,.9), fontsize=fontsize, rgbcolor='black')
g += arrow((4.7,.76), (4, fprime(x=4)), rgbcolor='black')
g += point((4,fprime(x=4)),rgbcolor='black', pointsize=20)
g += text("How to compute the slope? This is Calculus.", (4.3, -0.5),
fontsize=fontsize, rgbcolor='black')
g.save(dir + '/graph_slope_deriv.%s'%ext, gridlines=True, frame=True)
def fig_jump(dir,ext):
# straight jump
v = line( [(0,1), (3,1), (3,2), (6,2)], thickness=2)
v.ymin(0)
v.save(dir + '/jump.%s'%ext)
# smooth approximation to a jump
e = .7
v = line( [(0,1), (3-e,1)], thickness=2) + line([(3+e,2), (6,2)], thickness=2)
v.ymin(0)
S = spline( [(3-e,1), (3-e + e/20.0, 1), (3,1.5), (3+e-e/20.0, 2), (3+e,2)] )
v += plot(S, (3-e, 3+e), thickness=2)
v.save(dir + '/jump-smooth.%s'%ext, ymin=0)
# derivatives of smooth jumps
for e in ['7', '2', '05', '01']:
g = smoothderiv(float('.'+e))
g.save(dir + '/jump-smooth-deriv-%s.%s'%(e,ext))
def smoothderiv(e):
def deriv(f, delta):
# return very approximate numerical derivative of callable f, using
# a given choice of delta
def g(x):
return (f(x + delta) - f(x))/delta
return g
v = line( [(0,1), (3-e,1)], thickness=2) + line([(3+e,2), (6,2)], thickness=2)
v.ymin(0)
S = spline( [(3-e,1), (3-e+e/20.0, 1), (3,1.5), (3+e-e/20.0, 2), (3+e,2)] )
v += plot(S, (3-e, 3+e), thickness=2)
D = (line( [(0,0), (3-e,0)], rgbcolor='red', thickness=2) +
line([(3+e,0), (6,0)], rgbcolor='red', thickness=2))
D += plot( deriv(S, e/30.0), (3-e, 3+e), rgbcolor='red', thickness=2)
v += D
return v
def fig_dirac(dir,ext):
g = line([(0,0),(0,100)], rgbcolor='black')
g += arrow((0,-1),(0,50), width=3)
g += line([(-1.2,0), (1.25,0)], thickness=3)
g.save(dir+'/dirac_delta.%s'%ext,
frame=False, xmin=-1, xmax=1, ymax=50, axes=False, gridlines=True)
def fig_two_delta(dir,ext):
g = line([(0,0),(0,100)], rgbcolor='black')
g += arrow((-1/2.0,-1),(-1/2.0,50),width=3)
g += arrow((1/2.0,-1),(1/2.0,50),width=3)
g += line([(-1.2,0), (1.25,0)], thickness=3)
g += text("$-x$", (-1/2.0 - 1/20.0,-4), rgbcolor='black', fontsize=35, horizontal_alignment='center')
g += text("$x$", (1/2.0,-4), rgbcolor='black', fontsize=35, horizontal_alignment='center')
g.save(dir+'/two_delta.%s'%ext,
frame=False, xmin=-1, xmax=1, ymax=50, axes=False, gridlines=True)
##############################################################
# Cosine sums
##############################################################
def fig_phi(dir,ext):
g = phi_approx_plot(2,30,1000)
g.save(dir+'/phi_cos_sum_2_30_1000.%s'%ext, ymin=-5,ymax=160)
g = phi_interval_plot(26, 34)
g.save(dir+'/phi_cos_sum_26_34_1000.%s'%ext, axes=False)
g = phi_interval_plot(1010,1026,15000,drop=60)
g.save(dir+'/phi_cos_sum_1010_1026_15000.%s'%ext, axes=False, ymin=-50)
def phi_interval_plot(xmin, xmax, zeros=1000,fontsize=12,drop=20):
g = phi_approx_plot(xmin,xmax,zeros=zeros,fontsize=fontsize,drop=drop)
g += line([(xmin,0),(xmax,0)],rgbcolor='black')
return g
def phi_approx(m, positive_only=False, symbolic=False):
if symbolic:
assert not positive_only
s = var('s')
return -sum(cos(log(s)*t) for t in zeta_zeros()[:m])
from math import cos, log
v = [float(z) for z in zeta_zeros()[:m]]
def f(s):
s = log(float(s))
return -sum(cos(s*t) for t in v)
if positive_only:
z = float(0)
def g(s):
return max(f(s),z)
return g
else:
return f
def phi_approx_plot(xmin, xmax, zeros, pnts=2000, dots=True, positive_only=False,
fontsize=7, drop=10, **args):
phi = phi_approx(zeros, positive_only)
g = plot(phi, xmin, xmax, alpha=0.7,
plot_points=pnts, adaptive_recursion=0, **args)
g.xmin(xmin); g.xmax(xmax)
if dots: g += primepower_dots(xmin,xmax, fontsize=fontsize,drop=drop)
return g
def primepower_dots(xmin, xmax, fontsize=7, drop=10):
"""
Return plot with dots at the prime powers in the given range.
"""
g = Graphics()
for n in range(max(xmin,2),ceil(xmax)+1):
F = factor(n)
if len(F) == 1:
g += point((n,0), pointsize=50*log(F[0][0]), rgbcolor=(1,0,0))
if fontsize>0:
g += text(str(n),(n,-drop),fontsize=fontsize, rgbcolor='black')
g.xmin(xmin)
g.xmax(xmax)
return g
##############################################################
# psi waves
##############################################################
def fig_psi_waves(dir, ext):
theta, t = var('theta, t')
f = (theta*sin(t*theta) + 1/2.0 * cos(t*theta)) / (theta**2 + 1/4.0)
g = plot(f(theta=zeta_zeros()[0]),(t,0,pi))
g.save(dir + '/psi_just_waves1.%s'%ext)
g += plot(f(theta=zeta_zeros()[1]),(t,0,pi), rgbcolor='red')
g.save(dir + '/psi_2_waves.%s'%ext)
f = (e**(t/2)*theta*sin(t*theta) + 1/2.0 * e**(t/2) * cos(t*theta))/(theta**2 + 1/4.0)
g = plot(f(theta=zeta_zeros()[0]),(t,0,pi))
g.save(dir + '/psi_with_first_zero.%s'%ext)
g += plot(f(theta=zeta_zeros()[1]),(t,0,pi), rgbcolor='red')
g.save(dir + '/psi_with_exp_2.%s'%ext)
##############################################################
# Riemann's R_k
##############################################################
def fig_moebius(dir,ext):
g = plot(moebius,0, 50)
g.save(dir+'/moebius.%s'%ext,figsize=[10,2], axes_pad=.1)
def riemann_R(terms):
c = [0] + [float(moebius(n))/n for n in range(1, terms+1)]
def f(x):
x = float(x)
s = float(0)
for n in range(1,terms+1):
y = x**(1.0/n)
if y < 2:
break
s += c[n] * Li(y)
return s
return f
def plot_pi_riemann_gauss(xmin, xmax, terms):
R = riemann_R(terms)
g = plot(R, xmin, xmax)
g += plot(prime_pi, xmin, xmax, rgbcolor='red')
g += plot(Li, xmin, xmax, rgbcolor='purple')
#x = var('x'); g += plot(x/(log(x)-1), xmin, xmax, rgbcolor='green')
return g
def fig_pi_riemann_gauss(dir,ext):
for m in [100,1000]:
g = plot_pi_riemann_gauss(2,m, 100)
g.save(dir+'/pi_riemann_gauss_%s.%s'%(m,ext))
g = plot_pi_riemann_gauss(10000,11000, 100)
g.save(dir +'/pi_riemann_gauss_10000-11000.%s'%ext, axes=False, frame=True)
class RiemannPiApproximation:
r"""
Riemann's explicit formula for `\pi(X)`.
EXAMPLES::
We compute Riemann's analytic approximatin to `\pi(25)` using `R_{10}(x)`:
sage: R = RiemannPiApproximation(10, 100); R
Riemann explicit formula for pi(x) for x <= 100 using R_k for k <= 10
sage: R.Rk(100, 10)
25.3364299527
sage: prime_pi(100)
25
"""
def __init__(self, kmax, xmax, prec=50):
"""
INPUT:
- ``kmax`` -- (integer) large k allowed
- ``xmax`` -- (float) largest input x value allowed
- ``prec`` -- (default: 50) determines precision of certain series approximations
"""
from math import log
self.xmax = xmax
self.kmax = kmax
self.prec = prec
self.N = int(log(xmax)/log(2))
self.rho_k = [0] + [CDF(0.5, zeta_zeros()[k-1]) for k in range(1,kmax+1)]
self.rho = [[0]+[rho_k / float(n) for n in range(1, self.N+1)] for rho_k in self.rho_k]
self.mu = [float(x) for x in moebius.range(0,self.N+2)]
self.msum = sum([moebius(n) for n in xrange(1,self.N+1)])
self._init_coeffs()
def __repr__(self):
return "Riemann explicit formula for pi(x) for x <= %s using R_k for k <= %s"%(self.xmax, self.kmax)
def _init_coeffs(self):
self.coeffs = [1]
n_factorial = 1.0
for n in xrange(1, self.prec):
n_factorial *= n
zeta_value = float(abs(zeta(n+1)))
self.coeffs.append(float(1.0/(n_factorial*n*zeta_value)))
def _check(self, x, k):
if x > self.xmax:
raise ValueError, "x (=%s) must be at most %s"%(x, self.xmax)
if k > self.kmax:
raise ValueError, "k (=%s) must be at most %s"%(k, self.kmax)
@cached_method
def R(self, x):
from math import log
y = log(x)
z = y
a = float(1)
for n in xrange(1,self.prec):
a += self.coeffs[n]*z
z *= y
return a
@cached_method
def Rk(self, x, k):
return self.R(x) + self.Sk(x, k)
@cached_method
def Sk(self, x, k):
"""
Compute approximate correction term, so Rk(x,k) = R(x) + Sk(x,k)
"""
self._check(x, k)
from math import atan, pi, log
log_x = log(x) # base e
# This is from equation 32 on page 978 of Riesel-Gohl.
term1 = self.msum / (2*log_x) + \
(1/pi) * atan(pi/log_x)
# This is from equation 19 on page 975
term2 = sum(self.Tk(x, v) for v in xrange(1,k+1))
return term1 + term2
@cached_method
def Tk(self, x, k):
"""
Compute sum from 1 to N of
mu(n)/n * ( -2*sqrt(x) * cos(im(rho_k/n)*log(x) \
- arg(rho_k/n)) / ( pi_over_2 * log(x) )
"""
self._check(x, k)
x = float(x)
log_x = log(x)
val = float(0)
rho_k = self.rho_k[k]
rho = self.rho[k]
for n in xrange(1, self.N+1):
rho_k_over_n = rho[n]
mu_n = self.mu[n]
if mu_n != 0:
z = Ei( rho_k_over_n * log_x)
val += (mu_n/float(n)) * (2*z).real()
return -val
def plot_Rk(self, k, xmin=2, xmax=None, **kwds):
r"""
Plot `\pi(x)` and `R_k` between ``xmin`` and ``xmax``. If `k`
is a list, also plot every `R_k`, for `k` in the list.
The **kwds are passed onto the line function, which is used
to draw the plot of `R_k`.
"""
if not xmax:
xmax = self.xmax
else:
if xmax > self.xmax:
raise ValueError, "xmax must be at most %s"%self.xmax
xmax = min(self.xmax, xmax)
if kwds.has_key('plot_points'):
plot_points = kwds['plot_points']
del kwds['plot_points']
else:
plot_points = 100
eps = float(xmax-xmin)/plot_points
if not isinstance(k, list):
k = [k]
f = sum(line([(x,self.Rk(x,kk)) for x in erange(xmin,xmin+eps,Ellipsis,xmax)], **kwds)
for kk in k)
g = prime_pi.plot(xmin, xmax, rgbcolor='red')
return g+f
def fig_Rk(dir, ext):
R = RiemannPiApproximation(50, 500, 50)
for k,xmin,xmax in [(1,2,100), (10,2,100), (25,2,100),
(50,2,100), (50,2,500) ]:
print "plotting k=%s"%k
g = R.plot_Rk(k, xmin, xmax, plot_points=300, thickness=0.65)
g.save(dir + '/Rk_%s_%s_%s.%s'%(k,xmin,xmax,ext))
#
g = R.plot_Rk(50, 350, 400, plot_points=200)
g += plot(Li,350,400,rgbcolor='green')
g.save(dir + '/Rk_50_350_400.%s'%ext)
#################################################################
# Import fast cython versions of some functions, if available.
try:
from psage.rh.mazur_stein.book_cython import mult_parities
except ImportError, msg:
print msg
print "Cython versions of some functions not available."
mult_parieties = mult_parities_python
| Python |
# Code related to the expository book on the Riemann Hypothesis
# by Mazur-Stein
| Python |
#################################################################################
#
# (c) Copyright 2011 William Stein
#
# This file is part of PSAGE.
#
# PSAGE is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 2 of the License, or
# (at your option) any later version.
#
# PSAGE is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
#
#################################################################################
"""
We study low zeros.
"""
from sage.all import is_fundamental_discriminant, ZZ, parallel, var
from sage.libs.lcalc.lcalc_Lfunction import (
Lfunction_from_character,
Lfunction_from_elliptic_curve)
class LowZeros(object):
def __init__(self, num_zeros, params, ncpus=None):
self.num_zeros = num_zeros
self.params = params
self.ncpus = ncpus
self.zeros = self.compute_all_low_zeros(self.ncpus)
def compute_all_low_zeros(self, ncpus=None):
if ncpus is not None:
if ncpus == 1:
return [self.compute_low_zeros(x) for x in self.params]
else:
@parallel(ncpus)
def f(z):
return self.compute_low_zeros(z)
else:
@parallel
def f(z):
return self.compute_low_zeros(z)
# Get the answers back, and sort them in the same order
# as the input params. This is *very* important to do, i.e.,
# to get the order right!
Z = dict([(x[0][0][0], x[1]) for x in f(self.params)])
return [Z[x] for x in self.params]
def ith_zero_means(self, i=0):
z = self.zeros
s = 0.0
m = []
for j in range(len(self.params)):
s += z[j][i] # i-th zero for j-th parameter (e.g., j-th discriminant)
# The mean is s/(j+1)
m.append( (self.params[j], s/(j+1)) )
return m
def ith_zeros(self, i=0):
return [(self.params[j], self.zeros[j][i]) for j in range(len(self.params))]
def fundamental_discriminants(A, B):
"""Return the fundamental discriminants between A and B (inclusive), as Sage integers,
ordered by absolute value, with negatives first when abs same."""
v = [ZZ(D) for D in range(A, B+1) if is_fundamental_discriminant(D)]
v.sort(lambda x,y: cmp((abs(x),sgn(x)),(abs(y),sgn(y))))
return v
class RealQuadratic(LowZeros):
def __init__(self, num_zeros, max_D, **kwds):
self.max_D = max_D
params = fundamental_discriminants(2,max_D)
super(RealQuadratic, self).__init__(num_zeros, params, **kwds)
def __repr__(self):
return "Family of real quadratic zeta functions with discriminant <= %s"%self.max_D
def compute_low_zeros(self, D):
return quadratic_twist_zeros(D, self.num_zeros)
class QuadraticImaginary(LowZeros):
def __init__(self, num_zeros, min_D, **kwds):
self.min_D = min_D
params = fundamental_discriminant(min_D, -1)
super(QuadraticImaginary, self).__init__(num_zeros, params, **kwds)
def __repr__(self):
return "Family of quadratic imaginary zeta functions with discriminant <= %s"%self.max_D
def compute_low_zeros(self, D):
return quadratic_twist_zeros(D, self.num_zeros)
class EllCurveZeros(LowZeros):
def __init__(self, num_zeros, curves, **kwds):
# sort the curves into batches by conductor
d = {}
for E in curves:
N = E.conductor()
if d.has_key(N):
d[N].append(E)
else:
d[N] = [E]
params = list(sorted(d.keys()))
self.d = d
super(EllCurveZeros, self).__init__(num_zeros, params, **kwds)
def __repr__(self):
return "Family of %s elliptic curve L functions"%len(self.params)
def compute_low_zeros(self, N):
a = []
for E in self.d[N]:
L = Lfunction_from_elliptic_curve(E)
a.append(L.find_zeros_via_N(self.num_zeros))
num_curves = len(a)
return [sum(a[i][j] for i in range(num_curves))/num_curves
for j in range(self.num_zeros)]
class EllQuadraticTwists(LowZeros):
def __init__(self, num_zeros, curve, discs, number_of_coeffs=10000, **kwds):
self.curve = curve
self.number_of_coeffs = number_of_coeffs
params = discs
super(EllQuadraticTwists, self).__init__(num_zeros, params, **kwds)
def __repr__(self):
return "Family of %s elliptic curve L functions"%len(self.params)
def compute_low_zeros(self, D):
L = Lfunction_from_elliptic_curve(self.curve.quadratic_twist(D),
number_of_coeffs=self.number_of_coeffs)
return L.find_zeros_via_N(self.num_zeros)
def quadratic_twist_zeros(D, n, algorithm='clib'):
"""
Return imaginary parts of the first n zeros of all the Dirichlet
character corresponding to the quadratic field of discriminant D.
INPUT:
- D -- fundamental discriminant
- n -- number of zeros to find
- algorithm -- 'clib' (use C library) or 'subprocess' (open another process)
"""
if algorithm == 'clib':
L = Lfunction_from_character(kronecker_character(D), type="int")
return L.find_zeros_via_N(n)
elif algorithm == 'subprocess':
assert is_fundamental_discriminant(D)
cmd = "lcalc -z %s --twist-quadratic --start %s --finish %s"%(n, D, D)
out = os.popen(cmd).read().split()
return [float(out[i]) for i in range(len(out)) if i%2!=0]
else:
raise ValueError, "unknown algorithm '%s'"%algorithm
def fit_to_power_of_log(v):
"""
INPUT:
- v -- a list of (x,y) values, with x increasing.
OUTPUT:
- number a such that data is "approximated" by b*log(x)^a.
"""
# ALGORITHM: transform data to (log(log(x)), log(y)) and find the slope
# of the best line that fits this transformed data.
# This is the right thing to do, since if y = log(x)^a, then log(y) = a*log(log(x)).
from math import log, exp
w = [(log(log(x)), log(y)) for x,y in v]
a, b = least_squares_fit(w)
return float(a), exp(float(b))
def least_squares_fit(v):
"""
INPUT:
- v -- a list of (x,y) values that are floats
OUTPUT:
- a and b such that the line y=a*x + b is the least squares fit for the data.
All computations are done using floats.
"""
import numpy
x = numpy.array([a[0] for a in v])
y = numpy.array([a[1] for a in v])
A = numpy.vstack([x, numpy.ones(len(x))]).T
a, b = numpy.linalg.lstsq(A,y)[0]
return a, b
class XLogInv(object):
def __init__(self, a):
self.a = a
x = var('x')
self.f = (x * (log(x) - a))._fast_float_(x)
def __repr__(self):
return "The inverse of the function x*(log(x) - %s), for sufficiently large positive x"%self.a
def __call__(self, y):
return find_root(self.f - float(y), 1, 10e9)
| Python |
# Code related to the Riemann Hypothesis
| Python |
"""
Triple product L-series.
WARNING: The code in here gets the algorithm down, but is (1) pure
Python, and (2) runs into a limit since in order to actually use it in
even the first example, one needs to send a huge number of
coefficients to GP/PARI over a ptty, which results in a crash.
So currently this code does not actually work in a single case!
To fix it:
* find a better way to send a large number of coefficients to pari
* make a version of the code that instead uses lcalc
Note that this code still has some value, since it can be used to
compute the Dirichlet series coefficients of the triple product.
"""
#################################################################################
#
# (c) Copyright 2011 William Stein
#
# This file is part of PSAGE
#
# PSAGE is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# PSAGE is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
#
#################################################################################
from sage.all import ZZ, RDF, CDF
R_cdf = CDF['x']
pi = RDF.pi()
def quad_roots(a, p):
"""
Return the two complex roots of X^2 - a*X + p.
INPUT:
- `a` -- a real number
- `p` -- a prime number
OUTPUT:
- 2-tuple of complex numbers
EXAMPLES::
"""
t = R_cdf([p, -a, 1]).roots()
return (t[0][0], t[1][0])
class TripleProductLseries(object):
"""
A triple product `L`-series attached to three newforms of level `N`.
"""
def __init__(self, N, f, g, h):
"""
INPUT:
- N -- squarefree integer
- f -- an object such that for n>=0, we have
f[n] = a_n(f) = n-th Fourier coefficient of
a newform on Gamma_0(N).
- g -- like f
- h -- like f
"""
self._N = ZZ(N)
if not (self._N.is_squarefree() and self._N > 0):
raise ValueError, "N (=%s) must be a squarefree positive integer"%self._N
self._newforms = (f,g,h)
self._gen = RDF['X'].gen()
self._genC = CDF['X'].gen()
self._series = RDF[['X']]
def __repr__(self):
"""
Return text representation of this triple product `L`-function.
"""
return "Triple product L-function L(s,f,g,h) of three newforms on Gamma_0(%s)"%self._N
def level(self):
"""
Return the common level `N` of the newforms in the triple product.
OUTPUT:
- Integer
EXAMPLES::
"""
return self._N
def newforms(self):
"""
Return 3-tuple (f,g,h) of the data that defines the newforms
in the triple product.
OUTPUT:
- 3-tuple
EXAMPLES::
"""
return self._newforms
def _local_series(self, p, prec):
"""
Return power series in `X` (which you should think of as `p^{-s}`)
that is the expansion to precision prec of the local factor at `p`
of this `L`-series.
INPUT:
- p -- prime
- prec -- positive integer
OUTPUT:
- power series that ends in a term ``O(X^prec)``.
"""
f = self._series(self.charpoly(p), prec)
return f**(-1)
def dirichlet_series(self, prec, eps=1e-10):
"""
Return the Dirichlet series representation of self, up to the given
precision.
INPUT:
- prec -- positive integer
- eps -- None or a positive real; any coefficient with absolute
value less than eps is set to 0.
"""
coeffs = self.dirichlet_series_coeffs(prec, eps)
return DirichletSeries(coeffs, 's')
def dirichlet_series_coeffs(self, prec, eps=1e-10):
"""
Return the coefficients of the Dirichlet series representation
of self, up to the given precision.
INPUT:
- prec -- positive integer
- eps -- None or a positive real; any coefficient with absolute
value less than eps is set to 0.
"""
# Use multiplicativity to compute the Dirichlet series
# coefficients, then make a DirichletSeries object.
zero = RDF(0)
coeffs = [RDF(0),RDF(1)] + [None]*(prec-2)
from sage.all import log, floor # TODO: slow
# prime-power indexed coefficients
for p in prime_range(2, prec):
B = floor(log(prec, p)) + 1
series = self._local_series(p, B)
p_pow = p
for i in range(1, B):
coeffs[p_pow] = series[i] if (eps is None or abs(series[i])>eps) else zero
p_pow *= p
# non-prime-powers
from sage.all import factor
for n in range(2, prec):
if coeffs[n] is None:
a = prod(coeffs[p**e] for p, e in factor(n))
coeffs[n] = a if (eps is None or abs(a) > eps) else zero
return coeffs
def charpoly(self, p):
"""
Return the denominator as a polynomial in `X` (=`p^{-s}`) of the local
factor at `p` of this `L`-series.
The degree of the polynomial is ???? [[todo]].
INPUT:
- `p` -- prime
OUTPUT:
- polynomial in `X`
EXAMPLES::
"""
if self._N % p == 0:
return self._charpoly_bad(p)
else:
return self._charpoly_good(p)
def _charpoly_good(self, p):
"""
Internal function that returns the local charpoly at a good prime.
INPUT:
- `p` -- prime
OUTPUT:
- polynomial in `X`
EXAMPLES::
"""
Y = self._genC
a = [quad_roots(f[p], p) for f in self._newforms]
L = 1
for n in range(8):
d = ZZ(n).digits(2)
d = [0]*(3-len(d)) + d
L *= 1 - prod(a[i][d[i]] for i in range(3))*Y
return self._gen.parent()([x.real_part() for x in L])
def _charpoly_bad(self, p):
"""
Internal function that returns the local charpoly at a bad prime.
INPUT:
- `p` -- prime
OUTPUT:
- polynomial in `X`
EXAMPLES::
"""
X = self._gen
a_p, b_p, c_p = [f[p] for f in self._newforms]
return (1 - a_p*b_p*c_p * X) * (1 - a_p*b_p*c_p*p*X)**2
def epsilon(self, p=None):
"""
Return the local or global root number of this triple product
L-function.
INPUT:
- p -- None (default) or a prime divisor of the level
"""
if p is None:
# Right below equation (1.11) in [Gross-Kudla]
return -prod(self.epsilon(p) for p in self.level().prime_divisors())
else:
if not ZZ(p).is_prime():
raise ValueError, "p must be prime"
if self.level() % p != 0:
raise ValueError, "p must divide the level"
# Equation (1.3) in [Gross-Kudla]
a_p, b_p, c_p = [f[p] for f in self._newforms]
return -a_p*b_p*c_p
def dokchitser(self, prec):
# NOTE: In order to get the Dokchitser parameters of an L-function,
# it is useful to know that
#
# gamma(s) = 2^s*gamma(s/2)*gamma((s+1)/2) / (2*sqrt(pi))
#
conductor = self.level()**10
gammaV = [-1,-1,-1,0,0,0,0,1]
weight = 4
eps = self.epsilon()
poles = []
residues = []
from sage.lfunctions.dokchitser import Dokchitser
L = Dokchitser(conductor = conductor,
gammaV = gammaV,
weight = weight,
eps = eps,
poles = poles, residues=[])
#s = 'v=%s; a(k)=if(k>%s,0,v[k])'%(self.dirichlet_series_coeffs(prec), prec)
s = 'v=%s; a(k)=v[k]'%(self.dirichlet_series_coeffs(prec))
L.init_coeffs('a(k)', pari_precode=s)
return L
class DirichletSeries(object):
"""
A Dirichlet series.
"""
def __init__(self, coeffs, variable='s'):
"""
INPUT:
- ``coeffs`` -- a list of the coefficients of the Dirichlet series
such that the coefficient `a_n` in the sum `a_n/n^s` is ``coeffs[n]``.
- ``variable`` - a string
"""
self._coeffs = coeffs
self._variable = variable
def __repr__(self):
if self._coeffs[0]._is_atomic():
v = ['%s/%s^%s'%(self._coeffs[n], n, self._variable) for
n in range(1,len(self._coeffs)) if self._coeffs[n]]
s = ' + '.join(v)
s = s.replace(' + -',' - ')
else:
v = ['(%s)/%s^%s'%(self._coeffs[n], n, self._variable) for
n in range(1,len(self._coeffs)) if self._coeffs[n]]
s = ' + '.join(v)
return s
def __getitem__(self, *args):
return self._coeffs.__getitem__(*args)
| Python |
# Triple Product L-functions (e.g., like in Gross-Kudla)
| Python |
"""
General L-series
AUTHOR:
- William Stein
TODO:
- Symmetric powers (and modular degree -- see trac 9758)
- Triple product L-functions: Gross-Kudla, Zhang, etc -- see the code in triple_prod/triple.py
- Support L-calc L-function
- Make it so we use exactly one GP session for *all* of the Dokchitser L-functions
- Tensor products
- Genus 2 curves, via smalljac and genus2reduction
- Fast L-series of elliptic curves over number fields (not just sqrt(5)), via smalljac
- Inverse of number_of_coefficients function.
"""
#################################################################################
#
# (c) Copyright 2011 William Stein
#
# This file is part of PSAGE
#
# PSAGE is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# PSAGE is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
#
#################################################################################
import copy, math, types
from sage.all import prime_range, cached_method, sqrt, SR, vector
from sage.rings.all import is_RationalField, ZZ, Integer, QQ, O, ComplexField, CDF, primes, infinity as oo
from sage.schemes.elliptic_curves.ell_generic import is_EllipticCurve
from psage.ellcurve.lseries.helper import extend_multiplicatively_generic
from sage.misc.all import prod
from sage.modular.abvar.abvar import is_ModularAbelianVariety
from sage.modular.dirichlet import is_DirichletCharacter
from sage.lfunctions.dokchitser import Dokchitser
from sage.modular.modsym.space import is_ModularSymbolsSpace
from sage.modular.abvar.abvar import is_ModularAbelianVariety
from sage.rings.number_field.number_field_base import is_NumberField
import sage.modular.modform.element
from sage.modular.all import Newform
from sage.structure.factorization import Factorization
from sage.misc.mrange import cartesian_product_iterator
I = sqrt(-1)
def prec(s):
"""
Return precision of s, if it has a precision attribute. Otherwise
return 53. This is useful internally in this module.
EXAMPLES::
sage: from psage.lseries.eulerprod import prec
sage: prec(ComplexField(100)(1))
100
sage: prec(RealField(125)(1))
125
sage: prec(1/3)
53
"""
if hasattr(s, 'prec'):
return s.prec()
return 53
def norm(a):
"""
Return the norm of a, for a in either a number field or QQ.
This is a function used internally in this module, mainly because
elements of QQ and ZZ have no norm method.
EXAMPLES::
sage: from psage.lseries.eulerprod import norm
sage: K.<a> = NumberField(x^2-x-1)
sage: norm(a+5)
29
sage: (a+5).norm()
29
sage: norm(17)
17
"""
try:
return a.norm()
except AttributeError:
return a
def tiny(prec):
"""
Return a number that we consider tiny to the given precision prec
in bits. This is used in various places as "zero" to the given
precision for various checks, e.g., of correctness of the
functional equation.
"""
return max(1e-8, 1.0/2**(prec-1))
def prime_below(P):
"""
Return the prime in ZZ below the prime P (or element of QQ).
EXAMPLES::
sage: from psage.lseries.eulerprod import prime_below
sage: K.<a> = NumberField(x^2-x-1)
sage: prime_below(K.prime_above(11))
11
sage: prime_below(K.prime_above(5))
5
sage: prime_below(K.prime_above(3))
3
sage: prime_below(7)
7
"""
try:
return P.smallest_integer()
except AttributeError:
return ZZ(P)
class LSeriesDerivative(object):
"""
The formal derivative of an L-series.
EXAMPLES::
sage: from psage.lseries.eulerprod import LSeries
sage: L = LSeries('delta')
sage: L.derivative()
First derivative of L-function associated to Ramanujan's Delta (a weight 12 cusp form)
sage: L.derivative()(11/2)
0.125386233743526
We directly create an instance of the class (users shouldn't need to do this)::
sage: from psage.lseries.eulerprod import LSeriesDerivative
sage: Ld = LSeriesDerivative(L, 2); Ld
Second derivative of L-function associated to Ramanujan's Delta (a weight 12 cusp form)
sage: type(Ld)
<class 'psage.lseries.eulerprod.LSeriesDerivative'>
"""
def __init__(self, lseries, k):
"""
INPUT:
- lseries -- any LSeries object (derives from LseriesAbstract)
- k -- positive integer
"""
k = ZZ(k)
if k <= 0:
raise ValueError, "k must be a positive integer"
self._lseries = lseries
self._k = k
def __cmp__(self, right):
return cmp((self._lseries,self._k), (right._lseries, right._k))
def __call__(self, s):
"""
Return the value of this derivative at s, which must coerce to a
complex number. The computation is to the same precision as s,
or to 53 bits of precision if s is exact.
As usual, if s has large imaginary part, then there could be
substantial precision loss (a warning is printed in that case).
EXAMPLES::
sage: from psage.lseries.eulerprod import LSeries
sage: L = LSeries(EllipticCurve('389a'))
sage: L1 = L.derivative(1); L1(1)
-1.94715429754927e-20
sage: L1(2)
0.436337613850735
sage: L1(I)
-19.8890471908356 + 31.2633280771869*I
sage: L2 = L.derivative(2); L2(1)
1.51863300057685
sage: L2(I)
134.536162459604 - 62.6542402272310*I
"""
return self._lseries._function(prec(s)).derivative(s, self._k)
def __repr__(self):
"""
String representation of this derivative of an L-series.
EXAMPLES::
sage: from psage.lseries.eulerprod import LSeries
sage: L = LSeries('delta')
sage: L.derivative(1).__repr__()
"First derivative of L-function associated to Ramanujan's Delta (a weight 12 cusp form)"
sage: L.derivative(2).__repr__()
"Second derivative of L-function associated to Ramanujan's Delta (a weight 12 cusp form)"
sage: L.derivative(3).__repr__()
"Third derivative of L-function associated to Ramanujan's Delta (a weight 12 cusp form)"
sage: L.derivative(4).__repr__()
"4-th derivative of L-function associated to Ramanujan's Delta (a weight 12 cusp form)"
sage: L.derivative(2011).__repr__()
"2011-th derivative of L-function associated to Ramanujan's Delta (a weight 12 cusp form)"
"""
k = self._k
if k == 1:
kth = 'First'
elif k == 2:
kth = 'Second'
elif k == 3:
kth = 'Third'
else:
kth = '%s-th'%k
return "%s derivative of %s"%(kth, self._lseries)
def derivative(self, k=1):
"""
Return the k-th derivative of this derivative object.
EXAMPLES::
sage: from psage.lseries.eulerprod import LSeries
sage: f = Newforms(43,2,names='a')[1]; f
q + a1*q^2 - a1*q^3 + (-a1 + 2)*q^5 + O(q^6)
sage: L = LSeries(f); L1 = L.derivative()
sage: L1(1)
0.331674007376949
sage: L(1)
0.620539857407845
sage: L = LSeries(f); L1 = L.derivative(); L1
First derivative of L-series of a degree 2 newform of level 43 and weight 2
sage: L1.derivative()
Second derivative of L-series of a degree 2 newform of level 43 and weight 2
sage: L1.derivative(3)
4-th derivative of L-series of a degree 2 newform of level 43 and weight 2
"""
if k == 0:
return self
return LSeriesDerivative(self._lseries, self._k + k)
class LSeriesParentClass(object):
def __contains__(self, x):
return isinstance(x, (LSeriesAbstract, LSeriesProduct))
def __call__(self, x):
"""
EXAMPLES::
sage: from psage.lseries.eulerprod import LSeries
sage: L = LSeries('zeta')
sage: P = L.parent(); P
All L-series objects and their products
sage: P(L) is L
True
sage: P(L^3)
(Riemann Zeta function viewed as an L-series)^3
sage: (L^3).parent()
All L-series objects and their products
You can make the L-series attached to an object by coercing
that object into the parent::
sage: P(EllipticCurve('11a'))
L-series of Elliptic Curve defined by y^2 + y = x^3 - x^2 - 10*x - 20 over Rational Field
We also allow coercing in 1, because this is very useful for
formal factorizations and products::
sage: P(1)
1
Other numbers do not coerce in, of course::
sage: P(2)
Traceback (most recent call last):
...
TypeError
"""
if isinstance(x, LSeriesAbstract):
return x
elif isinstance(x, LSeriesProduct):
return x
elif x == 1:
return x
else:
try:
return LSeries(x)
except NotImplementedError:
raise TypeError
def __repr__(self):
"""
Return string representation of this parent object.
sage: from psage.lseries.eulerprod import LSeriesParent
sage: LSeriesParent.__repr__()
'All L-series objects and their products'
"""
return "All L-series objects and their products"
def __cmp__(self, right):
"""
Returns equality if right is an instance of
LSeriesParentClass; otherwise compare memory locations.
EXAMPLES::
sage: from psage.lseries.eulerprod import LSeriesParent, LSeriesParentClass
sage: cmp(LSeriesParent, LSeriesParentClass())
0
sage: cmp(LSeriesParent, 7) != 0
True
sage: cmp(7, LSeriesParent) == -cmp(LSeriesParent, 7)
True
"""
if isinstance(right, LSeriesParentClass):
return 0
return cmp(id(self), id(right))
LSeriesParent = LSeriesParentClass()
class LSeriesAbstract(object):
r"""
L-series defined by an Euler product.
The parameters that define the 'shape' of the L-series are:
conductor, hodge_numbers, weight, epsilon, poles, base_field
Let gamma(s) = prod( Gamma((s+h)/2) for h in hodge_numbers ).
Denote this L-series by L(s), and let `L^*(s) = A^s \gamma(s) L(s)`, where
`A = \sqrt(N)/\pi^{d/2}`, where d = len(hodge_numbers) and N = conductor.
Then the functional equation is
Lstar(s) = epsilon * Lstar(weight - s).
To actually use this class we create a derived class that in
addition implements a method _local_factor(P), that takes as input
a prime ideal P of K=base_field, and returns a polynomial, which
is typically the reversed characteristic polynomial of Frobenius
at P of Gal(Kbar/K) acting on the maximal unramified quotient of
some Galois representation. This class automatically computes the
Dirichlet series coefficients `a_n` from the local factors of the
`L`-function.
The derived class may optionally -- and purely as an optimization
-- define a method self._precompute_local_factors(bound,
prec=None), which is typically called before
[_local_factor(P) for P with norm(P) < bound]
is called in the course of various computations.
"""
def __init__(self,
conductor,
hodge_numbers,
weight,
epsilon,
poles,
residues,
base_field,
is_selfdual=True,
prec=53):
"""
INPUT:
- ``conductor`` -- list or number (in a subset of the
positive real numbers); if the conductor is a list, then
each conductor is tried in order (to the precision prec
below) until we find one that works.
- ``hodge_numbers`` -- list of numbers (in a subring of the complex numbers)
- ``weight`` -- number (in a subset of the positive real numbers)
- ``epsilon`` -- number (in a subring of the complex numbers)
- ``poles`` -- list of numbers (in subring of complex numbers); poles of the *completed* L-function
- ``residues`` -- list of residues at each pole given in poles or string "automatic"
- ``base_field`` -- QQ or a number field; local L-factors
correspond to nonzero prime ideals of this field.
- ``is_selfdual`` -- bool (default: True)
- ``prec`` -- integer (default: 53); precision to use when trying to figure
out parameters using the functional equation
EXAMPLES::
sage: from psage.lseries.eulerprod import LSeriesAbstract
sage: L = LSeriesAbstract(conductor=1, hodge_numbers=[0], weight=1, epsilon=1, poles=[1], residues=[-1], base_field=QQ)
sage: type(L)
<class 'psage.lseries.eulerprod.LSeriesAbstract'>
sage: L._conductor
1
sage: L._hodge_numbers
[0]
sage: L._weight
1
sage: L._epsilon
1
sage: L._poles
[1]
sage: L._residues
[-1]
sage: L._base_field
Rational Field
sage: L
Euler Product L-series with conductor 1, Hodge numbers [0], weight 1, epsilon 1, poles [1], residues [-1] over Rational Field
"""
self._anlist = {None:[]}
(self._conductor, self._hodge_numbers, self._weight, self._epsilon,
self._poles, self._residues, self._base_field, self._is_selfdual) = (
conductor, hodge_numbers, weight, epsilon, poles, residues,
base_field, is_selfdual)
# the following parameters allow for specifying a list of
# possibilities:
#
# conductor -- list of possible conductors
# hodge_numbers -- give a list of lists
# weight -- list of possible weights
# poles (residues must be the default 'automatic')
# epsilon -- list of possible epsilon's.
# 1. Figure out for which parameters we have multiple options
# 2. Run through them until checking each until one is found
# that works.
v = []
if isinstance(conductor, list):
v.append('_conductor')
if len(hodge_numbers)>0 and isinstance(hodge_numbers[0], list):
v.append('_hodge_numbers')
if isinstance(weight, list):
v.append('_weight')
if len(poles) > 0 and isinstance(poles[0], list):
v.append('_poles')
if isinstance(epsilon, list):
v.append('_epsilon')
if len(v) > 0:
found_params = False
for X in cartesian_product_iterator([getattr(self, attr) for attr in v]):
kwds = dict((v[i],X[i]) for i in range(len(v)))
if self._is_valid_parameters(prec=prec, save=True, **kwds):
found_params = True
break
if not found_params:
raise RuntimeError, "no choice of values for %s works"%(', '.join(v))
def _is_valid_parameters(self, prec=53, save=True, **kwds):
valid = False
try:
old = [(k, getattr(self, k)) for k in kwds.keys()]
for k,v in kwds.iteritems():
setattr(self, k, v)
self._function.clear_cache()
self._function(prec=prec)
try:
self._function(prec=prec)
valid = True
except RuntimeError:
pass
finally:
if not save:
for k, v in old:
setattr(self, k, v)
return valid
def __cmp__(self, right):
if self is right:
return 0
for a in ['degree', 'weight', 'conductor', 'epsilon', 'base_field']:
c = cmp(getattr(self, a)(), getattr(right, a)())
if c: return c
c = cmp(type(self), type(right))
return self._cmp(right)
def _cmp(self, right):
raise TypeError
def parent(self):
"""
Return parent of this L-series, which is the collection of all
L-series and their products.
EXAMPLES::
sage: from psage.lseries.eulerprod import LSeries
sage: L = LSeries('delta'); P = L.parent(); P
All L-series objects and their products
sage: L in P
True
"""
return LSeriesParent
def __pow__(self, n):
"""
Return the n-th power of this L-series, where n can be any integer.
EXAMPLES::
sage: from psage.lseries.eulerprod import LSeries
sage: L = LSeries('delta');
sage: L3 = L^3; L3
(L-function associated to Ramanujan's Delta (a weight 12 cusp form))^3
sage: L3(1)
0.0000524870430366548
sage: L(1)^3
0.0000524870430366548
sage: M = L^(-3); M(1)
19052.3211471761
sage: L(1)^(-3)
19052.3211471761
Higher precision::
sage: M = L^(-3); M(RealField(100)(1))
19052.321147176093380952680193
sage: L(RealField(100)(1))^(-3)
19052.321147176093380952680193
Special case -- 0th power -- is not allowed::
sage: L^0
Traceback (most recent call last):
...
ValueError: product must be nonempty
"""
return LSeriesProduct([(self, ZZ(n))])
def __mul__(self, right):
"""
Multiply two L-series, or an L-series times a formal product of L-series.
EXAMPLES::
sage: from psage.lseries.eulerprod import LSeries
sage: d = LSeries('delta'); z = LSeries('zeta')
sage: d * z
(Riemann Zeta function viewed as an L-series) * (L-function associated to Ramanujan's Delta (a weight 12 cusp form))
sage: d * (d * z)
(Riemann Zeta function viewed as an L-series) * (L-function associated to Ramanujan's Delta (a weight 12 cusp form))^2
"""
if isinstance(right, LSeriesAbstract):
return LSeriesProduct([(self, 1), (right, 1)])
elif isinstance(right, LSeriesProduct):
return right * self
raise TypeError
def __div__(self, right):
"""
Divide two L-series or formal L-series products.
EXAMPLES::
sage: from psage.lseries.eulerprod import LSeries
sage: d = LSeries('delta'); z = LSeries('zeta')
sage: d / z
(Riemann Zeta function viewed as an L-series)^-1 * (L-function associated to Ramanujan's Delta (a weight 12 cusp form))
sage: d / (z^3)
(Riemann Zeta function viewed as an L-series)^-3 * (L-function associated to Ramanujan's Delta (a weight 12 cusp form))
"""
if isinstance(right, LSeriesAbstract):
return LSeriesProduct([(self, 1), (right, -1)])
elif isinstance(right, LSeriesProduct):
return LSeriesProduct(Factorization([(self, 1)]) / right._factorization)
raise TypeError
def conductor(self):
"""
Return the conductor of this L-series.
EXAMPLES::
sage: from psage.lseries.eulerprod import LSeries
sage: LSeries('zeta').conductor()
1
sage: LSeries('delta').conductor()
1
sage: LSeries(EllipticCurve('11a')).conductor()
11
sage: LSeries(Newforms(33)[0]).conductor()
33
sage: LSeries(DirichletGroup(37).0).conductor()
37
sage: LSeries(kronecker_character(7)).conductor()
28
sage: kronecker_character(7).conductor()
28
sage: L = LSeries(EllipticCurve('11a3').base_extend(QQ[sqrt(2)]), prec=5)
sage: L.conductor().factor()
2^6 * 11^2
"""
return self._conductor
def hodge_numbers(self):
"""
Return the Hodge numbers of this L-series. These define the local Gamma factors.
EXAMPLES::
sage: from psage.lseries.eulerprod import LSeries
sage: LSeries('zeta').hodge_numbers()
[0]
sage: LSeries('delta').hodge_numbers()
[0, 1]
sage: LSeries(EllipticCurve('11a')).hodge_numbers()
[0, 1]
sage: LSeries(Newforms(43,names='a')[1]).hodge_numbers()
[0, 1]
sage: LSeries(DirichletGroup(37).0).hodge_numbers()
[1]
sage: LSeries(EllipticCurve(QQ[sqrt(-1)],[1,2]), prec=5).hodge_numbers() # long time
[0, 0, 1, 1]
"""
return list(self._hodge_numbers)
def weight(self):
"""
Return the weight of this L-series.
EXAMPLES::
sage: from psage.lseries.eulerprod import LSeries
sage: LSeries('zeta').weight()
1
sage: LSeries('delta').weight()
12
sage: LSeries(EllipticCurve('389a')).weight()
2
sage: LSeries(Newforms(43,names='a')[1]).weight()
2
sage: LSeries(Newforms(6,4)[0]).weight()
4
sage: LSeries(DirichletGroup(37).0).weight()
1
sage: L = LSeries(EllipticCurve('11a3').base_extend(QQ[sqrt(2)]),prec=5); L.weight()
2
"""
return self._weight
def poles(self):
"""
Poles of the *completed* L-function with the extra Gamma
factors included.
WARNING: These are not just the poles of self.
OUTPUT:
- list of numbers
EXAMPLES::
sage: from psage.lseries.eulerprod import LSeries
sage: LSeries('zeta').poles()
[0, 1]
sage: LSeries('delta').poles()
[]
"""
return list(self._poles)
def residues(self, prec=None):
"""
Residues of the *completed* L-function at each pole.
EXAMPLES::
sage: from psage.lseries.eulerprod import LSeries
sage: LSeries('zeta').residues()
[9, 8]
sage: LSeries('delta').residues()
[]
sage: v = LSeries('zeta').residues()
sage: v.append(10)
sage: LSeries('zeta').residues()
[9, 8]
The residues of the Dedekind Zeta function of a field are dynamically computed::
sage: K.<a> = NumberField(x^2 + 1)
sage: L = LSeries(K); L
Dedekind Zeta function of Number Field in a with defining polynomial x^2 + 1
If you just call residues you get back that they are automatically computed::
sage: L.residues()
'automatic'
But if you call with a specific precision, they are computed using that precision::
sage: L.residues(prec=53)
[-0.886226925452758]
sage: L.residues(prec=200)
[-0.88622692545275801364908374167057259139877472806119356410690]
"""
if self._residues == 'automatic':
if prec is None:
return self._residues
else:
C = ComplexField(prec)
return [C(a) for a in self._function(prec=prec).gp()('Lresidues')]
else:
return list(self._residues)
def base_field(self):
"""
EXAMPLES::
sage: from psage.lseries.eulerprod import LSeries
sage: LSeries('zeta').base_field()
Rational Field
sage: L = LSeries(EllipticCurve('11a3').base_extend(QQ[sqrt(2)]), prec=5); L.base_field()
Number Field in sqrt2 with defining polynomial x^2 - 2
"""
return self._base_field
def epsilon(self, prec=None):
"""
EXAMPLES::
sage: from psage.lseries.eulerprod import LSeries
sage: LSeries('zeta').epsilon()
1
sage: LSeries('delta').epsilon()
1
sage: LSeries(EllipticCurve('389a')).epsilon()
1
sage: LSeries(EllipticCurve('37a')).epsilon()
-1
sage: LSeries(Newforms(389,names='a')[1]).epsilon()
-1
sage: LSeries(Newforms(6,4)[0]).epsilon()
1
sage: LSeries(DirichletGroup(7).0).epsilon()
1/7*I*((((((e^(2/21*I*pi) + 1)*e^(2/21*I*pi) + 1)*e^(1/21*I*pi) - 1)*e^(1/21*I*pi) - 1)*e^(2/21*I*pi) - 1)*e^(1/21*I*pi) - 1)*sqrt(7)*e^(1/21*I*pi)
sage: LSeries(DirichletGroup(7).0).epsilon(prec=53)
0.386513572759156 + 0.922283718859307*I
In this example, the epsilon factor is computed when the curve
is created. The prec parameter determines the floating point precision
used in computing the epsilon factor::
sage: L = LSeries(EllipticCurve('11a3').base_extend(QQ[sqrt(2)]), prec=5); L.epsilon()
-1
Here is extra confirmation that the rank is really odd over the quadratic field::
sage: EllipticCurve('11a').quadratic_twist(2).rank()
1
We can compute with the L-series too::
sage: L(RealField(5)(2))
0.53
For L-functions of newforms with nontrivial character, the
epsilon factor is harder to find (we don't have a good
algorithm implemented to find it) and might not even be 1 or
-1, so it is set to 'solve'. In this case, the functional
equation is used to determine the solution.::
sage: f = Newforms(kronecker_character_upside_down(7),3)[0]; f
q - 3*q^2 + 5*q^4 + O(q^6)
sage: L = LSeries(f)
sage: L.epsilon()
'solve'
sage: L(3/2)
0.332981771482934
sage: L.epsilon()
1
Here is an example with nontrivial character::
sage: f = Newforms(DirichletGroup(7).0, 5, names='a')[0]; f
q + a0*q^2 + ((zeta6 - 2)*a0 - zeta6 - 1)*q^3 + (-4*zeta6*a0 + 2*zeta6 - 2)*q^4 + ((4*zeta6 - 2)*a0 + 9*zeta6 - 18)*q^5 + O(q^6)
sage: L = LSeries(f)
First trying to evaluate with the default (53 bits) of
precision fails, since for some reason (that I do not
understand) the program is unable to find a valid epsilon
factor::
sage: L(0)
Traceback (most recent call last):
...
RuntimeError: unable to determine epsilon from functional equation working to precision 53, since we get epsilon=0.806362085925390 - 0.00491051026156292*I, which is not sufficiently close to 1
However, when we evaluate to 100 bits of precision it works::
sage: L(RealField(100)(0))
0
The epsilon factor is *not* known to infinite precision::
sage: L.epsilon()
'solve'
But it is now known to 100 bits of precision, and here it is::
sage: L.epsilon(100)
0.42563106101692403875896879406 - 0.90489678963824790765479396740*I
When we try to compute to higher precision, again Sage solves for the epsilon factor
numerically::
sage: L(RealField(150)(1))
0.26128389551787271923496480408992971337929665 - 0.29870133769674001421149135036267324347896657*I
And now it is known to 150 bits of precision. Notice that
this is consistent with the value found above, and has
absolute value (very close to) 1.
sage: L.epsilon(150)
0.42563106101692403875896879406038776338921622 - 0.90489678963824790765479396740501409301704122*I
sage: abs(L.epsilon(150))
1.0000000000000000000000000000000000000000000
"""
if self._epsilon == 'solve' or (
hasattr(self._epsilon, 'prec') and (prec is None or self._epsilon.prec() < prec)):
return 'solve'
if prec is not None:
C = ComplexField(prec)
if isinstance(self._epsilon, list):
return [C(x) for x in self._epsilon]
return C(self._epsilon)
return self._epsilon
def is_selfdual(self):
"""
Return True if this L-series is self dual; otherwise, return False.
EXAMPLES::
Many L-series are self dual::
sage: from psage.lseries.eulerprod import LSeries
sage: LSeries('zeta').is_selfdual()
True
sage: LSeries('delta').is_selfdual()
True
sage: LSeries(Newforms(6,4)[0]).is_selfdual()
True
Nonquadratic characters have non-self dual L-series::
sage: LSeries(DirichletGroup(7).0).is_selfdual()
False
sage: LSeries(kronecker_character(7)).is_selfdual()
True
Newforms with non-quadratic characters also have non-self dual L-seris::
sage: L = LSeries(Newforms(DirichletGroup(7).0, 5, names='a')[0]); L.is_selfdual()
False
"""
return self._is_selfdual
@cached_method
def degree(self):
"""
Return the degree of this L-function, which is by definition the number of Gamma
factors (e.g., the number of Hodge numbers) divided by the degree of the base field.
EXAMPLES::
sage: from psage.lseries.eulerprod import LSeries
sage: LSeries('zeta').degree()
1
sage: LSeries(DirichletGroup(5).0).degree()
1
sage: LSeries(EllipticCurve('11a')).degree()
2
The L-series attached to this modular symbols space of dimension 2 is a product
of 2 degree 2 L-series, hence has degree 4::
sage: M = ModularSymbols(43,2,sign=1).cuspidal_subspace()[1]; M.dimension()
2
sage: L = LSeries(M); L
L-series attached to Modular Symbols subspace of dimension 2 of Modular Symbols space of dimension 4 for Gamma_0(43) of weight 2 with sign 1 over Rational Field
sage: L.factor()
(L-series of a degree 2 newform of level 43 and weight 2) * (L-series of a degree 2 newform of level 43 and weight 2)
sage: L.degree()
4
sage: x = var('x'); K.<a> = NumberField(x^2-x-1); LSeries(EllipticCurve([0,-a,a,0,0])).degree()
2
"""
n = len(self.hodge_numbers())
d = self.base_field().degree()
assert n % d == 0, "degree of base field must divide the number of Hodge numbers"
return n//d
def twist(self, chi, conductor=None, epsilon=None, prec=53):
r"""
Return the quadratic twist of this L-series by the character chi, which
must be a character of self.base_field(). Thus chi should take as input
prime ideals (or primes) of the ring of integers of the base field, and
output something that can be coerced to the complex numbers.
INPUT:
- `\chi` -- 1-dimensional character
EXAMPLES::
sage: from psage.lseries.eulerprod import LSeries
sage: E = EllipticCurve('11a')
sage: L = LSeries(E); L
L-series of Elliptic Curve defined by y^2 + y = x^3 - x^2 - 10*x - 20 over Rational Field
sage: L3 = L.twist(DirichletGroup(3).0); L3
Twist of L-series of Elliptic Curve defined by y^2 + y = x^3 - x^2 - 10*x - 20 over Rational Field by Dirichlet character modulo 3 of conductor 3 mapping 2 |--> -1
sage: L3._chi
Dirichlet character modulo 3 of conductor 3 mapping 2 |--> -1
sage: L3._L
L-series of Elliptic Curve defined by y^2 + y = x^3 - x^2 - 10*x - 20 over Rational Field
sage: L3(1)
1.68449633297548
sage: F = E.quadratic_twist(-3)
sage: L3.conductor()
99
sage: F.conductor()
99
sage: F.lseries()(1)
1.68449633297548
sage: L3.anlist(20)
[0, 1, 2, 0, 2, -1, 0, -2, 0, 0, -2, -1, 0, 4, -4, 0, -4, 2, 0, 0, -2]
sage: F.anlist(20)
[0, 1, 2, 0, 2, -1, 0, -2, 0, 0, -2, -1, 0, 4, -4, 0, -4, 2, 0, 0, -2]
sage: L3.anlist(1000) == F.anlist(1000)
True
sage: L3.local_factor(11)
T + 1
A higher degree twist::
sage: L = LSeries(EllipticCurve('11a'))
sage: L5 = L.twist(DirichletGroup(5).0); L5
Twist of L-series of Elliptic Curve defined by y^2 + y = x^3 - x^2 - 10*x - 20 over Rational Field by Dirichlet character modulo 5 of conductor 5 mapping 2 |--> zeta4
sage: L5(1)
1.28009593569230 - 0.681843202124309*I
sage: L5.epsilon()
'solve'
sage: L5.epsilon(53)
0.989989082587826 + 0.141143956147310*I
sage: L5.conductor()
275
sage: L5.taylor_series(center=1, degree=3)
1.28009593569230 - 0.681843202124309*I + (-0.536450338806282 + 0.166075270978779*I)*z + (0.123743053129226 + 0.320802890011298*I)*z^2 + O(z^3)
WARNING!! Twisting is not implemented in full generality when
the conductors are not coprime. One case where we run into
trouble is when twisting lowers the level of a newform. Below
we take the form of level 11 and weight 2, twist it by the
character chi of conductor 3 to get a form of level 99. Then
we take the L-series of the level 99 form, and twist that by
chi, which should be the L-series attached to the form of
level 11. Unfortunately, our code for working out the local
L-factors doesn't succeed in this case, hence the local factor
is wrong, so the functional equation is not satisfied.
sage: f = Newform('11a'); f
q - 2*q^2 - q^3 + 2*q^4 + q^5 + O(q^6)
sage: L = LSeries(f)
sage: chi = DirichletGroup(3).0
sage: Lc = L.twist(chi); Lc
Twist of L-series of a degree 1 newform of level 11 and weight 2 by Dirichlet character modulo 3 of conductor 3 mapping 2 |--> -1
sage: Lc.anlist(20)
[0, 1, 2, 0, 2, -1, 0, -2, 0, 0, -2, -1, 0, 4, -4, 0, -4, 2, 0, 0, -2]
sage: g = Newform('99d'); g
q + 2*q^2 + 2*q^4 - q^5 + O(q^6)
sage: list(g.qexp(20))
[0, 1, 2, 0, 2, -1, 0, -2, 0, 0, -2, -1, 0, 4, -4, 0, -4, 2]
sage: Lt = Lc.twist(chi, conductor=11)
Traceback (most recent call last):
...
RuntimeError: no choice of values for _epsilon works
sage: Lt = Lc.twist(chi,conductor=11, epsilon=1)
sage: Lt(1)
Traceback (most recent call last):
...
RuntimeError: invalid L-series parameters: functional equation not satisfied
This is because the local factor is wrong::
sage: Lt.local_factor(3)
1
sage: L.local_factor(3)
3*T^2 + T + 1
"""
return LSeriesTwist(self, chi=chi, conductor=conductor, epsilon=epsilon, prec=prec)
@cached_method
def local_factor(self, P, prec=None):
"""
Return the local factor of the L-function at the prime P of
self._base_field. The result is cached.
INPUT:
- a prime P of the ring of integers of the base_field
- prec -- None or positive integer (bits of precision)
OUTPUT:
- a polynomial, e.g., something like "1-a*T+p*T^2".
EXAMPLES:
You must overload this in the derived class::
sage: from psage.lseries.eulerprod import LSeriesAbstract
sage: L = LSeriesAbstract(conductor=1, hodge_numbers=[0], weight=1, epsilon=1, poles=[1], residues=[-1], base_field=QQ)
sage: L.local_factor(2)
Traceback (most recent call last):
...
NotImplementedError: must be implemented in the derived class
"""
return self._local_factor(P, prec=prec)
def _local_factor(self, P, prec=None):
"""
Compute local factor at prime P. This must be overwritten in the derived class.
EXAMPLES::
sage: from psage.lseries.eulerprod import LSeriesAbstract
sage: L = LSeriesAbstract(conductor=1, hodge_numbers=[0], weight=1, epsilon=1, poles=[1], residues=[-1], base_field=QQ)
sage: L.local_factor(2)
Traceback (most recent call last):
...
NotImplementedError: must be implemented in the derived class
"""
raise NotImplementedError, "must be implemented in the derived class"
def __repr__(self):
"""
EXAMPLES::
sage: from psage.lseries.eulerprod import LSeriesAbstract
sage: L = LSeriesAbstract(conductor=1, hodge_numbers=[0], weight=1, epsilon=1, poles=[1], residues=[-1], base_field=QQ)
sage: L.__repr__()
'Euler Product L-series with conductor 1, Hodge numbers [0], weight 1, epsilon 1, poles [1], residues [-1] over Rational Field'
"""
return "Euler Product L-series with conductor %s, Hodge numbers %s, weight %s, epsilon %s, poles %s, residues %s over %s"%(
self._conductor, self._hodge_numbers, self._weight, self.epsilon(), self._poles, self._residues, self._base_field)
def _precompute_local_factors(self, bound, prec):
"""
Derived classes may use this as a 'hint' that _local_factors
will soon get called for primes of norm less than the bound.
In the base class, this is a no-op, and it is not necessary to
overload this class.
INPUT:
- ``bound`` -- integer
- ``prec`` -- integer
EXAMPLES::
sage: from psage.lseries.eulerprod import LSeriesAbstract
sage: L = LSeriesAbstract(conductor=1, hodge_numbers=[0], weight=1, epsilon=1, poles=[1], residues=[-1], base_field=QQ)
sage: L._precompute_local_factors(100, 53)
"""
pass
def _primes_above(self, p):
"""
Return the primes of the ring of integers of the base field above the integer p.
INPUT:
- p -- prime integer (no type checking necessarily done)
EXAMPLES::
sage: from psage.lseries.eulerprod import LSeriesAbstract
sage: L = LSeriesAbstract(conductor=1, hodge_numbers=[0], weight=1, epsilon=1, poles=[1], residues=[-1], base_field=QQ)
sage: L._primes_above(3)
[3]
sage: L = LSeriesAbstract(conductor=1, hodge_numbers=[0], weight=1, epsilon=1, poles=[1], residues=[-1], base_field=QQ[sqrt(-1)])
sage: L._primes_above(5)
[Fractional ideal (I + 2), Fractional ideal (-I + 2)]
sage: L._primes_above(3)
[Fractional ideal (3)]
"""
K = self._base_field
if is_RationalField(K):
return [p]
else:
return K.primes_above(p)
def zeros(self, n):
"""
Return the imaginary parts of the first n nontrivial zeros of
this L-function on the critical line in the upper half plane,
as 32-bit real numbers.
INPUT:
- n -- nonnegative integer
EXAMPLES::
"""
return self._lcalc().zeros(n)
def _lcalc(self):
"""
Return Rubinstein Lcalc object attached to this L-series. This
is useful both for evaluating the L-series, especially when
the imaginary part is large, and for computing the zeros in
the critical strip.
EXAMPLES::
"""
# this will require using Rubinstein's L-calc
raise NotImplementedError
def anlist(self, bound, prec=None):
"""
Return list `v` of Dirichlet series coefficients `a_n`for `n` up to and including bound,
where `v[n] = a_n`. If at least one of the coefficients is ambiguous, e.g., the
local_factor method returns a list of possibilities, then this function instead
returns a generator over all possible `a_n` lists.
In particular, we include v[0]=0 as a convenient place holder
to avoid having `v[n-1] = a_n`.
INPUT:
- ``bound`` -- nonnegative integer
EXAMPLES::
sage: from psage.lseries.eulerprod import LSeries; L = LSeries('zeta')
sage: L.anlist(30)
[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
sage: from psage.lseries.eulerprod import LSeries; L = LSeries(EllipticCurve('11a'))
sage: L.anlist(30)
[0, 1, -2, -1, 2, 1, 2, -2, 0, -2, -2, 1, -2, 4, 4, -1, -4, -2, 4, 0, 2, 2, -2, -1, 0, -4, -8, 5, -4, 0, 2]
sage: K.<a> = NumberField(x^2-x-1); L = LSeries(EllipticCurve([0,-a,a,0,0]))
sage: L.anlist(30)
[0, 1, 0, 0, -2, -1, 0, 0, 0, -4, 0, 3, 0, 0, 0, 0, 0, 0, 0, 5, 2, 0, 0, 0, 0, -4, 0, 0, 0, 11, 0]
"""
# First check if we know anlist to infinite bit precision up to given bound:
if len(self._anlist[None]) > bound:
if prec is None:
# request it to infinite precision
return self._anlist[None][:bound+1]
else:
# finite precision request
C = ComplexField(prec)
return [C(a) for a in self._anlist[None]]
if prec is not None:
# check if numerically computed already to at least this precision
t = [z for z in self._anlist.iteritems() if z[0] >= prec and len(z[1]) > bound]
if len(t) > 0:
C = ComplexField(prec)
return [C(a) for a in t[0][1][:bound+1]]
self._precompute_local_factors(bound+1, prec=prec)
compute_anlist_multiple = False
LF = []
for p in prime_range(bound+1):
lf = []
for P in self._primes_above(p):
if norm(P) <= bound:
F = self._local_factor(P, prec)
if isinstance(F, list):
compute_anlist_multiple = True
lf.append(F)
LF.append((p, lf))
coefficients = self._compute_anlist(LF, bound, prec)
if not compute_anlist_multiple:
coefficients = list(coefficients)[0]
# save answer in cache
self._anlist[prec] = coefficients
return coefficients
def _compute_anlist(self, LF, bound, prec):
"""
Iterator over possible anlists, given LF, bound, and prec.
INPUT:
- ``LF`` -- list of pairs (p, [local factors (or lists of them) at primes over p])
- ``bound`` -- positive integer
- ``prec`` -- positive integer (bits of precision)
"""
K = self._base_field
coefficients = [0,1] + [0]*(bound-1)
for i, (p, v) in enumerate(LF):
if len(v) > 0:
# Check for the possibility of several different
# choices of Euler factor at a given prime. If this happens,
# we switch gears.
some_list = False
for j, lf in enumerate(v):
if isinstance(lf, list):
some_list = True
for f in list(lf):
LF0 = copy.deepcopy(LF)
LF0[i][1][j] = f
for z in self._compute_anlist(LF0, bound, prec):
yield z
if some_list:
return
# Not several factors -- just compute the a_{p^r} up to the required bound:
f = prod(v)
accuracy_p = int(math.floor(math.log(bound)/math.log(p))) + 1
T = f.parent().gen()
series_p = (f + O(T**accuracy_p))**(-1)
for j in range(1, accuracy_p):
coefficients[p**j] = series_p[j]
# fill in non-prime power coefficients
extend_multiplicatively_generic(coefficients)
yield list(coefficients)
def _symbolic_(self, R, bound=10, prec=None):
"""
Convert self into the symbolic ring as a truncated Dirichleter series, including
terms up to `n^s` where n=bound.
EXAMPLES::
sage: from psage.lseries.eulerprod import LSeries
sage: L = LSeries(EllipticCurve('37a'))
sage: SR(L)
-2/2^s - 3/3^s + 2/4^s - 2/5^s + 6/6^s - 1/7^s + 6/9^s + 4/10^s + 1
sage: L._symbolic_(SR, 20)
-2/2^s - 3/3^s + 2/4^s - 2/5^s + 6/6^s - 1/7^s + 6/9^s + 4/10^s - 5/11^s - 6/12^s - 2/13^s + 2/14^s + 6/15^s - 4/16^s - 12/18^s - 4/20^s + 1
"""
s = R.var('s')
a = self.anlist(bound, prec)
return sum(a[n]/n**s for n in range(1,bound+1))
def __call__(self, s):
"""
Return value of this L-function at s. If s is a real or
complex number to prec bits of precision, then the result is
also computed to prec bits of precision. If s has infinite or
unknown precision, then the L-value is computed to 53 bits of
precision.
EXAMPLES::
sage: from psage.lseries.eulerprod import LSeries
sage: L = LSeries(EllipticCurve('37a'))
sage: L(1)
0
sage: L(2)
0.381575408260711
sage: z = L(RealField(100)(2)); z
0.38157540826071121129371040958
sage: z.prec()
100
sage: L(RealField(150)(2))
0.38157540826071121129371040958008663667709753
WARNING: There will be precision loss (with a warning) if the imaginary
part of the input is large::
sage: L = LSeries('zeta')
sage: L(1/2 + 40*I)
verbose -1 (...: dokchitser.py, __call__) Warning: Loss of 14 decimal digits due to cancellation
0.793046013671137 - 1.04127377821427*I
sage: L(ComplexField(200)(1/2 + 40*I))
verbose -1 (...: dokchitser.py, __call__) Warning: Loss of 14 decimal digits due to cancellation
0.79304495256192867196489258889793696080572220439302833315881 - 1.0412746146510650200518905953910554313275550685861559488384*I
An example with a pole::
sage: L = LSeries('zeta')
sage: L(2) # good
1.64493406684823
sage: L(1) # a pole!
Traceback (most recent call last):
...
ZeroDivisionError: pole at 1
"""
if s in self._poles:
raise ZeroDivisionError, "pole at %s"%s
return self._function(prec(s))(s)
def derivative(self, k=1):
"""
Return the k-th derivative of self.
INPUT:
- k -- (default: 1) nonnegative integer
EXAMPLES::
sage: from psage.lseries.eulerprod import LSeries
sage: L = LSeries('zeta')
sage: L.derivative()
First derivative of Riemann Zeta function viewed as an L-series
We numerically approximate the derivative at two points and compare
with evaluating the derivative object::
sage: eps=1e-10; (L(2+eps) - L(2))/eps
-0.937547817159157
sage: Lp = L.derivative(); Lp(2)
-0.937548254315844
sage: eps=1e-10; (L(2+I+eps) - L(2+I))/eps
0.0624900131640516 + 0.489033813444451*I
sage: Lp(2+I)
0.0624900021906470 + 0.489033591679899*I
Higher derivatives::
sage: L.derivative(2)
Second derivative of Riemann Zeta function viewed as an L-series
sage: L.derivative(2)(2)
1.98928023429890
sage: L.derivative(3)
Third derivative of Riemann Zeta function viewed as an L-series
sage: L.derivative(4)
4-th derivative of Riemann Zeta function viewed as an L-series
sage: L.derivative(5)
5-th derivative of Riemann Zeta function viewed as an L-series
Derivative of derivative::
sage: L.derivative().derivative()
Second derivative of Riemann Zeta function viewed as an L-series
Using the derivative function in Sage works::
sage: derivative(L)
First derivative of Riemann Zeta function viewed as an L-series
sage: derivative(L,2)
Second derivative of Riemann Zeta function viewed as an L-series
"""
if k == 0:
return self
return LSeriesDerivative(self, k)
def taylor_series(self, center=None, degree=6, variable='z', prec=53):
"""
Return the Taylor series expansion of self about the given
center point to the given degree in the specified variable
numerically computed to the precision prec in bits. If the
center is not specified it defaults to weight / 2.
INPUT:
- ``center`` -- None or number that coerces to the complex numbers
- ``degree`` -- integer
- ``variable`` -- string or symbolic variable
- ``prec`` -- positive integer (floating point bits of precision)
EXAMPLES:::
sage: from psage.lseries.eulerprod import LSeries; L = LSeries('zeta')
sage: L.taylor_series()
-1.46035450880959 - 3.92264613920915*z - 8.00417850696433*z^2 - 16.0005515408865*z^3 - 31.9998883216853*z^4 - 64.0000050055172*z^5 + O(z^6)
sage: RealField(53)(zeta(1/2))
-1.46035450880959
sage: L.taylor_series(center=2, degree=4, variable='t', prec=30)
1.6449341 - 0.93754825*t + 0.99464012*t^2 - 1.0000243*t^3 + O(t^4)
sage: RealField(30)(zeta(2))
1.6449341
"""
if center is None:
center = ComplexField(prec)(self._weight)/2
return self._function(prec).taylor_series(center, degree, variable)
def analytic_rank(self, tiny=1e-8, prec=53):
center = ComplexField(prec)(self._weight) / 2
degree = 4
while True:
f = self.taylor_series(center, degree, prec=prec)
i = 0
while i < degree:
if abs(f[i]) > tiny:
return i
i += 1
degree += 2
@cached_method
def _function(self, prec=53, T=1.2):
"""
Return Dokchitser object that allows for computation of this
L-series computed to enough terms so that the functional
equation checks out with the given value of T and precision.
This is used behind the scenes for evaluation and computation
of Taylor series.
"""
eps = self.epsilon(prec)
return self._dokchitser(prec, eps, T=T)
def _dokchitser_unitialized(self, prec, epsilon):
# Create the Dokchitser object
if epsilon == 'solve':
eps = 'X'
else:
eps = epsilon
return Dokchitser(conductor = self.conductor(), gammaV = self.hodge_numbers(), weight = self.weight(),
eps = eps, poles = self.poles(), residues = self.residues(),
prec = prec)
def number_of_coefficients(self, prec=53, T=1.2):
"""
Return the number of Dirichlet series coefficients that will
be needed in order to evaluate this L-series (near the real
line) to prec bits of precision and have the functional
equation test pass with the given value of T.
INPUT:
- prec -- integer
EXAMPLES::
sage: from psage.lseries.eulerprod import LSeries
sage: L = LSeries(DirichletGroup(5).0)
sage: L.number_of_coefficients(20)
8
sage: L.number_of_coefficients()
11
sage: L.number_of_coefficients(1000)
43
"""
return self._dokchitser_unitialized(prec, self.epsilon(prec)).num_coeffs(T)
def _dokchitser(self, prec, epsilon, T=1.2):
L = self._dokchitser_unitialized(prec, epsilon)
# Find out how many coefficients of the Dirichlet series are needed
# to compute to the requested precision.
n = L.num_coeffs(T=T)
#if n >= 500: # TODO: for debugging only -- remove later
# print "num coeffs =", n
# Compute the Dirichlet series coefficients
X = self.anlist(n, prec)
if isinstance(X, types.GeneratorType):
# Several possible coefficients -- we try them until finding on that works.
coeff_lists = X
else:
# Only one to try
coeff_lists = [X]
tiny0 = tiny(prec)
for coeffs in coeff_lists:
# Define a string that when evaluated in PARI defines a function
# a(k), which returns the Dirichlet coefficient a_k.
s = 'v=[%s]; a(k)=v[k];'%','.join([str(z) if isinstance(z, (int,long,Integer)) else z._pari_init_() for z in coeffs[1:]])
# Tell the L-series / PARI about the coefficients.
if self.is_selfdual():
L.init_coeffs('a(k)', pari_precode = s)
else:
# Have to directly call gp_eval, since case of functional equation having two different
# (conjugate) L-functions isn't supported in Dokchitser class (yet).
L._Dokchitser__init = True
L._gp_eval(s)
L._gp_eval('initLdata("a(k)",1,"conj(a(k))")')
if epsilon == 'solve':
cmd = "sgneq = Vec(checkfeq()); sgn = -sgneq[2]/sgneq[1]; sgn"
epsilon = ComplexField(prec)(L._gp_eval(cmd))
if abs(abs(epsilon)-1) > tiny0:
raise RuntimeError, "unable to determine epsilon from functional equation working to precision %s, since we get epsilon=%s, which is not sufficiently close to 1"%(prec, epsilon)
# 1, -1 are two common special cases, where it is clear what the
# infinite precision version is.
if epsilon == 1:
self._epsilon = 1
elif epsilon == -1:
self._epsilon = -1
else:
self._epsilon = epsilon
fe = L.check_functional_equation()
if abs(fe) <= tiny0:
# one worked!
self._anlist[prec] = coeffs
return L
else:
pass
# They all failed.
raise RuntimeError, "invalid L-series parameters: functional equation not satisfied"
def check_functional_equation(self, T, prec=53):
return self._function(prec=prec).check_functional_equation(T)
class LSeriesProductEvaluator(object):
def __init__(self, factorization, prec):
self._factorization = factorization
self._prec = prec
def __call__(self, s):
try:
v = self._functions
except AttributeError:
self._functions = [(L._function(self._prec),e) for L,e in self._factorization]
v = self._functions
return prod(f(s)**e for f,e in v)
class LSeriesProduct(object):
"""
A formal product of L-series.
"""
def __init__(self, F):
"""
INPUT:
- `F` -- list of pairs (L,e) where L is an L-function and e is a nonzero integer.
"""
if not isinstance(F, Factorization):
F = Factorization(F)
F.sort(cmp)
if len(F) == 0:
raise ValueError, "product must be nonempty"
self._factorization = F
def __cmp__(self, right):
# TODO: make work even if right not a product
return cmp(self._factorization, right._factorization)
def is_selfdual(self):
"""
Return True if every factor of self is self dual; otherwise, return False.
EXAMPLES::
sage: from psage.lseries.eulerprod import LSeries
sage: L1 = LSeries('zeta'); L1.is_selfdual()
True
sage: L2 = LSeries(DirichletGroup(9).0); L2.is_selfdual()
False
sage: (L1*L1).is_selfdual()
True
sage: (L1*L2).is_selfdual()
False
sage: (L2*L2).is_selfdual()
False
"""
is_selfdual = set(L.is_selfdual() for L,e in self._factorization)
if len(is_selfdual) > 1:
return False
else:
return list(is_selfdual)[0]
def conductor(self):
"""
Return the conductor of this product, which we define to be
the product with multiplicities of the conductors of the
factors of self.
EXAMPLES::
sage: from psage.lseries.eulerprod import LSeries
sage: J = J0(33); L = LSeries(J)
sage: L.conductor()
3993
sage: L.conductor().factor()
3 * 11^3
sage: J.decomposition()
[
Simple abelian subvariety 11a(1,33) of dimension 1 of J0(33),
Simple abelian subvariety 11a(3,33) of dimension 1 of J0(33),
Simple abelian subvariety 33a(1,33) of dimension 1 of J0(33)
]
Of course, the conductor as we have defined it need not be an integer::
sage: L = LSeries(J[0])/LSeries(J[2])^2; L
(L-series of a degree 1 newform of level 11 and weight 2) * (L-series of a degree 1 newform of level 33 and weight 2)^-2
sage: L.conductor()
1/99
"""
return prod(L.conductor()**e for L, e in self._factorization)
def __pow__(self, n):
"""
Return the n-th power of this formal L-series product, where n can be any integer.
EXAMPLES::
sage: from psage.lseries.eulerprod import LSeries
sage: L = LSeries('zeta') * LSeries(DirichletGroup(9).0)
sage: L(2)
1.80817853715812 + 0.369298119218816*I
sage: L = LSeries('zeta') * LSeries(DirichletGroup(9).0)
sage: L3 = L^3; L3
(Riemann Zeta function viewed as an L-series)^3 * (L-series attached to Dirichlet character modulo 9 of conductor 9 mapping 2 |--> zeta6)^3
sage: L3(2)
5.17205298762567 + 3.57190597873829*I
sage: CC((zeta(2)*LSeries(DirichletGroup(9).0)(2))^3)
5.17205298762567 + 3.57190597873829*I
sage: L^(-1999)
(Riemann Zeta function viewed as an L-series)^-1999 * (L-series attached to Dirichlet character modulo 9 of conductor 9 mapping 2 |--> zeta6)^-1999
sage: (L^(-1999)) (2)
8.90248311986228e-533 - 6.20123089437732e-533*I
"""
return LSeriesProduct(self._factorization**ZZ(n))
def __mul__(self, right):
if isinstance(right, LSeriesAbstract):
return LSeriesProduct(self._factorization * Factorization([(right,1)]))
elif isinstance(right, LSeriesProduct):
return LSeriesProduct(self._factorization * right._factorization)
else:
raise TypeError
def __div__(self, right):
if isinstance(right, LSeriesAbstract):
return LSeriesProduct(self._factorization * Factorization([(right,-1)]))
elif isinstance(right, LSeriesProduct):
return LSeriesProduct(self._factorization / right._factorization)
raise TypeError
def parent(self):
return LSeriesParent
def factor(self):
return self._factorization
def hodge_numbers(self):
"""
Return the Hodge numbers of this product of L-series.
"""
def degree(self):
return sum(e*L.degree() for L,e in self._factorization)
def local_factor(self, P, prec=None):
return prod(L.local_factor(P,prec)**e for L,e in self._factorization)
def __getitem__(self, *args, **kwds):
return self._factorization.__getitem__(*args, **kwds)
def __repr__(self):
return self.factor().__repr__()
def __call__(self, s):
return self._function(prec(s))(s)
def derivative(self, k=1):
raise NotImplementedError
def taylor_series(self, center=None, degree=6, variable='z', prec=53):
"""
EXAMPLE::
sage: from psage.lseries.eulerprod import LSeries
sage: L1 = LSeries('zeta'); L2 = LSeries('delta')
sage: f = L1 * L2; f
(Riemann Zeta function viewed as an L-series) * (L-function associated to Ramanujan's Delta (a weight 12 cusp form))
sage: f.taylor_series(center=2, degree=4, variable='w', prec=30)
0.24077647 + 0.10066485*w + 0.061553731*w^2 - 0.041923238*w^3 + O(w^4)
sage: L1.taylor_series(2, 4, 'w', 30) * L2.taylor_series(2, 4, 'w', 30)
0.24077647 + 0.10066485*w + 0.061553731*w^2 - 0.041923238*w^3 + O(w^4)
sage: f = L1 / L2; f
(Riemann Zeta function viewed as an L-series) * (L-function associated to Ramanujan's Delta (a weight 12 cusp form))^-1
sage: f.taylor_series(center=2, degree=4, variable='w', prec=30)
11.237843 - 17.508629*w + 21.688182*w^2 - 24.044641*w^3 + O(w^4)
sage: L1.taylor_series(2, 4, 'w', 30) / L2.taylor_series(2, 4, 'w', 30)
11.237843 - 17.508629*w + 21.688182*w^2 - 24.044641*w^3 + O(w^4)
"""
return prod(L.taylor_series(center, degree, variable, prec)**e for L,e in self._factorization)
def analytic_rank(self, prec=53):
"""
Return sum of the order of vanishing counted with
multiplicities of each factors at their center point.
WARNING: The analytic rank is computed numerically, so is
definitely not provably correct.
EXAMPLES::
We compute the analytic rank of the non-simple 32-dimensional modular abelian variety `J_0(389)`.
sage: from psage.lseries.eulerprod import LSeries
sage: M = ModularSymbols(389,sign=1).cuspidal_subspace()
sage: L = LSeries(M); L
L-series attached to Modular Symbols subspace of dimension 32 of Modular Symbols space of dimension 33 for Gamma_0(389) of weight 2 with sign 1 over Rational Field
We first attempt computation of the analytic rank with the default of 53 bits precision::
sage: L.analytic_rank()
Traceback (most recent call last):
...
RuntimeError: invalid L-series parameters: functional equation not satisfied
The above failed because trying to compute one of the degree
20 newforms resulting in some internal error when double
checking the functional equation. So we try with slightly more precision::
sage: L.analytic_rank(70)
13
This works, since the factors have dimensions 1,2,3,6,20, and
the one of degree 1 has rank 2, the ones of degree 2,3,6 have
rank 2,3,6, respectively, and the one of degree 20 has rank 0::
sage: 2*1 + 2 + 3 + 6
13
"""
return sum(e*L.analytic_rank(prec=prec) for L,e in self._factorization)
def weight(self):
"""
Return the weight of this L-series, which is the sum of the weights
of the factors counted with multiplicity.
"""
return sum(e*L.weight() for L,e in self._factorization)
@cached_method
def _function(self, prec=53):
"""
Return Dokchitser object that allows for computation of this
L-series. This is used behind the scenes for evaluation and
computation of Taylor series.
"""
return LSeriesProductEvaluator(self._factorization, prec)
class LSeriesZeta(LSeriesAbstract):
"""
EXAMPLES::
sage: from psage.lseries.eulerprod import LSeries
sage: L = LSeries('zeta'); L
Riemann Zeta function viewed as an L-series
sage: L(2)
1.64493406684823
sage: L(2.000000000000000000000000000000000000000000000000000)
1.64493406684822643647241516664602518921894990120680
sage: zeta(2.000000000000000000000000000000000000000000000000000)
1.64493406684822643647241516664602518921894990120680
sage: L.local_factor(3)
-T + 1
sage: L.local_factor(5)
-T + 1
sage: L.anlist(30)
[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
"""
def __init__(self):
LSeriesAbstract.__init__(self, conductor=1, hodge_numbers=[0], weight=1, epsilon=1,
poles=[0,1], residues=[9,8], base_field=QQ)
T = ZZ['T'].gen()
self._lf = 1 - T
def _cmp(self, right):
return 0
def _local_factor(self, P, prec):
return self._lf
def __repr__(self):
return "Riemann Zeta function viewed as an L-series"
class LSeriesDelta(LSeriesAbstract):
"""
EXAMPLES::
sage: from psage.lseries.eulerprod import LSeriesDelta; L = LSeriesDelta()
sage: L.anlist(10)
[0, 1, -24, 252, -1472, 4830, -6048, -16744, 84480, -113643, -115920]
sage: list(delta_qexp(11))
[0, 1, -24, 252, -1472, 4830, -6048, -16744, 84480, -113643, -115920]
sage: L.anlist(10^4) == list(delta_qexp(10^4+1))
True
"""
def __init__(self):
LSeriesAbstract.__init__(self, conductor=1, hodge_numbers=[0,1], weight=12, epsilon=1,
poles=[], residues=[], base_field=QQ)
self._T = ZZ['T'].gen()
self._lf = {}
def _local_factor(self, P, prec):
"""
EXAMPLES::
sage: from psage.lseries.eulerprod import LSeriesDelta; L = LSeriesDelta()
sage: L.local_factor(2)
2048*T^2 + 24*T + 1
sage: L._local_factor(11, None) # really this is called
285311670611*T^2 - 534612*T + 1
The representation is reducible modulo 691::
sage: L.local_factor(2).factor_mod(691)
(666) * (T + 387) * (T + 690)
sage: L.local_factor(3).factor_mod(691)
(251) * (T + 234) * (T + 690)
sage: L.local_factor(11).factor_mod(691)
(468) * (T + 471) * (T + 690)
... because of the 691 here::
sage: bernoulli(12)
-691/2730
"""
try:
return self._lf[P]
except KeyError:
pass
self._precompute_local_factors(P+1)
return self._lf[P]
def _precompute_local_factors(self, bound, prec=None):
"""
Precompute local factors up to the given bound.
EXAMPLES::
sage: from psage.lseries.eulerprod import LSeriesDelta; L = LSeriesDelta()
sage: L._lf
{}
sage: L._precompute_local_factors(10)
sage: L._lf
{2: 2048*T^2 + 24*T + 1, 3: 177147*T^2 - 252*T + 1, 5: 48828125*T^2 - 4830*T + 1, 7: 1977326743*T^2 + 16744*T + 1}
"""
from sage.modular.all import delta_qexp
T = self._T
T2 = T**2
f = delta_qexp(bound)
for p in prime_range(bound):
if not self._lf.has_key(p):
self._lf[p] = 1 - f[p]*T + (p**11)*T2
def __repr__(self):
return "L-function associated to Ramanujan's Delta (a weight 12 cusp form)"
def _cmp(self, right):
return 0
class LSeriesEllipticCurve(LSeriesAbstract):
def __init__(self, E, prec=53):
"""
EXAMPLES::
sage: from psage.lseries.eulerprod import LSeriesEllipticCurve
sage: L = LSeriesEllipticCurve(EllipticCurve('389a'))
sage: L(2)
0.360092863578881
"""
E = E.global_minimal_model()
self._E = E
K = E.base_field()
d = K.degree()
self._N = E.conductor()
LSeriesAbstract.__init__(self, conductor = norm(self._N) * K.discriminant()**2,
hodge_numbers = [0]*d+[1]*d, weight = 2, epsilon = [1,-1],
poles = [], residues=[], base_field = K, prec=prec)
def elliptic_curve(self):
return self._E
def _cmp(self, right):
return cmp(self.elliptic_curve(), right.elliptic_curve())
def __repr__(self):
return "L-series of %s"%self.elliptic_curve()
def _local_factor(self, P, prec):
R = ZZ['T']
T = R.gen()
q = norm(P)
p = prime_below(P)
f = ZZ(q).ord(p)
if P.divides(self._N):
a = self._E.local_data(P).bad_reduction_type()
return 1 - a*(T**f)
else:
a = q + 1 - self._E.reduction(P).count_points()
return 1 - a*(T**f) + q*(T**(2*f))
class LSeriesEllipticCurveQQ(LSeriesEllipticCurve):
def __init__(self, E):
E = E.global_minimal_model()
self._E = E
K = E.base_field()
self._N = E.conductor()
self._lf = {}
self._T = ZZ['T'].gen()
LSeriesAbstract.__init__(self, conductor = self._N,
hodge_numbers = [0,1], weight = 2, epsilon = E.root_number(),
poles = [], residues=[], base_field = QQ)
def _lf0(self, p):
a = self._E.ap(p)
T = self._T
if self._N%p == 0:
if self._N%(p*p) == 0:
return T.parent()(1)
else:
return 1 - a*T
else:
return 1 - a*T + p*T*T
def _precompute_local_factors(self, bound, prec=None):
for p in primes(bound):
if not self._lf.has_key(p):
self._lf[p] = self._lf0(p)
def _local_factor(self, P, prec):
if self._lf.has_key(P):
return self._lf[P]
else:
return self._lf0(P)
def _primes_above(self, p):
return [p]
class LSeriesEllipticCurveSqrt5(LSeriesEllipticCurve):
def _precompute_local_factors(self, bound, prec=None):
E = self._E
# Compute all of the prime ideals of the ring of integers up to the given bound
from psage.number_fields.sqrt5.prime import primes_of_bounded_norm, Prime
primes = primes_of_bounded_norm(bound)
# Compute the traces of Frobenius: this is supposed to be the hard part
from psage.ellcurve.lseries.aplist_sqrt5 import aplist
v = aplist(E, bound)
# Compute information about the primes of bad reduction, in
# particular the integers i such that primes[i] is a prime of bad
# reduction.
bad_primes = set([Prime(a.prime()) for a in E.local_data()])
# Compute the local factors of the L-series.
P = ZZ['T']
T = P.gen()
# Table of powers of T, so we don't have to compute T^4 (say) thousands of times.
Tp = [T**i for i in range(5)]
# For each prime, we write down the local factor.
if not hasattr(self, '_lf'):
self._lf = {}
for i, P in enumerate(primes):
inertial_deg = 2 if P.is_inert() else 1
a_p = v[i]
if P in bad_primes:
# bad reduction
f = 1 - a_p*Tp[inertial_deg]
else:
# good reduction
q = P.norm()
f = 1 - a_p*Tp[inertial_deg] + q*Tp[2*inertial_deg]
self._lf[P] = f
def _local_factor(self, P, prec):
from psage.number_fields.sqrt5.prime import Prime
if not isinstance(P, Prime):
P = Prime(P)
if self._lf.has_key(P):
return self._lf[P]
else:
return LSeriesEllipticCurve._local_factor(self, P.sage_ideal())
def _primes_above(self, p):
"""
Return the primes above p. This function returns a special
optimized prime of the ring of integers of Q(sqrt(5)).
"""
from psage.number_fields.sqrt5.prime import primes_above
return primes_above(p)
class LSeriesDedekindZeta(LSeriesAbstract):
"""
EXAMPLES::
sage: from psage.lseries.eulerprod import LSeries
sage: K.<a> = NumberField(x^3 - 2)
sage: L = LSeries(K); L
Dedekind Zeta function of Number Field in a with defining polynomial x^3 - 2
sage: L(2)
1.60266326190044
sage: L.residues()
'automatic'
sage: L.residues(prec=53)
[-4.77632833933856]
sage: L.residues(prec=100)
[-4.7763283393385594030639875094]
"""
def __init__(self, K):
if not K.is_absolute():
K = K.absolute_field(names='a')
self._K = K
d = K.degree()
sigma = K.signature()[1]
LSeriesAbstract.__init__(self,
conductor = abs(K.discriminant()),
hodge_numbers = [0]*(d-sigma) + [1]*sigma,
weight = 1,
epsilon = 1,
poles = [1],
residues = 'automatic',
base_field = K,
is_selfdual = True)
self._T = ZZ['T'].gen()
def _cmp(self, right):
return cmp(self.number_field(), right.number_field())
def number_field(self):
return self._K
def __repr__(self):
return "Dedekind Zeta function of %s"%self._K
def _local_factor(self, P, prec):
T = self._T
return 1 - T**P.residue_class_degree()
class LSeriesDirichletCharacter(LSeriesAbstract):
"""
EXAMPLES::
sage: from psage.lseries.eulerprod import LSeries; L = LSeries(DirichletGroup(5).0)
sage: L(3)
0.988191681624057 + 0.0891051883457395*I
"""
def __init__(self, chi):
if not chi.is_primitive():
raise NotImplementedError, "chi must be primitive"
if chi.is_trivial():
raise NotImplementedError, "chi must be nontrivial"
if chi.base_ring().characteristic() != 0:
raise ValueError, "base ring must have characteristic 0"
self._chi = chi
LSeriesAbstract.__init__(self, conductor = chi.conductor(),
hodge_numbers = [1] if chi.is_odd() else [0],
weight = 1,
epsilon = None,
poles = [], # since primitive
residues = [], # since primitive
base_field = QQ,
is_selfdual = chi.order() <= 2)
self._T = ZZ['T'].gen()
def _cmp(self, right):
return cmp(self.character(), right.character())
def __repr__(self):
"""
EXAMPLES::
sage: from psage.lseries.eulerprod import LSeries; L = LSeries(DirichletGroup(3).0)
sage: L.__repr__()
'L-series attached to Dirichlet character modulo 3 of conductor 3 mapping 2 |--> -1'
"""
return "L-series attached to %s"%self._chi
def character(self):
return self._chi
def epsilon(self, prec=None):
chi = self._chi
if prec is None:
# answer in symbolic ring
return (sqrt(-1) * SR(chi.gauss_sum())) / chi.modulus().sqrt()
else:
C = ComplexField(prec)
x = C(chi.modulus()).sqrt() / chi.gauss_sum_numerical(prec=prec)
if chi.is_odd():
x *= C.gen()
return 1/x
def _local_factor(self, P, prec):
a = self._chi(P)
if prec is not None:
a = ComplexField(prec)(a)
return 1 - a*self._T
class LSeriesModularSymbolsAbstract(LSeriesAbstract):
def _cmp(self, right):
return cmp(self.modular_symbols(), right.modular_symbols())
def modular_symbols(self):
return self._M
def __repr__(self):
"""
EXAMPLES::
sage: from psage.lseries.eulerprod import LSeries
sage: f = Newforms(43,2,names='a')[1]; f
q + a1*q^2 - a1*q^3 + (-a1 + 2)*q^5 + O(q^6)
sage: LSeries(f).__repr__()
'L-series of a degree 2 newform of level 43 and weight 2'
"""
return "L-series of a degree %s newform of level %s and weight %s"%(self._M.dimension(), self._M.level(), self._M.weight())
def _precompute_local_factors(self, bound, prec):
primes = [p for p in prime_range(bound) if not self._lf.has_key(p) or self._lf[p][0] < prec]
self._do_precompute(primes, prec)
def _do_precompute(self, primes, prec):
E, v = self._M.compact_system_of_eigenvalues(primes)
if prec == 53:
C = CDF
elif prec is None or prec==oo:
if v.base_ring() == QQ:
C = QQ
else:
C = CDF
else:
C = ComplexField(prec)
phi = v.base_ring().embeddings(C)[self._conjugate]
v = vector(C, [phi(a) for a in v])
aplist = E.change_ring(C) * v
T = C['T'].gen(); T2 = T**2
chi = self._M.character()
k = self.weight()
for i in range(len(primes)):
p = primes[i]
s = chi(p)
if s != 0: s *= p**(k-1)
F = 1 - aplist[i]*T + s*T2
self._lf[p] = (prec, F)
def _local_factor(self, P, prec):
# TODO: ugly -- get rid of all "prec=None" in whole program -- always use oo.
if prec is None: prec = oo
if self._lf.has_key(P) and self._lf[P][0] >= prec:
return self._lf[P][1]
else:
self._do_precompute([P],prec)
return self._lf[P][1]
class LSeriesModularSymbolsNewformGamma0(LSeriesModularSymbolsAbstract):
def _cmp(self, right):
return cmp((self._M, self._conjugate), (right._M, right._conjugate))
def __init__(self, M, conjugate=0, check=True, epsilon=None):
"""
INPUT:
- M -- a simple, new, cuspidal modular symbols space with
sign 1
- conjugate -- (default: 0), integer between 0 and dim(M)-1
- check -- (default: True), if True, checks that M is
simple, new, cuspidal, which can take a very long time,
depending on how M was defined
- epsilon -- (default: None), if not None, should be the sign
in the functional equation, which is -1 or 1. If this is
None, then epsilon is computed by computing the sign of
the main Atkin-Lehner operator on M. If you have a faster
way to determine epsilon, use it.
EXAMPLES::
sage: from psage.lseries.eulerprod import LSeriesModularSymbolsNewformGamma0
sage: M = ModularSymbols(43,sign=1).cuspidal_subspace()[1]; M
Modular Symbols subspace of dimension 2 of Modular Symbols space of dimension 4 for Gamma_0(43) of weight 2 with sign 1 over Rational Field
sage: L0 = LSeriesModularSymbolsNewformGamma0(M,0,check=False,epsilon=1); L0
L-series of a degree 2 newform of level 43 and weight 2
sage: L0.taylor_series()
0.620539857407845 + 0.331674007376949*z - 0.226392184536589*z^2 + 0.0960519649929789*z^3 - 0.00451826124421802*z^4 - 0.0203363026933833*z^5 + O(z^6)
sage: L1 = LSeriesModularSymbolsNewformGamma0(M,1,check=False,epsilon=1); L1
L-series of a degree 2 newform of level 43 and weight 2
sage: L1(1)
0.921328017272472
sage: L1.taylor_series()
0.921328017272472 + 0.492443075089339*z - 0.391019352704047*z^2 + 0.113271812405127*z^3 + 0.0213067052584679*z^4 - 0.0344198080536274*z^5 + O(z^6)
"""
if M.dimension() == 0:
raise ValueError, "modular symbols space must positive dimension"
chi = M.character()
if chi is None or not chi.is_trivial():
raise ValueError, "modular symbols space must have trivial character"
self._M = M
N = M.level()
if check:
if not M.is_simple():
raise ValueError, "modular symbols space must be simple"
if not M.is_new():
raise ValueError, "modular symbols space must be new"
if not M.is_cuspidal():
raise ValueError, "modular symbols space must be cuspidal"
k = M.weight()
if epsilon is None:
w = M.atkin_lehner_operator(N).matrix()
if w not in [-1, 1]:
raise ValueError, "modular symbols space must have constant Atkin-Lehner operator"
epsilon = (-1)**(k/2) * w[0,0]
conjugate = ZZ(conjugate)
if conjugate < 0 or conjugate >= M.dimension():
raise ValueError, "conjugate must a nonnegative integer less than the dimension"
self._conjugate = conjugate
self._lf = {}
LSeriesAbstract.__init__(self,
conductor = N,
hodge_numbers = [0,1],
weight = k,
epsilon = epsilon,
poles = [], # since primitive
residues = [], # since primitive
base_field = QQ)
def _is_valid_modsym_space(M):
if not is_ModularSymbolsSpace(M):
raise TypeError, "must be a modular symbols space"
if M.dimension() == 0:
raise ValueError, "modular symbols space must positive dimension"
if M.character() is None:
raise ValueError, "modular symbols space must have associated character"
if not M.is_simple():
raise ValueError, "modular symbols space must be simple"
if not M.is_new():
raise ValueError, "modular symbols space must be new"
if not M.is_cuspidal():
raise ValueError, "modular symbols space must be cuspidal"
class LSeriesModularSymbolsNewformCharacter(LSeriesModularSymbolsAbstract):
def _cmp(self, right):
return cmp((self._M, self._conjugate), (right._M, right._conjugate))
def __init__(self, M, conjugate=0):
_is_valid_modsym_space(M)
chi = M.character()
self._M = M
N = M.level()
# See Remark 5.0.2 in [Diamond-Im] which says: "Let f be a newform of level N
# which is a common eigenform under all the Hecke operators T_p. Then
# w_N(f) = c*fbar, where fbar = sum bar(a_n) q^n and c is a scalar. The functional
# equation may be rewritten as Lambda(s, f) = c * i^k * Lambda(k-s, fbar).
# That said, this seems hard to compute, so we just solve using the
# functional equation.
epsilon = 'solve'
k = M.weight()
conjugate = ZZ(conjugate)
if conjugate < 0 or conjugate >= M.dimension():
raise ValueError, "conjugate must a nonnegative integer less than the dimension"
self._conjugate = conjugate
LSeriesAbstract.__init__(self,
conductor = N,
hodge_numbers = [0,1],
weight = k,
epsilon = epsilon,
poles = [], # since primitive
residues = [], # since primitive
base_field = QQ,
is_selfdual = chi.order() <= 2)
self._lf = {}
class LSeriesModularEllipticCurveSqrt5(LSeriesAbstract):
def __init__(self, E, **kwds):
self._E = E
self._N = E.conductor()
self._T = ZZ['T'].gen()
LSeriesAbstract.__init__(self,
conductor = norm(self._N) * 25,
hodge_numbers = [0,0,1,1],
weight = 2,
epsilon = [1,-1],
poles = [], residues = [],
base_field = E.base_field(),
is_selfdual = True,
**kwds)
def elliptic_curve(self):
return self._E
def _cmp(self, right):
return cmp(self.elliptic_curve(), right.elliptic_curve())
def __repr__(self):
return "L-series attached to %s"%self._E
def _local_factor(self, P, prec):
T = self._T
v = self._N.valuation(P)
if v >= 2:
# additive reduction -- local factor is 1
return T.parent()(1)
elif v >= 1:
# multiplicative reduction -- we have no algorithm yet to compute this
# local factor, so we let the functional equation do the work.
d = P.residue_class_degree()
return [1 - T**d, 1 + T**d]
else:
# good reduction -- use Hecke operator
a = self._E.ap(P)
d = P.residue_class_degree()
q = P.norm()
return 1 - a*T**d + q*T**(2*d)
def _new_modsym_space_with_multiplicity(M):
"""
Returns a simple new modular symbols space N and an integer d such
that M is isomorphic to `N^d` as a module over the anemic Hecke
algebra.
INPUT:
- M -- a sign=1 modular simple space for the full Hecke
algebra (including primes dividing the level) that can't be
decomposed further by the Hecke operators. None of the
conditions on M are explicitly checked.
OUTPUT:
- N -- a simple new modular symbols space
- d -- a positive integer
"""
if M.is_new():
return [(M,1)]
raise NotImplementedError
def LSeriesModularSymbolsNewform(M, i=0):
chi = M.character()
if chi is None:
raise NotImplementedError
elif chi.is_trivial():
return LSeriesModularSymbolsNewformGamma0(M, i)
else:
return LSeriesModularSymbolsNewformCharacter(M, i)
class LSeriesModularSymbolsMotive(LSeriesProduct):
"""
The product of L-series attached to the modular symbols space M.
"""
def __init__(self, M):
self._M = M
if not is_ModularSymbolsSpace(M):
raise TypeError, "X must be a modular symbols space or have a modular symbols method"
self._M = M
D = M.decomposition()
for A in D:
_is_valid_modsym_space(A)
F = []
for A in D:
for X in _new_modsym_space_with_multiplicity(A):
N, d = X
chi = N.character()
for i in range(N.dimension()):
F.append( (LSeriesModularSymbolsNewform(N,i), d))
LSeriesProduct.__init__(self, F)
def modular_symbols(self):
return self._M
def __repr__(self):
return "L-series attached to %s"%self._M
class LSeriesModularAbelianVariety(LSeriesProduct):
"""
The product of L-series attached to the modular abelian variety A.
EXAMPLES::
sage: from psage.lseries.eulerprod import LSeries
sage: L = LSeries(J0(54)); L
L-series attached to Abelian variety J0(54) of dimension 4
sage: L.factor()
(L-series of a degree 1 newform of level 27 and weight 2)^2 * (L-series of a degree 1 newform of level 54 and weight 2) * (L-series of a degree 1 newform of level 54 and weight 2)
sage: L(1)
0.250717238804658
sage: L.taylor_series(prec=20)
0.25072 + 0.59559*z + 0.15099*z^2 - 0.35984*z^3 + 0.056934*z^4 + 0.17184*z^5 + O(z^6)
Independent check of L(1)::
sage: prod(EllipticCurve(lbl).lseries()(1) for lbl in ['54a', '54b', '27a', '27a'])
0.250717238804658
Different check that totally avoids using Dokchitser::
sage: prod(EllipticCurve(lbl).lseries().at1()[0] for lbl in ['54a', '54b', '27a', '27a'])
0.250848605530185
"""
def __init__(self, A):
self._A = A
D = A.decomposition()
F = None
for A in D:
# TODO: This is ugly, but I don't know a cleaner way to do it yet.
# Could be painfully inefficient in general.
f = Newform(A.newform_label(), names='a')
M = f.modular_symbols(sign=1)
d = ZZ(A.dimension() / M.dimension())
L = LSeriesModularSymbolsMotive(M)**d
if F is None:
F = L
else:
F *= L
if F is None:
raise ValueError, "abelian variety must have positive dimension"
LSeriesProduct.__init__(self, F.factor())
def abelian_variety(self):
return self._A
def __repr__(self):
return "L-series attached to %s"%self._A
import psage.modform.hilbert.sqrt5.hmf
class LSeriesTwist(LSeriesAbstract):
"""
Twist of an L-series by a character.
"""
def __init__(self, L, chi, conductor=None, epsilon=None, prec=53):
"""
INPUT:
- `L` -- an L-series
- ``chi`` -- a character of the base field of L
- ``conductor`` -- None, or a list of conductors to try
- ``prec`` -- precision to use when trying conductors, if
conductor is a list
"""
self._L = L
self._chi = chi
if not chi.is_primitive():
raise ValueError, "character must be primitive"
A = ZZ(L.conductor())
B = chi.conductor()
if conductor is None:
if A.gcd(B) != 1:
# Make a list of all possible conductors, and let the
# functional equation figure it out.
smallest = ZZ(A)
while smallest.gcd(B) != 1:
smallest = smallest // smallest.gcd(B)
biggest = A * (B**L.degree())
assert biggest % smallest == 0
#
# TODO: improve this using the theorem stated
# on page 1 of http://wstein.org/papers/padictwist/
#
conductor = [smallest*d for d in divisors(biggest//smallest)]
else:
conductor = A * (B**L.degree())
hodge_numbers = L.hodge_numbers()
weight = L.weight()
if epsilon is None:
if L.epsilon() != 'solve':
if chi.order() <= 2:
if A.gcd(B) == 1:
epsilon = L.epsilon() * chi(-A)
else:
epsilon = [L.epsilon(), -L.epsilon()]
else:
epsilon = 'solve'
else:
epsilon = 'solve'
is_selfdual = L.is_selfdual()
poles = [] # ??? TODO -- no clue here.
residues = 'automatic'
base_field = L.base_field()
LSeriesAbstract.__init__(self, conductor, hodge_numbers, weight, epsilon,
poles, residues, base_field, is_selfdual, prec)
def _local_factor(self, P, prec):
L0 = self._L.local_factor(P, prec)
chi = self._chi
T = L0.parent().gen()
c = chi(P)
if prec is not None:
c = ComplexField(prec)(c)
return L0(c*T)
def __repr__(self):
return "Twist of %s by %s"%(self._L, self._chi)
def _cmp(self, right):
return cmp((self._L, self._chi), (right._L, right._chi))
def untwisted_lseries(self):
return self._L
def twist_character(self):
return self._chi
##############
# TODO: General tensor products and symmetric powers: see
# http://magma.maths.usyd.edu.au/magma/handbook/text/1392#15272
##############
def LSeries(X, *args, **kwds):
"""
Return the L-series of X, where X can be any of the following:
- elliptic curve over a number field (including QQ)
- Dirichlet character
- cuspidal newform
- new cuspidal modular symbols space -- need not be simple
- string: 'zeta' (Riemann Zeta function), 'delta'
- modular elliptic curve attached to Hilbert modular forms space
For convenience, if L is returned, then L._X is set to X.
EXAMPLES::
The Dedekind Zeta function of a number field::
sage: from psage.lseries.eulerprod import LSeries
sage: K.<a> = NumberField(x^2 + 1)
sage: L = LSeries(K); L
Dedekind Zeta function of Number Field in a with defining polynomial x^2 + 1
sage: L(2)
1.50670300992299
sage: K.zeta_coefficients(100) == L.anlist(100)[1:]
True
sage: L = LSeries(ModularSymbols(43, weight=2,sign=1).cuspidal_subspace().decomposition()[1])
sage: L(1)
0.571720756464112
sage: L.factor()[0][0](1)
0.620539857407845
sage: L.factor()[1][0](1)
0.921328017272472
sage: L._X
Modular Symbols subspace of dimension 2 of Modular Symbols space of dimension 4 for Gamma_0(43) of weight 2 with sign 1 over Rational Field
sage: L = LSeries(ModularSymbols(DirichletGroup(13).0^2, weight=2,sign=1).cuspidal_subspace())
sage: L(1)
0.298115272465799 - 0.0402203326076733*I
sage: from psage.modform.hilbert.sqrt5.hmf import F, HilbertModularForms
sage: D = HilbertModularForms(-13*F.0+5).elliptic_curve_factors()
sage: D
[
Isogeny class of elliptic curves over QQ(sqrt(5)) attached to form number 0 in Hilbert modular forms of dimension 4, level -13*a+5 (of norm 209=11*19) over QQ(sqrt(5)),
Isogeny class of elliptic curves over QQ(sqrt(5)) attached to form number 1 in Hilbert modular forms of dimension 4, level -13*a+5 (of norm 209=11*19) over QQ(sqrt(5)),
Isogeny class of elliptic curves over QQ(sqrt(5)) attached to form number 2 in Hilbert modular forms of dimension 4, level -13*a+5 (of norm 209=11*19) over QQ(sqrt(5))
]
sage: L = LSeries(D[0])
sage: L(RealField(10)(1))
0
sage: L.epsilon()
-1
The L-series of a modular abelian variety with both new and old parts::
sage: L = LSeries(J0(33)); L
L-series attached to Abelian variety J0(33) of dimension 3
sage: L.factor()
(L-series of a degree 1 newform of level 11 and weight 2)^2 * (L-series of a degree 1 newform of level 33 and weight 2)
sage: L.local_factor(2, prec=oo)
8*T^6 + 12*T^5 + 12*T^4 + 8*T^3 + 6*T^2 + 3*T + 1
sage: L(1)
0.0481553138900504
We check the above computation of L(1) via independent methods (and implementations)::
sage: prod(EllipticCurve(lbl).lseries().at1()[0] for lbl in ['11a', '11a', '33a'])
0.0481135342926321
sage: prod(EllipticCurve(lbl).lseries()(1) for lbl in ['11a', '11a', '33a'])
0.0481553138900504
A nonsimple new modular symbols space of level 43::
sage: L = LSeries(ModularSymbols(43,sign=1).cuspidal_subspace())
sage: L
L-series attached to Modular Symbols subspace of dimension 3 of Modular Symbols space of dimension 4 for Gamma_0(43) of weight 2 with sign 1 over Rational Field
sage: L(1)
0
sage: L.taylor_series()
0.196399786632435*z + 0.314922741074845*z^2 - 0.0797083673829092*z^3 - 0.161630566287135*z^4 + 0.123939472976207*z^5 + O(z^6)
sage: L.factor()
(L-series of a degree 1 newform of level 43 and weight 2) * (L-series of a degree 2 newform of level 43 and weight 2) * (L-series of a degree 2 newform of level 43 and weight 2)
sage: L.analytic_rank()
1
sage: D = ModularSymbols(43,sign=1).cuspidal_subspace().decomposition()
sage: L0 = LSeries(D[0]); L1 = LSeries(D[1])
sage: L0.taylor_series() * L1.taylor_series()
0.196399786632435*z + 0.314922741074845*z^2 - 0.0797083673829091*z^3 - 0.161630566287135*z^4 + 0.123939472976207*z^5 + O(z^6)
sage: L0.factor()
L-series of a degree 1 newform of level 43 and weight 2
sage: L1.factor()
(L-series of a degree 2 newform of level 43 and weight 2) * (L-series of a degree 2 newform of level 43 and weight 2)
"""
L = _lseries(X, *args, **kwds)
L._X = X
return L
def _lseries(X, *args, **kwds):
"""
Helper function used by LSeries function.
"""
if is_EllipticCurve(X):
K = X.base_ring()
if is_RationalField(K):
return LSeriesEllipticCurveQQ(X, *args, **kwds)
elif list(K.defining_polynomial()) == [-1,-1,1]:
return LSeriesEllipticCurveSqrt5(X, *args, **kwds)
else:
return LSeriesEllipticCurve(X)
if is_DirichletCharacter(X):
if X.is_trivial() and X.is_primitive():
return LSeriesZeta(*args, **kwds)
else:
return LSeriesDirichletCharacter(X, *args, **kwds)
if is_NumberField(X):
return LSeriesDedekindZeta(X, *args, **kwds)
if isinstance(X, sage.modular.modform.element.Newform):
return LSeriesModularSymbolsNewform(X.modular_symbols(sign=1), *args, **kwds)
if is_ModularSymbolsSpace(X):
if X.sign() != 1:
raise NotImplementedError
return LSeriesModularSymbolsMotive(X, *args, **kwds)
if isinstance(X, str):
y = X.lower()
if y == 'zeta':
return LSeriesZeta(*args, **kwds)
elif y == 'delta':
return LSeriesDelta(*args, **kwds)
else:
raise ValueError, 'unknown L-series "%s"'%y
if isinstance(X, psage.modform.hilbert.sqrt5.hmf.EllipticCurveFactor):
return LSeriesModularEllipticCurveSqrt5(X, *args, **kwds)
if is_ModularAbelianVariety(X):
return LSeriesModularAbelianVariety(X, *args, **kwds)
raise NotImplementedError
| Python |
# L series
| Python |
from mpc_extras import *
| Python |
#################################################################################
#
# (c) Copyright 2010 William Stein
#
# This file is part of PSAGE
#
# PSAGE is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# PSAGE is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
#
#################################################################################
"""
Orders in Function Fields
"""
from sage.structure.parent_gens import ParentWithGens
from sage.rings.ring import IntegralDomain, PrincipalIdealDomain
from sage.rings.ideal import is_Ideal
class FunctionFieldOrder(IntegralDomain):
def __init__(self, fraction_field):
"""
EXAMPLES::
sage: R = FunctionField(QQ,'y').maximal_order()
sage: isinstance(R, sage.rings.function_field.function_field_order.FunctionFieldOrder)
True
"""
self._fraction_field = fraction_field
def _repr_(self):
"""
EXAMPLES::
sage: FunctionField(QQ,'y').maximal_order()._repr_()
'Maximal order in Rational function field in y over Rational Field'
"""
return "Order in %s"%self.fraction_field()
def is_finite(self):
"""
EXAMPLES::
sage: FunctionField(QQ,'y').maximal_order().is_finite()
False
"""
return False
def is_field(self, proof=True):
"""
EXAMPLES::
sage: FunctionField(QQ,'y').maximal_order().is_field()
False
"""
return False
def is_noetherian(self):
"""
Return True, since orders in function fields are noetherian.
EXAMPLES::
sage: FunctionField(QQ,'y').maximal_order().is_noetherian()
True
"""
return True
def fraction_field(self):
"""
EXAMPLES::
sage: FunctionField(QQ,'y').maximal_order().fraction_field()
Rational function field in y over Rational Field
"""
return self._fraction_field
def ideal_with_gens_over_base(self, gens):
"""
Return the fractional ideal with given generators over the
maximal ideal of the base field. That this is really an ideal
is not checked.
INPUT:
- ``basis`` -- list of elements that are a basis for the
ideal over the maximal order of the base field
EXAMPLES::
We construct an ideal in a rational function field::
sage: R.<y> = FunctionField(QQ)
sage: S = R.maximal_order()
sage: I = S.ideal_with_gens_over_base([y]); I
Ideal (y) of Maximal order in Rational function field in y over Rational Field
sage: I*I
Ideal (y^2) of Maximal order in Rational function field in y over Rational Field
We construct some ideals in a nontrivial function field::
sage: R.<x> = FunctionField(GF(7)); S.<y> = R[]
sage: L.<y> = R.extension(y^2 - x^3 - 1)
sage: M = L.equation_order(); M
Order in Function field in y defined by y^2 + 6*x^3 + 6
sage: I = M.ideal_with_gens_over_base([1, y]); I
Ideal (1, y) of Order in Function field in y defined by y^2 + 6*x^3 + 6
sage: I.module()
Free module of degree 2 and rank 2 over Maximal order in Rational function field in x over Finite Field of size 7
Echelon basis matrix:
[1 0]
[0 1]
"""
from function_field_ideal import ideal_with_gens_over_base
return ideal_with_gens_over_base(self, [self(a) for a in gens])
def ideal(self, *gens):
"""
Return the fractional ideal generated by the element gens or
the elements in gens if gens is a list.
EXAMPLES::
sage: R.<y> = FunctionField(QQ)
sage: S = R.maximal_order()
sage: S.ideal(y)
Ideal (y) of Maximal order in Rational function field in y over Rational Field
A fractional ideal of a nontrivial extension::
sage: R.<x> = FunctionField(GF(7)); S.<y> = R[]
sage: L.<y> = R.extension(y^2 - x^3 - 1)
sage: M = L.equation_order()
sage: M.ideal(1/y)
Ideal (1, (6/(x^3 + 1))*y) of Order in Function field in y defined by y^2 + 6*x^3 + 6
"""
if len(gens) == 1:
gens = gens[0]
if not isinstance(gens, (list, tuple)):
gens = [gens]
from function_field_ideal import ideal_with_gens
return ideal_with_gens(self, gens)
class FunctionFieldOrder_basis(FunctionFieldOrder):
"""
An order given by a basis over the maximal order of the base
field.
"""
def __init__(self, basis, check=True):
"""
EXAMPLES::
sage: K.<x> = FunctionField(GF(7)); R.<y> = K[]; L.<Y> = K.extension(y^4 + x*y + 4*x + 1); S = L.equation_order()
sage: S
Order in Function field in Y defined by y^4 + x*y + 4*x + 1
sage: type(S)
<class 'sage.rings.function_field.function_field_order.FunctionFieldOrder_basis'>
"""
if len(basis) == 0:
raise ValueError, "basis must have positive length"
fraction_field = basis[0].parent()
if len(basis) != fraction_field.degree():
raise ValueError, "length of basis must equal degree of field"
FunctionFieldOrder.__init__(self, fraction_field)
self._basis = tuple(basis)
V, fr, to = fraction_field.vector_space()
R = fraction_field.base_field().maximal_order()
self._module = V.span([to(b) for b in basis], base_ring=R)
self._ring = fraction_field.polynomial_ring()
self._populate_coercion_lists_(coerce_list=[self._ring])
if check:
if self._module.rank() != fraction_field.degree():
raise ValueError, "basis is not a basis"
IntegralDomain.__init__(self, self, names = fraction_field.variable_names(), normalize = False)
def _element_constructor_(self, f):
"""
EXAMPLES::
sage: R.<y> = FunctionField(QQ)
sage: R.maximal_order()._element_constructor_(y)
y
"""
# HUGE TODO: have to check that f is really in self!!
if f.parent() is self.fraction_field():
f = f.element()
elif f.parent() is self._ring:
return function_field_element.FunctionFieldElement_rational(self, f)
return function_field_element.FunctionFieldElement_rational(self, self._ring(f))
def fraction_field(self):
"""
EXAMPLES::
sage: K.<x> = FunctionField(GF(7)); R.<y> = K[]; L.<Y> = K.extension(y^4 + x*y + 4*x + 1); S = L.equation_order()
sage: S.fraction_field()
Function field in Y defined by y^4 + x*y + 4*x + 1
"""
return self._fraction_field
def basis(self):
"""
EXAMPLES::
sage: K.<x> = FunctionField(GF(7)); R.<y> = K[]; L.<Y> = K.extension(y^4 + x*y + 4*x + 1); S = L.equation_order()
sage: S.basis()
(1, Y, Y^2, Y^3)
"""
return self._basis
def free_module(self):
"""
EXAMPLES::
sage: K.<x> = FunctionField(GF(7)); R.<y> = K[]; L.<Y> = K.extension(y^4 + x*y + 4*x + 1); S = L.equation_order()
sage: S.free_module()
Free module of degree 4 and rank 4 over Maximal order in Rational function field in x over Finite Field of size 7
Echelon basis matrix:
[1 0 0 0]
[0 1 0 0]
[0 0 1 0]
[0 0 0 1]
"""
return self._module
## def polynomial_quotient_ring(self):
## """
## Return a quotient of a (possibly multivariate) polynomial ring
## that is isomorphic to self, along with morphisms back and
## forth.
## """
## raise NotImplementedError
import function_field_element
class FunctionFieldOrder_rational(PrincipalIdealDomain, FunctionFieldOrder):
"""
The maximal order in a rational function field.
"""
def __init__(self, function_field):
"""
EXAMPLES::
sage: K.<t> = FunctionField(GF(19)); K
Rational function field in t over Finite Field of size 19
sage: R = K.maximal_order(); R
Maximal order in Rational function field in t over Finite Field of size 19
sage: type(R)
<class 'sage.rings.function_field.function_field_order.FunctionFieldOrder_rational'>
"""
FunctionFieldOrder.__init__(self, function_field)
IntegralDomain.__init__(self, self, names = function_field.variable_names(), normalize = False)
self._ring = function_field._ring
self._populate_coercion_lists_(coerce_list=[self._ring])
self._gen = self(self._ring.gen())
self._basis = (self(1),)
def basis(self):
"""
Return basis (=1) for this order as a module over the polynomial ring.
EXAMPLES::
sage: K.<t> = FunctionField(GF(19))
sage: M = K.maximal_order()
sage: M.basis()
(1,)
sage: parent(M.basis()[0])
Maximal order in Rational function field in t over Finite Field of size 19
"""
return self._basis
def ideal(self, *gens):
"""
Return the fractional ideal generated by the element gens or
the elements in gens if gens is a list.
EXAMPLES::
sage: R.<y> = FunctionField(QQ)
sage: S = R.maximal_order()
sage: S.ideal(y)
Ideal (y) of Maximal order in Rational function field in y over Rational Field
A fractional ideal of a nontrivial extension::
sage: R.<x> = FunctionField(GF(7)); S.<y> = R[]
sage: L.<y> = R.extension(y^2 - x^3 - 1)
sage: M = L.equation_order()
sage: M.ideal(1/y)
Ideal (1, (6/(x^3 + 1))*y) of Order in Function field in y defined by y^2 + 6*x^3 + 6
A non-principal ideal::
sage: R.<x> = FunctionField(GF(7))
sage: S = R.maximal_order()
sage: S.ideal(x^3+1,x^3+6)
Ideal (1) of Maximal order in Rational function field in x over Finite Field of size 7
sage: S.ideal((x^2+1)*(x^3+1),(x^3+6)*(x^2+1))
Ideal (x^2 + 1) of Maximal order in Rational function field in x over Finite Field of size 7
"""
if len(gens) == 1:
gens = gens[0]
if not isinstance(gens, (list, tuple)):
if is_Ideal(gens):
gens = gens.gens()
else:
gens = [gens]
from function_field_ideal import ideal_with_gens
return ideal_with_gens(self, gens)
def _repr_(self):
"""
EXAMPLES::
sage: FunctionField(QQ,'y').maximal_order()._repr_()
'Maximal order in Rational function field in y over Rational Field'
"""
return "Maximal order in %s"%self.fraction_field()
def gen(self, n=0):
"""
EXAMPLES::
sage: R = FunctionField(QQ,'y').maximal_order(); R.gen()
y
sage: R.gen(1)
Traceback (most recent call last):
...
IndexError: Only one generator.
"""
if n != 0: raise IndexError, "Only one generator."
return self._gen
def ngens(self):
"""
EXAMPLES::
sage: R = FunctionField(QQ,'y').maximal_order(); R.ngens()
1
"""
return 1
def _element_constructor_(self, f):
"""
EXAMPLES::
sage: R.<y> = FunctionField(QQ)
sage: R.maximal_order()._element_constructor_(y)
y
"""
# HUGE TODO: have to check that f is really in self!!
if f.parent() is self.fraction_field():
f = f.element()
if f.parent() is self._ring:
return function_field_element.FunctionFieldElement_rational(self, f)
return function_field_element.FunctionFieldElement_rational(self, self._ring(f))
## def polynomial_quotient_ring(self):
## """
## Return a quotient of a (possibly multivariate) polynomial ring
## that is isomorphic to self, along with morphisms back and
## forth.
## EXAMPLES::
## """
## return self._ring
| Python |
#################################################################################
#
# (c) Copyright 2010 William Stein
#
# This file is part of PSAGE
#
# PSAGE is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# PSAGE is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
#
#################################################################################
r"""
"""
from sage.categories.map import Map
from sage.categories.homset import Hom
from function_field_order import FunctionFieldOrder
class FunctionFieldIsomorphism(Map):
r"""
A base class for various isomorphisms between function fields and
vector spaces.
EXAMPLES::
sage: K.<x> = FunctionField(QQ); R.<y> = K[]; L.<Y> = K.extension(y^2 - x*y + 4*x^3)
sage: V, f, t = L.vector_space()
sage: isinstance(f, sage.rings.function_field.maps.FunctionFieldIsomorphism)
True
"""
def _repr_type(self):
"""
Return the type of this map (an isomorphism), for the purposes of printing out self.
EXAMPLES::
sage: K.<x> = FunctionField(QQ); R.<y> = K[]; L.<Y> = K.extension(y^2 - x*y + 4*x^3)
sage: V, f, t = L.vector_space()
sage: f._repr_type()
'Isomorphism'
"""
return "Isomorphism"
def is_injective(self):
"""
Return True, since this isomorphism is injective.
EXAMPLES::
sage: K.<x> = FunctionField(QQ); R.<y> = K[]; L.<Y> = K.extension(y^2 - x*y + 4*x^3)
sage: V, f, t = L.vector_space()
sage: f.is_injective()
True
"""
return True
def is_surjective(self):
"""
Return True, since this isomorphism is surjective.
EXAMPLES::
sage: K.<x> = FunctionField(QQ); R.<y> = K[]; L.<Y> = K.extension(y^2 - x*y + 4*x^3)
sage: V, f, t = L.vector_space()
sage: f.is_surjective()
True
"""
return True
class MapVectorSpaceToFunctionField(FunctionFieldIsomorphism):
r"""
An isomorphism from a vector space and a function field.
EXAMPLES:
sage: K.<x> = FunctionField(QQ); R.<y> = K[]; L.<Y> = K.extension(y^2 - x*y + 4*x^3)
sage: V, f, t = L.vector_space(); f
Isomorphism map:
From: Vector space of dimension 2 over Rational function field in x over Rational Field
To: Function field in Y defined by y^2 - x*y + 4*x^3
"""
def __init__(self, V, K):
"""
EXAMPLES::
sage: K.<x> = FunctionField(QQ); R.<y> = K[]; L.<Y> = K.extension(y^2 - x*y + 4*x^3)
sage: V, f, t = L.vector_space(); type(f)
<class 'sage.rings.function_field.maps.MapVectorSpaceToFunctionField'>
"""
self._V = V
self._K = K
self._R = K.polynomial_ring()
FunctionFieldIsomorphism.__init__(self, Hom(V, K))
def _call_(self, v):
"""
EXAMPLES::
sage: K.<x> = FunctionField(QQ); R.<y> = K[]; L.<Y> = K.extension(y^2 - x*y + 4*x^3)
sage: V, f, t = L.vector_space()
sage: f(x*V.0 + (1/x^3)*V.1) # indirect doctest
1/x^3*Y + x
"""
f = self._R(self._V(v).list())
return self._K(f)
def domain(self):
"""
EXAMPLES::
sage: K.<x> = FunctionField(QQ); R.<y> = K[]; L.<Y> = K.extension(y^2 - x*y + 4*x^3)
sage: V, f, t = L.vector_space()
sage: f.domain()
Vector space of dimension 2 over Rational function field in x over Rational Field
"""
return self._V
def codomain(self):
"""
EXAMPLES::
sage: K.<x> = FunctionField(QQ); R.<y> = K[]; L.<Y> = K.extension(y^2 - x*y + 4*x^3)
sage: V, f, t = L.vector_space()
sage: f.codomain()
Function field in Y defined by y^2 - x*y + 4*x^3
"""
return self._K
class MapFunctionFieldToVectorSpace(FunctionFieldIsomorphism):
"""
An isomorphism from a function field to a vector space.
EXAMPLES::
sage: K.<x> = FunctionField(QQ); R.<y> = K[]; L.<Y> = K.extension(y^2 - x*y + 4*x^3)
sage: V, f, t = L.vector_space(); t
Isomorphism map:
From: Function field in Y defined by y^2 - x*y + 4*x^3
To: Vector space of dimension 2 over Rational function field in x over Rational Field
"""
def __init__(self, K, V):
"""
EXAMPLES::
sage: K.<x> = FunctionField(QQ); R.<y> = K[]; L.<Y> = K.extension(y^2 - x*y + 4*x^3)
sage: V, f, t = L.vector_space(); type(t)
<class 'sage.rings.function_field.maps.MapFunctionFieldToVectorSpace'>
"""
self._V = V
self._K = K
self._zero = K.base_ring()(0)
self._n = K.degree()
FunctionFieldIsomorphism.__init__(self, Hom(K, V))
def domain(self):
"""
EXAMPLES::
sage: K.<x> = FunctionField(QQ); R.<y> = K[]; L.<Y> = K.extension(y^2 - x*y + 4*x^3)
sage: V, f, t = L.vector_space()
sage: t.domain()
Function field in Y defined by y^2 - x*y + 4*x^3
"""
return self._K
def codomain(self):
"""
EXAMPLES::
sage: K.<x> = FunctionField(QQ); R.<y> = K[]; L.<Y> = K.extension(y^2 - x*y + 4*x^3)
sage: V, f, t = L.vector_space()
sage: t.codomain()
Vector space of dimension 2 over Rational function field in x over Rational Field
"""
return self._V
def _repr_type(self):
"""
EXAMPLES::
sage: K.<x> = FunctionField(QQ); R.<y> = K[]; L.<Y> = K.extension(y^2 - x*y + 4*x^3)
sage: V, f, t = L.vector_space()
sage: t._repr_type()
'Isomorphism'
"""
return "Isomorphism"
def _call_(self, x):
"""
EXAMPLES::
sage: K.<x> = FunctionField(QQ); R.<y> = K[]; L.<Y> = K.extension(y^2 - x*y + 4*x^3)
sage: V, f, t = L.vector_space()
sage: t(x + (1/x^3)*Y) # indirect doctest
(x, 1/x^3)
"""
y = self._K(x)
v = y.list()
w = v + [self._zero]*(self._n - len(v))
return self._V(w)
##########################################################################
# Morphisms between function fields
class FunctionFieldMorphism(Map):
"""
EXAMPLES::
sage: R.<x> = FunctionField(QQ); S.<y> = R[]
sage: L.<y> = R.extension(y^2 - x^2)
sage: f = L.hom(-y); f
Morphism of function fields defined by y |--> -y
"""
def __init__(self, parent, im_gen, base_morphism):
"""
EXAMPLES::
sage: R.<x> = FunctionField(GF(7)); S.<y> = R[]
sage: L.<y> = R.extension(y^3 + 6*x^3 + x); f = L.hom(y*2); f
Morphism of function fields defined by y |--> 2*y
sage: type(f)
<class 'sage.rings.function_field.maps.FunctionFieldMorphism'>
sage: factor(L.polynomial())
y^3 + 6*x^3 + x
sage: f(y).charpoly('y')
y^3 + 6*x^3 + x
"""
self._im_gen = im_gen
self._base_morphism = base_morphism
Map.__init__(self, parent)
# Verify that the morphism is valid:
R = self.codomain()['X']
v = parent.domain().polynomial().list()
if base_morphism is not None:
v = [base_morphism(a) for a in v]
f = R(v)
if f(im_gen):
raise ValueError, "invalid morphism"
def is_injective(self):
"""
EXAMPLES::
sage: R.<x> = FunctionField(GF(7)); S.<y> = R[]
sage: L.<y> = R.extension(y^3 + 6*x^3 + x); f = L.hom(y*2)
sage: f.is_injective()
True
"""
return True
def __repr__(self):
"""
EXAMPLES::
sage: R.<x> = FunctionField(GF(7)); S.<y> = R[]
sage: L.<y> = R.extension(y^3 + 6*x^3 + x); f = L.hom(y*2)
sage: f.__repr__()
'Morphism of function fields defined by y |--> 2*y'
"""
return "Morphism of function fields defined by %s"%self._short_repr()
def __nonzero__(self):
"""
EXAMPLES::
sage: R.<x> = FunctionField(GF(7)); S.<y> = R[]
sage: L.<y> = R.extension(y^3 + 6*x^3 + x); f = L.hom(y*2)
sage: f.__nonzero__()
True
sage: bool(f)
True
"""
return True
def _short_repr(self):
"""
EXAMPLES::
sage: R.<x> = FunctionField(GF(7)); S.<y> = R[]
sage: L.<y> = R.extension(y^3 + 6*x^3 + x); f = L.hom(y*2)
sage: f._short_repr()
'y |--> 2*y'
"""
a = '%s |--> %s'%(self.domain().gen(), self._im_gen)
if self._base_morphism is not None:
a += ', ' + self._base_morphism._short_repr()
return a
def _call_(self, x):
"""
EXAMPLES::
sage: R.<x> = FunctionField(GF(7)); S.<y> = R[]
sage: L.<y> = R.extension(y^3 + 6*x^3 + x); f = L.hom(y*2)
sage: f(y/x + x^2/(x+1)) # indirect doctest
2/x*y + x^2/(x + 1)
sage: f(y)
2*y
"""
v = x.list()
if self._base_morphism is not None:
v = [self._base_morphism(a) for a in v]
f = v[0].parent()['X'](v)
return f(self._im_gen)
class FunctionFieldMorphism_rational(FunctionFieldMorphism):
def __init__(self, parent, im_gen):
"""
EXAMPLES::
sage: R.<x> = FunctionField(GF(7)); f = R.hom(1/x); f
Morphism of function fields defined by x |--> 1/x
sage: type(f)
<class 'sage.rings.function_field.maps.FunctionFieldMorphism_rational'>
"""
Map.__init__(self, parent)
self._im_gen = im_gen
self._base_morphism = None
def _call_(self, x):
"""
EXAMPLES::
sage: R.<x> = FunctionField(GF(7)); f = R.hom(1/x); f
Morphism of function fields defined by x |--> 1/x
sage: f(x+1) # indirect doctest
(x + 1)/x
sage: 1/x + 1
(x + 1)/x
"""
a = x.element()
return a.subs({a.parent().gen():self._im_gen})
| Python |
#################################################################################
#
# (c) Copyright 2010 William Stein
#
# This file is part of PSAGE
#
# PSAGE is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# PSAGE is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
#
#################################################################################
# Function fields
from constructor import FunctionField
from function_field import is_FunctionField
| Python |
#################################################################################
#
# (c) Copyright 2010 William Stein
#
# This file is part of PSAGE
#
# PSAGE is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# PSAGE is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
#
#################################################################################
from sage.rings.ideal import Ideal_generic
class FunctionFieldIdeal(Ideal_generic):
"""
A fractional ideal of a function field.
EXAMPLES::
sage: R.<x> = FunctionField(GF(7))
sage: S = R.maximal_order(); I = S.ideal(x^3+1)
sage: isinstance(I, sage.rings.function_field.function_field_ideal.FunctionFieldIdeal)
True
"""
pass
class FunctionFieldIdeal_module(FunctionFieldIdeal):
"""
A fractional ideal specified by a finitely generated module over
the integers of the base field.
EXAMPLES::
An ideal in a rational function field::
sage: R.<x> = FunctionField(QQ); S.<y> = R[]
sage: L.<y> = R.extension(y^2 - x^3 - 1); M = L.equation_order()
sage: I = M.ideal(y)
sage: I
Ideal (x^3 + 1, -y) of Order in Function field in y defined by y^2 - x^3 - 1
sage: I^2
Ideal (x^3 + 1, (-x^3 - 1)*y) of Order in Function field in y defined by y^2 - x^3 - 1
"""
def __init__(self, ring, module):
"""
INPUT:
- ``ring`` -- an order in a function field
- ``module`` -- a module
EXAMPLES::
sage: R.<x> = FunctionField(QQ); S.<y> = R[]
sage: L.<y> = R.extension(y^2 - x^3 - 1); M = L.equation_order()
sage: I = M.ideal(y)
sage: type(I)
<class 'sage.rings.function_field.function_field_ideal.FunctionFieldIdeal_module'>
"""
self._ring = ring
self._module = module
self._structure = ring.fraction_field().vector_space()
V, from_V, to_V = self._structure
gens = tuple([from_V(a) for a in module.basis()])
Ideal_generic.__init__(self, ring, gens, coerce=False)
def __contains__(self, x):
"""
Return True if x is in this ideal.
EXAMPLES::
sage: R.<x> = FunctionField(GF(7)); S.<y> = R[]
sage: L.<y> = R.extension(y^2 - x^3 - 1); M = L.equation_order()
sage: I = M.ideal_with_gens_over_base([1, y]); I
Ideal (1, y) of Order in Function field in y defined by y^2 + 6*x^3 + 6
sage: y in I
True
sage: y/x in I
False
sage: y^2 - 2 in I
True
"""
return self._structure[2](x) in self._module
def module(self):
"""
Return module over the maximal order of the base field that
underlies self.
The formation of this module is compatible with the vector
space corresponding to the function field.
OUTPUT:
- a module over the maximal order of the base field of self
EXAMPLES::
sage: R.<x> = FunctionField(GF(7))
sage: S = R.maximal_order(); S
Maximal order in Rational function field in x over Finite Field of size 7
sage: R.polynomial_ring()
Univariate Polynomial Ring in x over Rational function field in x over Finite Field of size 7
sage: I = S.ideal_with_gens_over_base([x^2 + 1, x*(x^2+1)])
sage: I.gens()
(x^2 + 1,)
sage: I.module()
Free module of degree 1 and rank 1 over Maximal order in Rational function field in x over Finite Field of size 7
User basis matrix:
[x^2 + 1]
sage: V, from_V, to_V = R.vector_space(); V
Vector space of dimension 1 over Rational function field in x over Finite Field of size 7
sage: I.module().is_submodule(V)
True
"""
return self._module
def __add__(self, other):
"""
Add together two ideals.
EXAMPLES::
sage: R.<x> = FunctionField(GF(7)); S.<y> = R[]
sage: L.<y> = R.extension(y^2 - x^3 - 1); M = L.equation_order()
sage: I = M.ideal(y); J = M.ideal(y+1)
sage: Z = I + J; Z
Ideal (y + 1, 6*y) of Order in Function field in y defined by y^2 + 6*x^3 + 6
sage: 1 in Z
True
sage: M.ideal(y^2) + M.ideal(y^3) == M.ideal(y^2,y^3)
True
"""
if not isinstance(other, FunctionFieldIdeal_module):
other = self.ring().ideal(other)
return FunctionFieldIdeal_module(self.ring(), self.module() + other.module())
def intersection(self, other):
"""
Return the intersection of the ideals self and other.
EXAMPLES::
sage: R.<x> = FunctionField(GF(7)); S.<y> = R[]
sage: L.<y> = R.extension(y^2 - x^3 - 1); M = L.equation_order()
sage: I = M.ideal(y^3); J = M.ideal(y^2)
sage: Z = I.intersection(J); Z
Ideal (6*x^6 + 5*x^3 + 6, (6*x^3 + 6)*y) of Order in Function field in y defined by y^2 + 6*x^3 + 6
sage: y^2 in Z
False
sage: y^3 in Z
True
"""
if not isinstance(other, FunctionFieldIdeal_module):
other = self.ring().ideal(other)
if self.ring() != other.ring():
raise ValueError, "rings must be the same"
return FunctionFieldIdeal_module(self.ring(), self.module().intersection(other.module()))
def __cmp__(self, other):
"""
Compare self and other.
EXAMPLES::
sage: R.<x> = FunctionField(GF(7)); S.<y> = R[]
sage: L.<y> = R.extension(y^2 - x^3 - 1)
sage: M = L.equation_order()
sage: I = M.ideal(y*(y+1)); J = M.ideal((y^2-2)*(y+1))
sage: I+J == J+I # indirect test
True
sage: I == J
False
sage: I < J
True
sage: J < I
False
"""
if not isinstance(other, FunctionFieldIdeal_module):
other = self.ring().ideal(other)
if self.ring() != other.ring():
raise ValueError, "rings must be the same"
return cmp(self.module(), other.module())
def __invert__(self):
"""
Return the inverse of this fractional ideal.
EXAMPLES::
sage: R.<x> = FunctionField(GF(7)); S.<y> = R[]
sage: L.<y> = R.extension(y^2 - x^3 - 1); M = L.equation_order()
sage: I = M.ideal(y)
sage: I.__invert__()
Ideal (1, (6/(x^3 + 1))*y) of Order in Function field in y defined by y^2 + 6*x^3 + 6
sage: I^(-1)
Ideal (1, (6/(x^3 + 1))*y) of Order in Function field in y defined by y^2 + 6*x^3 + 6
sage: I.__invert__() * I
Ideal (1, 6*y) of Order in Function field in y defined by y^2 + 6*x^3 + 6
"""
if len(self.gens()) == 0:
raise ZeroDivisionError
# NOTE: If I = (g0, ..., gn), then {x : x*I is in R}
# is the intersection over i of {x : x*gi is in R}
# Thus (I + J)^(-1) = I^(-1) intersect J^(-1).
G = self.gens()
R = self.ring()
inv = R.ideal(~G[0])
for g in G[1:]:
inv = inv.intersection(R.ideal(~g))
return inv
def ideal_with_gens(R, gens):
"""
Return fractional ideal in the order of R with given generators
over R.
EXAMPLES::
sage: R.<x> = FunctionField(QQ); S.<y> = R[]
sage: L.<y> = R.extension(y^2 - x^3 - 1); M = L.equation_order()
sage: sage.rings.function_field.function_field_ideal.ideal_with_gens(M, [y])
Ideal (x^3 + 1, -y) of Order in Function field in y defined by y^2 - x^3 - 1
"""
K = R.fraction_field()
return ideal_with_gens_over_base(R, [b*K(g) for b in R.basis() for g in gens])
def ideal_with_gens_over_base(R, gens):
"""
Return fractional ideal in the given order R with given generators
over the maximal order of the base field.
EXAMPLES::
sage: R.<x> = FunctionField(QQ); S.<y> = R[]
sage: L.<y> = R.extension(y^2 - x^3 - 1); M = L.equation_order()
sage: sage.rings.function_field.function_field_ideal.ideal_with_gens_over_base(M, [x^3+1,-y])
Ideal (x^3 + 1, -y) of Order in Function field in y defined by y^2 - x^3 - 1
"""
K = R.fraction_field()
V, from_V, to_V = K.vector_space()
# We handle the case of a rational function field separately,
# since this is the base case and is used, e.g,. internally
# by the linear algebra Hermite form code.
import function_field_order
if isinstance(R, function_field_order.FunctionFieldOrder_rational):
try:
v = R._ring.ideal([x.element() for x in gens]).gens_reduced()
assert len(v) == 1
basis = [to_V(v[0])]
M = V.span_of_basis(basis, check=False, already_echelonized=True, base_ring=R)
except Exception, msg:
print msg # TODO --for debugging
raise
else:
# General case
S = V.base_field().maximal_order()
M = V.span([to_V(b) for b in gens], base_ring=S)
return FunctionFieldIdeal_module(R, M)
| Python |
#################################################################################
#
# (c) Copyright 2010 William Stein
#
# This file is part of PSAGE
#
# PSAGE is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# PSAGE is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
#
#################################################################################
r"""
Function fields
EXAMPLES::
We create an extension of a rational function fields, and do some
simple arithmetic in it::
sage: K.<x> = FunctionField(GF(5^2,'a')); K
Rational function field in x over Finite Field in a of size 5^2
sage: R.<y> = K[]
sage: L.<y> = K.extension(y^5 - (x^3 + 2*x*y + 1/x)); L
Function field in y defined by y^5 + 3*x*y + (4*x^4 + 4)/x
sage: y^4
y^4
sage: y^5
2*x*y + (x^4 + 1)/x
sage: a = 1/y; a
(4*x/(4*x^4 + 4))*y^4 + 2*x^2/(4*x^4 + 4)
sage: a * y
1
We next make an extension of the above function field, illustrating
that arithmetic with a tower of 3 fields is fully supported::
sage: S.<t> = L[]
sage: M.<t> = L.extension(t^2 - x*y)
sage: M
Function field in t defined by t^2 + 4*x*y
sage: t^2
x*y
sage: 1/t
((1/(x^4 + 1))*y^4 + 2*x/(4*x^4 + 4))*t
sage: M.base_field()
Function field in y defined by y^5 + 3*x*y + (4*x^4 + 4)/x
sage: M.base_field().base_field()
Rational function field in x over Finite Field in a of size 5^2
"""
from sage.structure.category_object import CategoryObject
from sage.rings.ring import Field
from sage.rings.integer_ring import ZZ
from sage.structure.parent_gens import ParentWithGens
import function_field_element
from category import FunctionFields
CAT = FunctionFields()
import maps
def is_FunctionField(x):
"""
Return True if x is of function field type.
EXAMPLES::
sage: from sage.rings.function_field.all import is_FunctionField
sage: is_FunctionField(QQ)
False
sage: is_FunctionField(FunctionField(QQ,'t'))
True
"""
return isinstance(x, FunctionField)
class FunctionField(Field):
"""
The abstract base class for all function fields.
EXAMPLES::
sage: K.<x> = FunctionField(QQ)
sage: isinstance(K, sage.rings.function_field.function_field.FunctionField)
True
"""
def characteristic(self):
"""
Return the characteristic of this function field.
EXAMPLES::
sage: R.<t> = FunctionField(QQ)
sage: R.characteristic()
0
sage: R.<t> = FunctionField(GF(7))
sage: R.characteristic()
7
"""
return self.constant_field().characteristic()
def is_finite(self):
"""
Return whether this function field is finite, which it is not.
EXAMPLES::
sage: R.<t> = FunctionField(QQ)
sage: R.is_finite()
False
sage: R.<t> = FunctionField(GF(7))
sage: R.is_finite()
False
"""
return False
def extension(self, f, names=None):
"""
Create an extension L = K[y]/(f(y)) of a function field,
defined by a univariate polynomial in one variable over this
function field K.
INPUT:
- `f` -- a univariate polynomial over self
- ``names`` -- None or string or length-1 tuple
OUTPUT:
- a function field
EXAMPLES::
sage: K.<x> = FunctionField(QQ); R.<y> = K[]
sage: K.extension(y^5 - x^3 - 3*x + x*y)
Function field in y defined by y^5 + x*y - x^3 - 3*x
A nonintegral defining polynomial::
sage: K.<t> = FunctionField(QQ); R.<y> = K[]
sage: K.extension(y^3 + (1/t)*y + t^3/(t+1))
Function field in y defined by y^3 + 1/t*y + t^3/(t + 1)
The defining polynomial need not be monic or integral::
sage: K.extension(t*y^3 + (1/t)*y + t^3/(t+1))
Function field in y defined by t*y^3 + 1/t*y + t^3/(t + 1)
"""
if names is None:
names = f.variable_name()
return FunctionField_polymod(f, names)
def order_with_basis(self, basis, check=True):
"""
Return the order with given basis over the maximal order of
the base field.
INPUT:
- ``basis`` -- a list of elements of self
- ``check`` -- bool (default: True); if True, check that
the basis is really linearly independent
OUTPUT:
- an order in this function field
EXAMPLES::
sage: K.<x> = FunctionField(QQ); R.<y> = K[]; L.<Y> = K.extension(y^3 + x^3 + 4*x + 1)
sage: O = L.order_with_basis([1, Y, Y^2]); O
Order in Function field in Y defined by y^3 + x^3 + 4*x + 1
sage: O.basis()
(1, Y, Y^2)
sage: O = L.order_with_basis([x, x^2 + x*Y, (2/3)*Y^2]); O
Order in Function field in Y defined by y^3 + x^3 + 4*x + 1
sage: O.basis()
(x, x*Y + x^2, 2/3*Y^2)
"""
from function_field_order import FunctionFieldOrder_basis
return FunctionFieldOrder_basis([self(a) for a in basis], check=check)
def order(self, x, check=True):
"""
Return the order in this function field generated over the
maximal order by x or the elements of x if x is a list.
INPUT:
- ``x`` -- element of self, or a list of elements of self
- ``check`` -- bool (default: True); if True, check that
x really generates an order
EXAMPLES::
sage: K.<x> = FunctionField(QQ); R.<y> = K[]; L.<Y> = K.extension(y^3 + x^3 + 4*x + 1)
sage: O = L.order(Y); O
Order in Function field in Y defined by y^3 + x^3 + 4*x + 1
sage: O.basis()
(1, Y, Y^2)
sage: Z = K.order(x); Z
Order in Rational function field in x over Rational Field
sage: Z.basis()
(1,)
Orders with multiple generators, not yet supported::
sage: Z = K.order([x,x^2]); Z
Traceback (most recent call last):
...
NotImplementedError
"""
if not isinstance(x, (list, tuple)):
x = [x]
if len(x) == 1:
g = x[0]
basis = [self(1)]
for i in range(self.degree()-1):
basis.append(basis[-1]*g)
else:
raise NotImplementedError
return self.order_with_basis(basis, check=check)
def _coerce_map_from_(self, R):
"""
Return True if there is a coerce map from R to self.
EXAMPLES::
sage: K.<x> = FunctionField(QQ); R.<y> = K[]; L.<Y> = K.extension(y^3 + x^3 + 4*x + 1)
sage: L.equation_order()
Order in Function field in Y defined by y^3 + x^3 + 4*x + 1
sage: L._coerce_map_from_(L.equation_order())
True
sage: L._coerce_map_from_(GF(7))
False
"""
from function_field_order import FunctionFieldOrder
if isinstance(R, FunctionFieldOrder) and R.fraction_field() == self:
return True
return False
def hom(self, im_gens, base_morphism=None):
"""
Create a homomorphism from self to another function field.
INPUT:
- ``im_gens`` -- a list of images of the generators of self
and of successive base rings.
- ``base_morphism`` -- (default: None) a homomorphism of
the base ring, after the im_gens are used. Thus if
im_gens has length 2, then base_morphism should be a morphism
from self.base_ring().base_ring().
EXAMPLES::
We create a rational function field, and a quadratic extension of it::
sage: R.<x> = FunctionField(QQ); S.<y> = R[]
sage: L.<y> = R.extension(y^2 - x^3 - 1)
We make the field automorphism that sends y to -y::
sage: f = L.hom(-y); f
Morphism of function fields defined by y |--> -y
Evaluation works::
sage: f(y*x - 1/x)
-x*y - 1/x
We try to define an invalid morphism::
sage: f = L.hom(y+1); f
Traceback (most recent call last):
...
ValueError: invalid morphism
We make a morphism of the base rational function field::
sage: phi = R.hom(x+1); phi
Morphism of function fields defined by x |--> x + 1
sage: phi(x^3 - 3)
x^3 + 3*x^2 + 3*x - 2
sage: (x+1)^3-3
x^3 + 3*x^2 + 3*x - 2
We make a morphism by specifying where the generators and the
base generators go::
sage: L.hom([-y, x])
Morphism of function fields defined by y |--> -y, x |--> x
We make another extension of a rational function field::
sage: R2.<t> = FunctionField(QQ); S2.<w> = R2[]
sage: L2.<w> = R.extension((4*w)^2 - (t+1)^3 - 1)
We define a morphism, by givin the images of generators::
sage: f = L.hom([4*w, t+1]); f
Morphism of function fields defined by y |--> 4*w, x |--> t + 1
Evaluation works, as expected::
sage: f(y+x)
4*w + t + 1
sage: f(x*y + x/(x^2+1))
(4*t + 4)*w + (t + 1)/(t^2 + 2*t + 2)
"""
if not isinstance(im_gens, (list,tuple)):
im_gens = [im_gens]
if len(im_gens) > 1:
base_morphism = self.base_field().hom(im_gens[1:], base_morphism)
return maps.FunctionFieldMorphism(self.Hom(im_gens[0].parent()), im_gens[0], base_morphism)
class FunctionField_polymod(FunctionField):
"""
A function field defined by a univariate polynomial, as an
extension of the base field.
EXAMPLES::
We make a function field defined by a degree 5 polynomial over the
rational function field over the rational numbers::
sage: K.<x> = FunctionField(QQ)
sage: R.<y> = K[]
sage: L.<w> = K.extension(y^5 - (x^3 + 2*x*y + 1/x)); L
Function field in w defined by y^5 - 2*x*y + (-x^4 - 1)/x
We next make a function field over the above nontrivial function
field L::
sage: S.<T> = L[]
sage: M.<alpha> = L.extension(T^2 + w*T + y); M
Function field in alpha defined by T^2 + w*T + w
sage: 1/alpha
((x/(-x^4 - 1))*w^4 - 2*x^2/(-x^4 - 1))*alpha - 1
sage: alpha * (1/alpha)
1
We drill down the tower of function fields::
sage: M.base_field()
Function field in w defined by y^5 - 2*x*y + (-x^4 - 1)/x
sage: M.base_field().base_field()
Rational function field in x over Rational Field
sage: M.base_field().base_field().constant_field()
Rational Field
sage: M.constant_base_field()
Rational Field
"""
def __init__(self, polynomial, names, category=CAT):
"""
Create a function field defined as an extension of another
function field by adjoining a root of a univariate polynomial.
INPUT:
- ``polynomial`` -- a univariate polynomial over a function field
- ``names`` -- variable names (as a tuple of length 1 or string)
- ``category`` -- a category (defaults to category of function fields)
EXAMPLES::
We create an extension of function fields::
sage: K.<x> = FunctionField(QQ); R.<y> = K[]
sage: L = K.extension(y^5 - x^3 - 3*x + x*y); L
Function field in y defined by y^5 + x*y - x^3 - 3*x
Note the type::
sage: type(L)
<class 'sage.rings.function_field.function_field.FunctionField_polymod_with_category'>
We can set the variable name, which doesn't have to be y::
sage: L.<w> = K.extension(y^5 - x^3 - 3*x + x*y); L
Function field in w defined by y^5 + x*y - x^3 - 3*x
"""
from sage.rings.polynomial.all import is_Polynomial
if names is None:
names = (polynomial.variable_name(), )
if not is_Polynomial(polynomial):
raise TypeError, "polynomial must be a polynomial"
if polynomial.degree() <= 0:
raise ValueError, "polynomial must have positive degree"
base_field = polynomial.base_ring()
if not isinstance(base_field, FunctionField):
raise TypeError, "polynomial must be over a function"
self._base_field = base_field
self._polynomial = polynomial
ParentWithGens.__init__(self, base_field,
names=names, category = category)
self._hash = hash(polynomial)
self._ring = self._polynomial.parent()
self._populate_coercion_lists_(coerce_list=[base_field, self._ring])
self._gen = self(self._ring.gen())
def __hash__(self):
"""
Return hash of this function field.
EXAMPLES::
sage: K.<x> = FunctionField(QQ); R.<y> = K[]
sage: L = K.extension(y^5 - x^3 - 3*x + x*y); hash(L)
3183366741743088279 # 64-bit
? # 32-bit
"""
return self._hash
def monic_integral_model(self, names):
"""
Return a function field isomorphic to self, but with defining
polynomial that is monic and integral over the base field.
INPUT::
- ``names`` -- name of the generator of the new field this function constructs
EXAMPLES::
sage: K.<x> = FunctionField(QQ); R.<y> = K[]
sage: L.<alpha> = K.extension(x^2*y^5 - 1/x); L
Function field in alpha defined by x^2*y^5 - 1/x
sage: A, from_A, to_A = L.monic_integral_model('beta')
sage: A
Function field in beta defined by y^5 - x^12
sage: from_A
Morphism of function fields defined by beta |--> x^3*alpha
sage: to_A
Morphism of function fields defined by alpha |--> 1/x^3*beta
sage: to_A(alpha)
1/x^3*beta
sage: from_A(to_A(alpha))
alpha
sage: from_A(to_A(1/alpha))
x^3*alpha^4
sage: from_A(to_A(1/alpha)) == 1/alpha
True
"""
g, d = self._make_monic(self.polynomial())
R = self.base_field()
K = R.extension(g, names=names)
to_K = self.hom(K.gen() / d)
from_K = K.hom(self.gen() * d)
return K, from_K, to_K
def _make_monic(self, f):
r"""
Let alpha be a root of f. This function returns a monic
integral polynomial g and an element d of the base field such
that g(alpha*d) = 0.
EXAMPLES::
sage: K.<x> = FunctionField(QQ); R.<y> = K[];
sage: L.<alpha> = K.extension(x^2*y^5 - 1/x)
sage: g, d = L._make_monic(L.polynomial()); g,d
(y^5 - x^12, x^3)
sage: g(alpha*d)
0
"""
R = f.base_ring()
if not isinstance(R, RationalFunctionField):
raise NotImplementedError
# make f monic
n = f.degree()
c = f.leading_coefficient()
if c != 1:
f = f / c
# find lcm of denominators
from sage.rings.arith import lcm
# would be good to replace this by minimal...
d = lcm([b.denominator() for b in f.list() if b])
if d != 1:
x = f.parent().gen()
g = (d**n) * f(x/d)
else:
g = f
return g, d
def constant_field(self):
"""
Return the algebraic closure of the constant field of the base
field in this function field.
EXAMPLES::
sage: K.<x> = FunctionField(QQ); R.<y> = K[]
sage: L.<w> = K.extension(y^5 - (x^3 + 2*x*y + 1/x))
sage: L.constant_field()
Traceback (most recent call last):
...
NotImplementedError
"""
raise NotImplementedError
def constant_base_field(self):
"""
Return the constant field of the base rational function field.
EXAMPLES::
sage: K.<x> = FunctionField(QQ); R.<y> = K[]
sage: L.<w> = K.extension(y^5 - (x^3 + 2*x*y + 1/x)); L
Function field in w defined by y^5 - 2*x*y + (-x^4 - 1)/x
sage: L.constant_base_field()
Rational Field
"""
return self.base_field().constant_base_field()
def degree(self):
"""
Return the degree of this function field over its base
function field.
EXAMPLES::
sage: K.<x> = FunctionField(QQ)
sage: R.<y> = K[]
sage: L.<w> = K.extension(y^5 - (x^3 + 2*x*y + 1/x)); L
Function field in w defined by y^5 - 2*x*y + (-x^4 - 1)/x
sage: L.degree()
5
"""
return self._polynomial.degree()
def _repr_(self):
"""
Return string representation of this function field.
EXAMPLES::
sage: K.<x> = FunctionField(QQ); R.<y> = K[]
sage: L.<w> = K.extension(y^5 - (x^3 + 2*x*y + 1/x))
sage: L._repr_()
'Function field in w defined by y^5 - 2*x*y + (-x^4 - 1)/x'
"""
return "Function field in %s defined by %s"%(self.variable_name(), self._polynomial)
def base_field(self):
"""
Return the base field of this function field. This function
field is presented as L = K[y]/(f(y)), and the base field is
by definition the field K.
EXAMPLES::
sage: K.<x> = FunctionField(QQ); R.<y> = K[]
sage: L.<w> = K.extension(y^5 - (x^3 + 2*x*y + 1/x))
sage: L.base_field()
Rational function field in x over Rational Field
"""
return self._base_field
def random_element(self, *args, **kwds):
"""
Create a random element of this function field. Parameters
are passed onto the random_element method of the base_field.
EXAMPLES::
sage: K.<x> = FunctionField(QQ); R.<y> = K[]
sage: L.<w> = K.extension(y^2 - (x^2 + x))
sage: L.random_element()
((x^2 - x + 2/3)/(x^2 + 1/3*x - 1))*w^2 + ((-1/4*x^2 + 1/2*x - 1)/(-5/2*x + 2/3))*w + (-1/2*x^2 - 4)/(-12*x^2 + 1/2*x - 1/95)
"""
return self(self._ring.random_element(degree=self.degree(), *args, **kwds))
def polynomial(self):
"""
Return the univariate polynomial that defines this function
field, i.e., the polynomial f(y) so that this function field
is of the form K[y]/(f(y)).
EXAMPLES::
sage: K.<x> = FunctionField(QQ); R.<y> = K[]
sage: L.<w> = K.extension(y^5 - (x^3 + 2*x*y + 1/x))
sage: L.polynomial()
y^5 - 2*x*y + (-x^4 - 1)/x
"""
return self._polynomial
def polynomial_ring(self):
"""
Return the polynomial ring used to represents elements of this
function field. If we view this function field as being presented
as K[y]/(f(y)), then this function returns the ring K[y].
EXAMPLES::
sage: K.<x> = FunctionField(QQ); R.<y> = K[]
sage: L.<w> = K.extension(y^5 - (x^3 + 2*x*y + 1/x))
sage: L.polynomial_ring()
Univariate Polynomial Ring in y over Rational function field in x over Rational Field
"""
return self._ring
def vector_space(self):
"""
Return a vector space V and isomorphisms self --> V and V --> self.
This function allows us to identify the elements of self with
elements of a vector space over the base field, which is
useful for representation and arithmetic with orders, ideals,
etc.
OUTPUT:
- ``V`` - a vector space over the rational numbers
- ``from_V`` - an isomorphism from V to self
- ``to_V`` - an isomorphism from self to V
EXAMPLES::
We define a function field::
sage: K.<x> = FunctionField(QQ); R.<y> = K[]
sage: L.<w> = K.extension(y^5 - (x^3 + 2*x*y + 1/x)); L
Function field in w defined by y^5 - 2*x*y + (-x^4 - 1)/x
We get the vector spaces, and maps back and forth::
sage: V, from_V, to_V = L.vector_space()
sage: V
Vector space of dimension 5 over Rational function field in x over Rational Field
sage: from_V
Isomorphism map:
From: Vector space of dimension 5 over Rational function field in x over Rational Field
To: Function field in w defined by y^5 - 2*x*y + (-x^4 - 1)/x
sage: to_V
Isomorphism map:
From: Function field in w defined by y^5 - 2*x*y + (-x^4 - 1)/x
To: Vector space of dimension 5 over Rational function field in x over Rational Field
We convert an element of the vector space back to the function field::
sage: from_V(V.1)
w
We define an interesting element of the function field::
sage: a = 1/L.0; a
(-x/(-x^4 - 1))*w^4 + 2*x^2/(-x^4 - 1)
We convert it to the vector space, and get a vector over the base field::
sage: to_V(a)
(2*x^2/(-x^4 - 1), 0, 0, 0, -x/(-x^4 - 1))
We convert to and back, and get the same element::
sage: from_V(to_V(a)) == a
True
In the other direction::
sage: v = x*V.0 + (1/x)*V.1
sage: to_V(from_V(v)) == v
True
"""
try: return self._vector_space
except AttributeError:
V = self.base_field()**self.degree()
from_V = maps.MapVectorSpaceToFunctionField(V, self)
to_V = maps.MapFunctionFieldToVectorSpace(self, V)
self._vector_space = (V, from_V, to_V)
return self._vector_space
def maximal_order(self):
"""
Return the maximal_order of self. If we view self as L =
K[y]/(f(y)), then this is the ring of elements of L that are
integral over K.
EXAMPLES::
This is not yet implemented...::
sage: K.<x> = FunctionField(QQ); R.<y> = K[]
sage: L.<w> = K.extension(y^5 - (x^3 + 2*x*y + 1/x))
sage: L.maximal_order()
Traceback (most recent call last):
...
NotImplementedError
"""
raise NotImplementedError
def _element_constructor_(self, x):
r"""
Make x into an element of this function field, possibly not canonically.
INPUT:
- ``x`` - the element
OUTPUT:
``x``, as an element of this function field
TESTS::
sage: K.<x> = FunctionField(QQ); R.<y> = K[]
sage: L.<w> = K.extension(y^5 - (x^3 + 2*x*y + 1/x))
sage: L._element_constructor_(L.polynomial_ring().gen())
w
"""
if x.parent() is self._ring:
return function_field_element.FunctionFieldElement_polymod(self, x)
if isinstance(x, function_field_element.FunctionFieldElement):
return function_field_element.FunctionFieldElement_polymod(self, self._ring(x.element()))
return function_field_element.FunctionFieldElement_polymod(self, self._ring(x))
def gen(self, n=0):
"""
Return the n-th generator of this function field. By default n=0; any other
value of n leads to an error. The generator is the class of y, if we view
self as being presented as K[y]/(f(y)).
EXAMPLES::
sage: K.<x> = FunctionField(QQ); R.<y> = K[]
sage: L.<w> = K.extension(y^5 - (x^3 + 2*x*y + 1/x))
sage: L.gen()
w
sage: L.gen(1)
Traceback (most recent call last):
...
IndexError: Only one generator.
"""
if n != 0: raise IndexError, "Only one generator."
return self._gen
def ngens(self):
"""
Return the number of generators of this function field over
its base field. This is by definition 1.
EXAMPLES::
sage: K.<x> = FunctionField(QQ); R.<y> = K[]
sage: L.<w> = K.extension(y^5 - (x^3 + 2*x*y + 1/x))
sage: L.ngens()
1
"""
return 1
def equation_order(self):
"""
If we view self as being presented as K[y]/(f(y)), then this
function returns the order generated by the class of y. If f
is not monic, then self._make_monic is called, and instead we
get the order generated by some integral multiple of a root of
alpha.
EXAMPLES::
sage: K.<x> = FunctionField(QQ); R.<y> = K[]
sage: L.<w> = K.extension(y^5 - (x^3 + 2*x*y + 1/x))
sage: L.equation_order()
Order in Function field in w defined by y^5 - 2*x*y + (-x^4 - 1)/x
We try an example, in which the defining polynomial is not
monic and is not integral::
sage: K.<x> = FunctionField(QQ); R.<y> = K[]
sage: L.<alpha> = K.extension(x^2*y^5 - 1/x); L
Function field in alpha defined by x^2*y^5 - 1/x
sage: O = L.equation_order(); O
Order in Function field in alpha defined by x^2*y^5 - 1/x
sage: O.basis()
(1, x^3*alpha, x^6*alpha^2, x^9*alpha^3, x^12*alpha^4)
"""
d = self._make_monic(self.polynomial())[1]
return self.order(d*self.gen(), check=False)
class RationalFunctionField(FunctionField):
"""
A rational function field K(t) in one variable, over an arbitrary
base field.
EXAMPLES::
sage: K.<t> = FunctionField(GF(3)); K
Rational function field in t over Finite Field of size 3
sage: K.gen()
t
sage: 1/t + t^3 + 5
(t^4 + 2*t + 1)/t
There are various ways to get at the underlying fields and rings
associated to a rational function field::
sage: K.<t> = FunctionField(GF(7))
sage: K.base_field()
Rational function field in t over Finite Field of size 7
sage: K.field()
Fraction Field of Univariate Polynomial Ring in t over Finite Field of size 7
sage: K.constant_field()
Finite Field of size 7
sage: K.maximal_order()
Maximal order in Rational function field in t over Finite Field of size 7
We define a morphism::
sage: K.<W> = FunctionField(QQ)
sage: L = FunctionField(QQ, 'tbar') # give var name as second input
sage: K.hom(L.gen())
Morphism of function fields defined by W |--> tbar
"""
def __init__(self, constant_field, names, category=CAT):
"""
Create a rational function field in one variable.
INPUT:
- ``constant_field`` -- an arbitrary field
- ``names`` -- a string or tuple of length 1
- ``category`` -- default: FunctionFields()
EXAMPLES::
sage: K.<t> = FunctionField(CC); K
Rational function field in t over Complex Field with 53 bits of precision
sage: K.category()
Category of function fields
sage: FunctionField(QQ[I], 'alpha')
Rational function field in alpha over Number Field in I with defining polynomial x^2 + 1
Must be over a field::
sage: FunctionField(ZZ, 't')
Traceback (most recent call last):
...
TypeError: constant_field must be a field
"""
if names is None:
raise ValueError, "variable name must be specified"
elif not isinstance(names, tuple):
names = (names, )
if not constant_field.is_field():
raise TypeError, "constant_field must be a field"
ParentWithGens.__init__(self, self, names=names, category = category)
R = constant_field[names[0]]
self._hash = hash((constant_field, names))
self._constant_field = constant_field
self._ring = R
self._field = R.fraction_field()
self._populate_coercion_lists_(coerce_list=[self._field])
self._gen = self(R.gen())
def __hash__(self):
"""
Return hash of this function field.
EXAMPLES::
sage: K.<t> = FunctionField(QQ)
sage: hash(K)
502145503910697533 # 64-bit
? # 32-bit
"""
return self._hash
def _repr_(self):
"""
Return string representation of this function field.
EXAMPLES::
sage: K.<t> = FunctionField(QQ)
sage: K._repr_()
'Rational function field in t over Rational Field'
"""
return "Rational function field in %s over %s"%(
self.variable_name(), self._constant_field)
def _element_constructor_(self, x):
r"""
Coerce x into an element of this function field, possibly not canonically.
INPUT:
- ``x`` - the element
OUTPUT:
``x``, as an element of this function field
EXAMPLES::
sage: K.<t> = FunctionField(QQ)
sage: a = K._element_constructor_(K.maximal_order().gen()); a
t
sage: a.parent()
Rational function field in t over Rational Field
"""
if x.parent() is self._field:
return function_field_element.FunctionFieldElement_rational(self, x)
if isinstance(x, function_field_element.FunctionFieldElement):
return function_field_element.FunctionFieldElement_rational(self, self._field(x.element()))
if x.parent() is self.polynomial_ring():
return x[0]
return function_field_element.FunctionFieldElement_rational(self, self._field(x))
# nonoptimized
def _to_bivariate_polynomial(self, f):
"""
Convert f from a univariate polynomial over the rational function
field into a bivariate polynomial and a denominator.
INPUT:
- f -- a univariate polynomial over self.
OUTPUT:
- 2-variate polynomial, denominator
EXAMPLES::
sage: R.<t> = FunctionField(GF(7))
sage: S.<X> = R[]
sage: f = (1/t)*(X^4 - 1/t^2)*(X^3 - t^3)
sage: R._to_bivariate_polynomial(f)
(x^7*t^2 - x^4*t^5 - x^3 + t^3, t^3)
"""
v = f.list()
from sage.rings.arith import LCM
denom = LCM([a.denominator() for a in v])
S = denom.parent()
x,t = S.base_ring()['x,t'].gens()
phi = S.hom([t])
return sum([phi((denom * v[i]).numerator()) * x**i for i in range(len(v))]), denom
def _factor_univariate_polynomial(self, f, proof=True):
"""
Factor the univariate polynomial f over self.
EXAMPLES::
We do a factorization over the function field over the rationals::
sage: R.<t> = FunctionField(QQ)
sage: S.<X> = R[]
sage: f = (1/t)*(X^4 - 1/t^2)*(X^3 - t^3)
sage: f.factor() # indirect doctest
(1/t) * (X - t) * (X^2 - 1/t) * (X^2 + 1/t) * (X^2 + t*X + t^2)
sage: f.factor().prod() == f
True
You must pass in proof=False over finite fields, due to
Singular's factoring algorithm being incomplete::
sage: R.<t> = FunctionField(GF(7))
sage: S.<X> = R[]
sage: f = (1/t)*(X^4 - 1/t^2)*(X^3 - t^3)
sage: f.factor()
Traceback (most recent call last):
...
NotImplementedError: proof = True factorization not implemented. Call factor with proof=False.
sage: f.factor(proof=False)
(1/t) * (X + 3*t) * (X + 5*t) * (X + 6*t) * (X^2 + 1/t) * (X^2 + 6/t)
sage: f.factor(proof=False).prod() == f
True
Factoring over a function field over a non-prime finite field::
sage: k.<a> = GF(9)
sage: R.<t> = FunctionField(k)
sage: S.<X> = R[]
sage: f = (1/t)*(X^3 - a*t^3)
sage: f.factor(proof=False)
(1/t) * (X + (a + 2)*t)^3
sage: f.factor(proof=False).prod() == f
True
"""
F, d = self._to_bivariate_polynomial(f)
fac = F.factor(proof=proof)
x = f.parent().gen()
t = f.parent().base_ring().gen()
phi = F.parent().hom([x, t])
v = [(phi(P),e) for P, e in fac]
unit = phi(fac.unit())/d
w = []
for a, e in v:
c = a.leading_coefficient()
a = a/c
unit *= (c**e)
w.append((a,e))
from sage.structure.factorization import Factorization
return Factorization(w, unit=unit)
def polynomial_ring(self, var='x'):
"""
Return polynomial ring K[var] that could be used to represent
elements of self, if self were viewed as K[var]/(var).
EXAMPLES::
sage: K.<x> = FunctionField(QQ)
sage: K.polynomial_ring()
Univariate Polynomial Ring in x over Rational function field in x over Rational Field
sage: K.polynomial_ring('T')
Univariate Polynomial Ring in T over Rational function field in x over Rational Field
"""
if var != 'x': return self[var]
try: return self._polynomial_ring
except AttributeError:
self._polynomial_ring = self[var]
return self._polynomial_ring
def vector_space(self):
"""
Return a vector space V and isomorphisms self --> V and V --> self.
OUTPUT:
- ``V`` - a vector space over the rational numbers
- ``from_V`` - an isomorphism from V to self
- ``to_V`` - an isomorphism from self to V
EXAMPLES::
sage: K.<x> = FunctionField(QQ)
sage: K.vector_space()
(Vector space of dimension 1 over Rational function field in x over Rational Field, Isomorphism map:
From: Vector space of dimension 1 over Rational function field in x over Rational Field
To: Rational function field in x over Rational Field, Isomorphism map:
From: Rational function field in x over Rational Field
To: Vector space of dimension 1 over Rational function field in x over Rational Field)
"""
try: return self._vector_space
except AttributeError:
V = self.base_field()**1
from_V = maps.MapVectorSpaceToFunctionField(V, self)
to_V = maps.MapFunctionFieldToVectorSpace(self, V)
self._vector_space = (V, from_V, to_V)
return self._vector_space
def random_element(self, *args, **kwds):
"""
Create a random element of this rational function field.
Parameters are passed onto the random_element method of the
underlying fraction field.
EXAMPLES::
sage: FunctionField(QQ,'alpha').random_element()
(-1/2*alpha^2 - 4)/(-12*alpha^2 + 1/2*alpha - 1/95)
"""
return self(self._field.random_element(*args, **kwds))
def degree(self):
"""
Return the degree over the base field of this rational
function field, which is 1.
EXAMPLES::
sage: K.<t> = FunctionField(QQ)
sage: K.degree()
1
"""
return ZZ(1)
def gen(self, n=0):
"""
Return the n-th generator of this function field. If n is not
0, then an IndexError is raised.
EXAMPLES::
sage: K.<t> = FunctionField(QQ); K.gen()
t
sage: K.gen().parent()
Rational function field in t over Rational Field
sage: K.gen(1)
Traceback (most recent call last):
...
IndexError: Only one generator.
"""
if n != 0:
raise IndexError, "Only one generator."
return self._gen
def ngens(self):
"""
Return the number of generators, which is 1.
EXAMPLES::
sage: K.<t> = FunctionField(QQ)
sage: K.ngens()
1
"""
return 1
def base_field(self):
"""
Return the base field of this rational function field, which is just
this function field itself.
EXAMPLES::
sage: K.<t> = FunctionField(GF(7))
sage: K.base_field()
Rational function field in t over Finite Field of size 7
"""
return self
def hom(self, im_gens, base_morphism=None):
"""
Create a homomorphism from self to another function field.
INPUT:
- ``im_gens`` -- exactly one element of some function field
- ``base_morphism`` -- ignored
OUTPUT:
- a map between function fields
EXAMPLES::
We make a map from a rational function field to itself::
sage: R.<x> = FunctionField(GF(7))
sage: R.hom( (x^4 + 2)/x)
Morphism of function fields defined by x |--> (x^4 + 2)/x
We construct a map from a rational function field into a
non-rational extension field::
sage: R.<x> = FunctionField(GF(7)); S.<y> = R[]
sage: L.<y> = R.extension(y^3 + 6*x^3 + x)
sage: f = R.hom(y^2 + y + 2); f
Morphism of function fields defined by x |--> y^2 + y + 2
sage: f(x)
y^2 + y + 2
sage: f(x^2)
5*y^2 + (x^3 + 6*x + 4)*y + 2*x^3 + 5*x + 4
"""
if isinstance(im_gens, CategoryObject):
return self.Hom(im_gens).natural_map()
if not isinstance(im_gens, (list,tuple)):
im_gens = [im_gens]
if len(im_gens) != 1:
raise ValueError, "there must be exactly one generator"
x = im_gens[0]
return maps.FunctionFieldMorphism_rational(self.Hom(x.parent()), x)
def field(self):
"""
Return the underlying field, forgetting the function field
structure.
EXAMPLES::
sage: K.<t> = FunctionField(GF(7))
sage: K.field()
Fraction Field of Univariate Polynomial Ring in t over Finite Field of size 7
"""
return self._field
def maximal_order(self):
"""
Return the maximal order of this function field. Since this
is a rational function field it is of the form K(t), and the
maximal order is by definition K[t].
EXAMPLES::
sage: K.<t> = FunctionField(QQ)
sage: K.maximal_order()
Maximal order in Rational function field in t over Rational Field
sage: K.equation_order()
Maximal order in Rational function field in t over Rational Field
"""
try: return self._maximal_order
except AttributeError:
from function_field_order import FunctionFieldOrder_rational
self._maximal_order = FunctionFieldOrder_rational(self)
return self._maximal_order
equation_order = maximal_order
def constant_base_field(self):
"""
Return the field that this rational function field is a
transcendental extension of.
EXAMPLES::
sage: K.<t> = FunctionField(QQ)
sage: K.constant_field()
Rational Field
"""
return self._constant_field
constant_field = constant_base_field
| Python |
#################################################################################
#
# (c) Copyright 2010 William Stein
#
# This file is part of PSAGE
#
# PSAGE is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# PSAGE is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
#
#################################################################################
from function_field import is_FunctionField
from constructor import FunctionField
| Python |
#################################################################################
#
# (c) Copyright 2010 William Stein
#
# This file is part of PSAGE
#
# PSAGE is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# PSAGE is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
#
#################################################################################
r"""
Category of function fields
"""
from sage.categories.category import Category
from sage.misc.cachefunc import cached_method
from sage.categories.basic import Fields
from sage.rings.field import is_Field
class FunctionFields(Category):
r"""
The category of function fields.
EXAMPLES:
We create the category of function fields::
sage: C = FunctionFields()
sage: C
Category of function fields
TESTS::
sage: TestSuite(FunctionFields()).run()
"""
@cached_method
def super_categories(self):
"""
EXAMPLES::
sage: FunctionFields().super_categories()
[Category of fields]
"""
return[Fields()]
def __contains__(self, x):
r"""
Returns True if ``x`` is a function field.
EXAMPLES::
"""
import sage.rings.all
return sage.rings.all.is_FunctionField(x)
def _call_(self, x):
r"""
Constructs an object in this category from the data in ``x``,
or throws a TypeError.
EXAMPLES::
sage: C = FunctionFields()
"""
try:
return x.function_field()
except AttributeError:
raise TypeError, "unable to canonically associate a function field to %s"%x
class ParentMethods:
pass
class ElementMethods:
pass
| Python |
#################################################################################
#
# (c) Copyright 2010 William Stein
#
# This file is part of PSAGE
#
# PSAGE is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# PSAGE is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
#
#################################################################################
import function_field
def FunctionField(X, names=None):
"""
Return the function field defined by X.
INPUT:
- `X` -- a field; return the function field in one variable over X.
- ``names`` -- name of variable as a string
EXAMPLES::
sage: FunctionField(QQ,'alpha')
Rational function field in alpha over Rational Field
sage: K.<alpha> = FunctionField(GF(7)); K
Rational function field in alpha over Finite Field of size 7
"""
return function_field.RationalFunctionField(X, names=names)
| Python |
r"""
We provide methods to create Fourier expansions of (weak) Jacobi forms `\mathrm{mod} p`.
"""
#===============================================================================
#
# Copyright (C) 2010 Martin Raum
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 3
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, see <http://www.gnu.org/licenses/>.
#
#===============================================================================
from sage.misc.all import prod
from sage.rings.all import PowerSeriesRing, GF
from sage.rings.all import binomial, factorial
from sage.structure.sage_object import SageObject
import operator
#===============================================================================
# JacobiFormD1NNModularFactory_class
#===============================================================================
class JacobiFormD1NNModularFactory_class (SageObject) :
def __init__(self, precision, p) :
self.__precision = precision
self.__power_series_ring = PowerSeriesRing(GF(p), 'q')
self.__p = int(p)
def index(self) :
return self.__precision.jacobi_index()
def power_series_ring(self) :
return self.__power_series_ring
def _qexp_precision(self) :
return self.__precision.index()
def _set_theta_factors(self, theta_factors) :
self.__theta_factors = theta_factors
def _theta_factors(self) :
try :
return self.__theta_factors
except AttributeError :
raise RuntimeError( "Theta factors have to be set first" )
def _set_eta_factor(self, eta_factor) :
self.__eta_factor = eta_factor
def _eta_factor(self) :
try :
return self.__eta_factor
except AttributeError :
raise RuntimeError( "Eta factor have to be set first" )
def by_taylor_expansion(self, fs, k) :
"""
We combine the theta decomposition and the heat operator as in [Sko].
This yields a bijections of Jacobi forms of weight `k` and
`M_k \times S_{k+2} \times .. \times S_{k+2m}`.
NOTE:
To make ``phi_divs`` integral we introduce an extra factor
`2^{\mathrm{index}} * \mathrm{factorial}(k + 2 * \mathrm{index} - 1)`.
"""
## we introduce an abbreviations
p = self.__p
PS = self.power_series_ring()
if not len(fs) == self.__precision.jacobi_index() + 1 :
raise ValueError("fs must be a list of m + 1 elliptic modular forms or their fourier expansion")
qexp_prec = self._qexp_precision()
if qexp_prec is None : # there are no forms below the precision
return dict()
f_divs = dict()
for (i, f) in enumerate(fs) :
f_divs[(i, 0)] = PS(f(qexp_prec), qexp_prec)
for i in xrange(self.__precision.jacobi_index() + 1) :
for j in xrange(1, self.__precision.jacobi_index() - i + 1) :
f_divs[(i,j)] = f_divs[(i, j - 1)].derivative().shift(1)
phi_divs = list()
for i in xrange(self.__precision.jacobi_index() + 1) :
## This is the formula in Skoruppas thesis. He uses d/ d tau instead of d / dz which yields
## a factor 4 m
phi_divs.append( sum( f_divs[(j, i - j)] * (4 * self.__precision.jacobi_index())**i
* binomial(i,j) * ( 2**self.index() // 2**i)
* prod(2*(i - l) + 1 for l in xrange(1, i))
* (factorial(k + 2*self.index() - 1) // factorial(i + k + j - 1))
* factorial(2*self.__precision.jacobi_index() + k - 1)
for j in xrange(i + 1) ) )
phi_coeffs = dict()
for r in xrange(self.index() + 1) :
series = sum( map(operator.mul, self._theta_factors()[r], phi_divs) )
series = self._eta_factor() * series
for n in xrange(qexp_prec) :
phi_coeffs[(n, r)] = int(series[n].lift()) % p
return phi_coeffs
| Python |
r"""
Classes describing the Fourier expansion of Jacobi forms of degree `1`
with indices in `\mathbf{N}`.
AUTHOR :
- Martin Raum (2010 - 04 - 04) Initial version
"""
#===============================================================================
#
# Copyright (C) 2010 Martin Raum
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 3
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, see <http://www.gnu.org/licenses/>.
#
#===============================================================================
## even weight
## c(n, r) = c(n', r') <=> r' \equiv \pm r (2m) and r'**2 - 4 n' m = r**2 - 4 n m
from operator import xor
from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import TrivialCharacterMonoid,\
TrivialRepresentation
from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_module import EquivariantMonoidPowerSeriesModule
from psage.modform.jacobiforms.jacobiformd1nn_fourierexpansion_cython import creduce, \
mult_coeff_int, mult_coeff_int_weak, \
mult_coeff_generic, mult_coeff_generic_weak
from sage.matrix.constructor import matrix
from sage.misc.cachefunc import cached_method, cached_function
from sage.misc.functional import isqrt
from sage.misc.latex import latex
from sage.rings.infinity import infinity
from sage.rings.integer import Integer
from sage.rings.integer_ring import ZZ
from sage.rings.rational_field import QQ
from sage.structure.sage_object import SageObject
import itertools
import operator
#===============================================================================
# JacobiFormD1NNIndices
#===============================================================================
class JacobiFormD1NNIndices ( SageObject ) :
def __init__(self, m, reduced = True, weak_forms = False) :
r"""
INPUT:
- `m` -- The index of the associated Jacobi forms.
- ``reduced`` -- If True the reduction of Fourier indices
with respect to the full Jacobi group
will be considered. Otherwise, only the
restriction `r**2 =< 4 n m` or `r**2 =< 4 m n + m**2`
will be considered.
- ``weak_forms`` -- If True the weak condition
`r**2 =< 4 m n` will be imposed on the
indices.
NOTE:
The Fourier expansion of a form is assumed to be indexed
`\sum c(n,r) z^n \zeta^r` . The indices are pairs `(n, r)`.
"""
self.__m = m
self.__reduced = reduced
self.__weak_forms = weak_forms
def ngens(self) :
return len(self.gens())
def gen(self, i = 0) :
if i < self.ngens() :
return self.gens()[i]
raise ValueError("There is no generator %s" % (i,))
@cached_method
def gens(self) :
# FIXME: This is incorrect for almost all indices m
return [(1,0), (1,1)]
def jacobi_index(self) :
return self.__m
def is_commutative(self) :
return True
def monoid(self) :
return JacobiFormD1NNIndices(self.__m, False, self.__weak_forms)
def group(self) :
r"""
These are the invertible, integral lower triogonal matrices
with bottom right entry `1`.
"""
return "L^1_2(ZZ)"
def is_monoid_action(self) :
r"""
True if the representation respects the monoid structure.
"""
return False
def filter(self, bound) :
return JacobiFormD1NNFilter(bound, self.__m, self.__reduced, self.__weak_forms)
def filter_all(self) :
return JacobiFormD1NNFilter(infinity, self.__m, self.__reduced, self.__weak_forms)
def minimal_composition_filter(self, ls, rs) :
return JacobiFormD1NNFilter( min([k[0] for k in ls])
+ min([k[0] for k in rs]),
self.__reduced, self.__weak_forms )
def _reduction_function(self) :
return lambda k: creduce(k, self.__m)
def reduce(self, s) :
return creduce(s, self.__m)
def decompositions(self, s) :
(n, r) = s
fm = 4 * self.__m
if self.__weak_forms :
yield ((0,0), (n,r))
yield ((n,r), (0,0))
msq = self.__m**2
for n1 in xrange(1, n) :
n2 = n - n1
for r1 in xrange( max(r - isqrt(fm * n2 + msq),
isqrt(fm * n1 + msq - 1) + 1),
min( r + isqrt(fm * n2 + msq) + 1,
isqrt(fm * n1 + msq) + 1 ) ) :
yield ((n1, r1), (n2, r - r1))
else :
yield ((0,0), (n,r))
yield ((n,r), (0,0))
for n1 in xrange(1, n) :
n2 = n - n1
##r = r1 + r2
##r1**2 <= 4 n1 m
## (r - r1)**2 <= 4 n2 m
## r1**2 - 2*r1*r + r**2 - 4 m n2 <= 0
## r1 <-> r \pm \sqrt{r**2 - r**2 + 4 m n2}
for r1 in xrange( max(r - isqrt(fm * n2),
isqrt(fm * n1 - 1) + 1),
min( r + isqrt(fm * n2) + 1,
isqrt(fm * n1) + 1 ) ) :
yield ((n1, r1), (n2, r - r1))
raise StopIteration
def zero_element(self) :
return (0,0)
def __contains__(self, k) :
try :
(n, r) = k
except TypeError:
return False
return isinstance(n, (int, Integer)) and isinstance(r, (int,Integer))
def __cmp__(self, other) :
c = cmp(type(self), type(other))
if c == 0 :
c = cmp(self.__reduced, other.__reduced)
if c == 0 :
c = cmp(self.__weak_forms, other.__weak_forms)
if c == 0 :
c = cmp(self.__m, other.__m)
return c
def __hash__(self) :
return reduce(xor, [hash(self.__m), hash(self.__reduced),
hash(self.__weak_forms)])
def _repr_(self) :
return "Jacobi Fourier indices for index %s forms" % (self.__m,)
def _latex_(self) :
return r"\text{Jacobi Fourier indices for index $%s$ forms}" % (latex(self.__m),)
#===============================================================================
# JacobiFormD1NNFilter
#===============================================================================
class JacobiFormD1NNFilter ( SageObject ) :
r"""
The filter which will consider the index `n` in the normal
notation `\sum c(n,r) z^n \zeta^r`.
"""
def __init__(self, bound, m, reduced = True, weak_forms = False) :
r"""
INPUT:
- ``bound`` -- A natural number or exceptionally
infinity reflection the bound for n.
- `m` -- The index of the associated Jacobi forms.
- ``reduced`` -- If True the reduction of Fourier indices
with respect to the full Jacobi group
will be considered. Otherwise, only the
restriction `r**2 \le 4 n m` or `r**2 \le 4 m n + m^2`
will be considered.
- ``weak_forms`` -- If True the weak condition
`r**2 \le 4 m n` will be imposed on the
indices.
NOTE:
The Fourier expansion of a form is assumed to be indexed
`\sum c(n,r) z^n \zeta^r` . The indices are pairs `(n, r)`.
"""
self.__m = m
if isinstance(bound, JacobiFormD1NNFilter) :
bound = bound.index()
self.__bound = bound
self.__reduced = reduced
self.__weak_forms = weak_forms
def jacobi_index(self) :
return self.__m
def is_reduced(self) :
return self.__reduced
def is_weak_filter(self) :
"""
Return whether this is a filter for weak Jacobi forms or not.
"""
return self.__weak_jacobi_forms
def filter_all(self) :
return JacobiFormD1NNFilter(infinity, self.__m, self.__reduced, self.__weak_forms)
def zero_filter(self) :
return JacobiFormD1NNFilter(0, self.__m, self.__reduced, self.__weak_forms)
def is_infinite(self) :
return self.__bound is infinity
def is_all(self) :
return self.is_infinite()
def index(self) :
return self.__bound
def __contains__(self, k) :
m = self.__m
if ( k[1]**2 > 4 * m * k[0] + m**2
if self.__weak_forms
else k[1]**2 > 4 * m * k[0] ) :
return False
if k[0] < self.__bound :
return True
elif self.__reduced :
return creduce(k, m)[0][0] < self.__bound
return False
def __iter__(self) :
return itertools.chain(self.iter_indefinite_forms(),
self.iter_positive_forms())
def iter_positive_forms(self) :
fm = 4 * self.__m
if self.__reduced :
if self.__weak_forms :
msq = self.__m**2
for n in xrange(1, self.__bound) :
for r in xrange(min(self.__m + 1, isqrt(fm * n + msq - 1) + 1)) :
yield (n, r)
else :
for n in xrange(1, self.__bound) :
for r in xrange(min(self.__m + 1, isqrt(fm * n - 1) + 1)) :
yield (n, r)
else :
if self.__weak_forms :
msq = self.__m**2
for n in xrange(1, self.__bound) :
for r in xrange(isqrt(fm * n + msq - 1) + 1) :
yield (n, r)
else :
for n in xrange(1, self.__bound) :
for r in xrange(isqrt(fm * n - 1) + 1) :
yield (n, r)
raise StopIteration
def iter_indefinite_forms(self) :
fm = Integer(4 * self.__m)
if self.__reduced :
if self.__weak_forms :
msq = self.__m**2
for n in xrange(0, min(self.__m // 4 + 1, self.__bound)) :
for r in xrange( isqrt(fm * n - 1) + 1 if n != 0 else 0,
isqrt(fm * n + msq + 1) ) :
yield (n, r)
else :
for r in xrange(0, min(self.__m + 1,
isqrt((self.__bound - 1) * fm) + 1) ) :
if fm.divides(r**2) :
yield (r**2 // fm, r)
else :
if self.__weak_forms :
msq = self.__m**2
for n in xrange(0, self.__bound) :
for r in xrange( isqrt(fm * n - 1) + 1 if n != 0 else 0,
isqrt(fm * n + msq + 1) ) :
yield (n, r)
else :
for n in xrange(0, self.__bound) :
if (fm * n).is_square() :
yield(n, isqrt(fm * n))
raise StopIteration
def __cmp__(self, other) :
c = cmp(type(self), type(other))
if c == 0 :
c = cmp(self.__reduced, other.__reduced)
if c == 0 :
c = cmp(self.__weak_forms, other.__weak_forms)
if c == 0 :
c = cmp(self.__m, other.__m)
if c == 0 :
c = cmp(self.__bound, other.__bound)
return c
def __hash__(self) :
return reduce( xor, map(hash, [ self.__reduced, self.__weak_forms,
self.__m, self.__bound ]) )
def _repr_(self) :
return "Jacobi precision %s" % (self.__bound,)
def _latex_(self) :
return r"\text{Jacobi precision $%s$}" % (latex(self.__bound),)
#===============================================================================
# JacobiD1NNFourierExpansionModule
#===============================================================================
def JacobiD1NNFourierExpansionModule(K, m, weak_forms = False) :
r"""
INPUT:
- `m` -- The index of the associated Jacobi forms.
- `weak_forms` -- If True the weak condition
`r^2 \le 4 m n`n will be imposed on the
indices.
"""
R = EquivariantMonoidPowerSeriesModule(
JacobiFormD1NNIndices(m, weak_forms = weak_forms),
TrivialCharacterMonoid("L^1_2(ZZ)", ZZ),
TrivialRepresentation("L^1_2(ZZ)", K) )
if K is ZZ :
R._set_multiply_function( lambda k, d1,d2, ch1,ch2, res : mult_coeff_int(k, d1, d2, ch1, ch2, res, m)
if not weak_forms
else lambda k, d1,d2, ch1,ch2, res : mult_coeff_int_weak(k, d1, d2, ch1, ch2, res, m) )
else :
R._set_multiply_function( lambda k, d1,d2, ch1,ch2, res : mult_coeff_generic(k, d1, d2, ch1, ch2, res, m)
if not weak_forms
else lambda k, d1,d2, ch1,ch2, res : mult_coeff_generic_weak(k, d1, d2, ch1, ch2, res, m) )
return R
| Python |
"""
Types of Jacobi forms of fixed index and weight.
AUTHOR :
- Martin Raum (2010 - 04 - 07) Initial version.
"""
#===============================================================================
#
# Copyright (C) 2010 Martin Raum
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 3
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, see <http://www.gnu.org/licenses/>.
#
#===============================================================================
from operator import xor
from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import TrivialGrading
from psage.modform.fourier_expansion_framework.modularforms.modularform_ambient import ModularFormsModule_generic
from psage.modform.fourier_expansion_framework.modularforms.modularform_types import ModularFormType_abstract
from psage.modform.jacobiforms.jacobiformd1nn_fegenerators import jacobi_form_by_taylor_expansion,\
_jacobi_forms_by_taylor_expansion_coords
from psage.modform.jacobiforms.jacobiformd1nn_fourierexpansion import JacobiD1NNFourierExpansionModule, \
JacobiFormD1NNFilter
from sage.categories.number_fields import NumberFields
from sage.matrix.constructor import diagonal_matrix, matrix, zero_matrix,\
identity_matrix
from sage.misc.cachefunc import cached_method
from sage.misc.mrange import mrange
from sage.modular.modform.constructor import ModularForms
from sage.rings.all import Integer
from sage.rings.integer_ring import ZZ
from sage.rings.number_field.number_field import CyclotomicField
from sage.rings.polynomial.polynomial_ring_constructor import PolynomialRing
from sage.rings.rational_field import QQ
from sage.structure.sequence import Sequence
#===============================================================================
# JacobiFormsD1NN
#===============================================================================
_jacobiforms_cache = dict()
def JacobiFormsD1NN(A, type, precision, *args, **kwds) :
global _jacobiforms_cache
if isinstance(precision, (int, Integer)) :
precision = JacobiFormD1NNFilter(precision, type.index())
k = (A, type, precision)
try :
return _jacobiforms_cache[k]
except KeyError :
if isinstance(type, JacobiFormD1NN_Gamma) :
M = ModularFormsModule_generic(A, type, precision)
else :
raise TypeError, "%s must be a Jacobi form type" % (type,)
_jacobiforms_cache[k] = M
return M
#===============================================================================
# JacobiFormD1NN_Gamma
#===============================================================================
class JacobiFormD1NN_Gamma ( ModularFormType_abstract ) :
r"""
Type of Jacobi forms of degree `1` and index in `\mathbb{N}` associated with
the full modular group.
TESTS::
sage: from psage.modform.jacobiforms import *
sage: from psage.modform.jacobiforms.jacobiformd1nn_fourierexpansion import JacobiFormD1NNFilter
sage: JR = JacobiFormsD1NN(QQ, JacobiFormD1NN_Gamma(3, 6), JacobiFormD1NNFilter(10, 3))
sage: JR.gens()
(Graded expansion TDE_0, Graded expansion TDE_1)
sage: JR.0 + 2 * JR.1
Graded expansion TDE_0 + 2*TDE_1
"""
def __init__(self, index, weight) :
if weight % 2 != 0 :
raise NotImplementedError, "Only even weight forms are implemented."
self.__index = index
self.__weight = weight
def index(self) :
return self.__index
def weight(self) :
return self.__weight
def _ambient_construction_function(self) :
return JacobiFormsD1NN
def group(self) :
return "Sp(2, ZZ)_\infty"
@cached_method
def _rank(self, K) :
if K is QQ or K in NumberFields() :
return len(_jacobi_forms_by_taylor_expansion_coords(self.__index, self.__weight, 0))
## This is the formula used by Poor and Yuen in Paramodular cusp forms
if self.__weight == 2 :
delta = len(self.__index.divisors()) // 2 - 1
else :
delta = 0
return sum( ModularForms(1, self.__weight + 2 * j).dimension() + j**2 // (4 * self.__index)
for j in xrange(self.__index + 1) ) \
+ delta
## This is the formula given by Skoruppa in
## Jacobi forms of critical weight and Weil representations
##FIXME: There is some mistake here
if self.__weight % 2 != 0 :
## Otherwise the space X(i**(n - 2 k)) is different
## See: Skoruppa, Jacobi forms of critical weight and Weil representations
raise NotImplementedError
m = self.__index
K = CyclotomicField(24 * m, 'zeta')
zeta = K.gen(0)
quadform = lambda x : 6 * x**2
bilinform = lambda x,y : quadform(x + y) - quadform(x) - quadform(y)
T = diagonal_matrix([zeta**quadform(i) for i in xrange(2*m)])
S = sum(zeta**(-quadform(x)) for x in xrange(2 * m)) / (2 * m) \
* matrix([[zeta**(-bilinform(j,i)) for j in xrange(2*m)] for i in xrange(2*m)])
subspace_matrix_1 = matrix( [ [1 if j == i or j == 2*m - i else 0 for j in xrange(m + 1) ]
for i in xrange(2*m)] )
subspace_matrix_2 = zero_matrix(ZZ, m + 1, 2*m)
subspace_matrix_2.set_block(0,0,identity_matrix(m+1))
T = subspace_matrix_2 * T * subspace_matrix_1
S = subspace_matrix_2 * S * subspace_matrix_1
sqrt3 = (zeta**(4*m) - zeta**(-4*m)) * zeta**(-6*m)
rank = (self.__weight - 1/2 - 1) / 2 * (m + 1) \
+ 1/8 * ( zeta**(3*m * (2*self.__weight - 1)) * S.trace()
+ zeta**(3*m * (1 - 2*self.__weight)) * S.trace().conjugate() ) \
+ 2/(3*sqrt3) * ( zeta**(4 * m * self.__weight) * (S*T).trace()
+ zeta**(-4 * m * self.__weight) * (S*T).trace().conjugate() ) \
- sum((j**2 % (m+1))/(m+1) -1/2 for j in range(0,m+1))
if self.__weight > 5 / 2 :
return rank
else :
raise NotImplementedError
raise NotImplementedError
@cached_method
def generators(self, K, precision) :
if K is QQ or K in NumberFields() :
return Sequence( [ jacobi_form_by_taylor_expansion(i, self.__index, self.__weight, precision)
for i in xrange(self._rank(K)) ],
universe = JacobiD1NNFourierExpansionModule(QQ, self.__index) )
raise NotImplementedError
def grading(self, K) :
if K is QQ or K in NumberFields() :
return TrivialGrading( self._rank(K),
(self.__index, self.__weight) )
raise NotImplementedError
def _generator_names(self, K) :
if K is QQ or K in NumberFields() :
return [ "TDE_%s" % (i,) for i in xrange(self._rank(K)) ]
raise NotImplementedError
def _generator_by_name(self, K, name) :
if K is QQ or K in NumberFields() :
R = self.generator_relations(K).ring()
try :
return R.gen(self._generator_names(K).index(name))
except ValueError :
raise ValueError, "name %s doesn't exist for %s" % (name, K)
raise NotImplementedError
@cached_method
def generator_relations(self, K) :
r"""
An ideal I in a polynomial ring R, such that the associated module
is (R / I)_1.
"""
if K is QQ or K in NumberFields() :
R = PolynomialRing(K, self._generator_names(K))
return R.ideal(0)
raise NotImplementedError
def weights(self, K) :
r"""
A list of integers corresponding to the weights.
"""
if K is QQ or K in NumberFields() :
return len(self._theta_decomposition_indices()) \
* [(self.__index, self.__weight)]
raise NotImplementedError
def graded_submodules_are_free(self) :
return True
def __cmp__(self, other) :
c = cmp(type(self), type(other))
if c == 0 :
c = cmp(self.__index, other.__index)
if c == 0 :
c = cmp(self.__weight, other.__weight)
return c
def __hash__(self) :
return reduce(xor, map(hash, [type(self), self.__index, self.__weight]))
| Python |
from jacobiformd1nn_types import JacobiFormsD1NN, JacobiFormD1NN_Gamma | Python |
"""
We provide methods to create Fourier expansions of (weak) Jacobi forms.
"""
#===============================================================================
#
# Copyright (C) 2010 Martin Raum
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 3
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, see <http://www.gnu.org/licenses/>.
#
#===============================================================================
from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_lazyelement import \
EquivariantMonoidPowerSeries_lazy
from psage.modform.jacobiforms.jacobiformd1nn_fourierexpansion import JacobiD1NNFourierExpansionModule
from psage.modform.jacobiforms.jacobiformd1nn_fourierexpansion import JacobiFormD1NNFilter
from sage.combinat.partition import number_of_partitions
from sage.libs.flint.fmpz_poly import Fmpz_poly
from sage.matrix.constructor import matrix
from sage.misc.cachefunc import cached_function
from sage.misc.functional import isqrt
from sage.misc.misc import prod
from sage.modular.modform.constructor import ModularForms
from sage.modular.modform.element import ModularFormElement
from sage.modules.free_module_element import vector
from sage.rings.all import GF
from sage.rings.arith import binomial, factorial
from sage.rings.integer import Integer
from sage.rings.integer_ring import ZZ
from sage.rings.polynomial.polynomial_ring_constructor import PolynomialRing
from sage.rings.power_series_ring import PowerSeriesRing
from sage.rings.rational_field import QQ
from sage.structure.sage_object import SageObject
import operator
#===============================================================================
# _jacobi_forms_by_taylor_expansion_coords
#===============================================================================
_jacobi_forms_by_taylor_expansion_coords_cache = dict()
def _jacobi_forms_by_taylor_expansion_coords(index, weight, precision) :
global _jacobi_forms_by_taylor_expansion_coords_cache
key = (index, weight)
try :
return _jacobi_forms_by_taylor_expansion_coords_cache[key]
except KeyError :
if precision < (index - 1) // 4 + 1 :
precision = (index - 1) // 4 + 1
weak_forms = _all_weak_jacobi_forms_by_taylor_expansion(index, weight, precision)
weak_index_matrix = matrix(ZZ, [ [ f[(n,r)] for n in xrange((index - 1) // 4 + 1)
for r in xrange(isqrt(4 * n * index) + 1, index + 1) ]
for f in weak_forms] )
_jacobi_forms_by_taylor_expansion_coords_cache[key] = \
weak_index_matrix.left_kernel().echelonized_basis()
return _jacobi_forms_by_taylor_expansion_coords_cache[key]
#===============================================================================
# jacobi_forms_by_taylor_expansion
#===============================================================================
def jacobi_form_by_taylor_expansion(i, index, weight, precision) :
r"""
We first lift an echelon basis of elliptic modular forms to weak Jacobi forms.
Then we return an echelon basis with respect enumeration of this first echelon
basis of the '\ZZ'-submodule of Jacobi forms.
"""
expansion_ring = JacobiD1NNFourierExpansionModule(ZZ, index)
coefficients_factory = DelayedFactory_JacobiFormD1NN_taylor_expansion( i, index, weight, precision )
return EquivariantMonoidPowerSeries_lazy(expansion_ring, precision, coefficients_factory.getcoeff)
#===============================================================================
# DelayedFactory_JacobiFormD1NN_taylor_expansion
#===============================================================================
class DelayedFactory_JacobiFormD1NN_taylor_expansion :
def __init__(self, i, index, weight, precision) :
self.__i = i
self.__index = index
self.__precision = precision
self.__weight = weight
self.__series = None
def getcoeff(self, key, **kwds) :
(_, k) = key
# for speed we ignore the character
if self.__series is None :
self.__series = \
sum( map( operator.mul,
_jacobi_forms_by_taylor_expansion_coords(self.__index, self.__weight, self.__precision)[self.__i],
_all_weak_jacobi_forms_by_taylor_expansion(self.__index, self.__weight, self.__precision) ) )
try :
return self.__series[k]
except KeyError :
return 0
#===============================================================================
# _theta_decomposition_indices
#===============================================================================
@cached_function
def _theta_decomposition_indices(index, weight) :
r"""
A list of possible indices of the echelon bases `M_k, S_{k+2}` etc. or `-1`
if a component is zero."
"""
dims = [ ModularForms(1, weight).dimension()] + \
[ ModularForms(1, weight + 2*i).dimension() - 1
for i in xrange(1, index + 1) ]
return [ (i,j) for (i,d) in enumerate(dims) for j in xrange(d)]
#===============================================================================
# _all_weak_jacobi_forms_by_taylor_expansion
#===============================================================================
@cached_function
def _all_weak_jacobi_forms_by_taylor_expansion(index, weight, precision) :
"""
TESTS:
We compute the Fourier expansion of a Jacobi form of weight `4` and index `2`. This
is denoted by ``d``. Moreover, we span the space of all Jacobi forms of weight `8` and
index `2`. Multiplying the weight `4` by the Eisenstein series of weight `4` must
yield an element of the weight `8` space. Note that the multiplication is done using
a polynomial ring, since no native multiplication for Jacobi forms is implemented.
::
sage: from psage.modform.jacobiforms.jacobiformd1nn_fourierexpansion import *
sage: from psage.modform.jacobiforms.jacobiformd1nn_fegenerators import _all_weak_jacobi_forms_by_taylor_expansion
sage: from psage.modform.fourier_expansion_framework import *
sage: prec = 20
sage: d = JacobiFormD1NNFilter(prec, 2)
sage: f = _all_weak_jacobi_forms_by_taylor_expansion(2, 4, prec)[0]
sage: (g1,g2) = tuple(_all_weak_jacobi_forms_by_taylor_expansion(2, 8, prec))
sage: em = ExpansionModule([g1, g2])
sage: P.<q, zeta> = PolynomialRing(QQ, 2)
sage: fp = sum(f[k] * q**k[0] * zeta**k[1] for k in JacobiFormD1NNFilter(prec, 2, reduced = False))
sage: mf4 = ModularForms(1, 4).0.qexp(prec).polynomial()
sage: h = mf4 * fp
sage: eh = EquivariantMonoidPowerSeries(g1.parent(), {g1.parent().characters().gen(0) : dict((k, h[k[0],k[1]]) for k in d)}, d)
sage: em.coordinates(eh.truncate(5), in_base_ring = False)
[7/66, 4480]
According to this we express ``eh`` in terms of the basis of the weight `8` space.
::
sage: neh = eh - em.0.fourier_expansion() * 7 / 66 - em.1.fourier_expansion() * 4480
sage: neh.coefficients()
{(18, 0): 0, (12, 1): 0, (9, 1): 0, (3, 0): 0, (11, 2): 0, (8, 0): 0, (16, 2): 0, (2, 1): 0, (15, 1): 0, (6, 2): 0, (14, 0): 0, (19, 0): 0, (5, 1): 0, (7, 2): 0, (4, 0): 0, (1, 2): 0, (12, 2): 0, (9, 0): 0, (8, 1): 0, (18, 2): 0, (15, 0): 0, (17, 2): 0, (14, 1): 0, (11, 1): 0, (18, 1): 0, (5, 0): 0, (2, 2): 0, (10, 0): 0, (4, 1): 0, (1, 1): 0, (3, 2): 0, (0, 0): 0, (13, 2): 0, (8, 2): 0, (7, 1): 0, (6, 0): 0, (17, 1): 0, (11, 0): 0, (19, 2): 0, (16, 0): 0, (10, 1): 0, (4, 2): 0, (1, 0): 0, (14, 2): 0, (0, 1): 0, (13, 1): 0, (7, 0): 0, (15, 2): 0, (12, 0): 0, (9, 2): 0, (6, 1): 0, (3, 1): 0, (16, 1): 0, (2, 0): 0, (19, 1): 0, (5, 2): 0, (17, 0): 0, (13, 0): 0, (10, 2): 0}
"""
modular_form_bases = \
[ ModularForms(1, weight + 2*i) \
.echelon_basis()[(0 if i == 0 else 1):]
for i in xrange(index + 1) ]
factory = JacobiFormD1NNFactory(precision, index)
return [ weak_jacbi_form_by_taylor_expansion(
i*[0] + [modular_form_bases[i][j]] + (index - i)*[0],
precision, True, weight = weight,
factory = factory )
for (i,j) in _theta_decomposition_indices(index, weight) ]
#===============================================================================
# weak_jacbi_form_by_taylor_expansion
#===============================================================================
def weak_jacbi_form_by_taylor_expansion(fs, precision, is_integral = False, weight = None, factory = None) :
if factory is None :
factory = JacobiFormD1NNFactory(precision, len(fs) - 1)
if is_integral :
expansion_ring = JacobiD1NNFourierExpansionModule(ZZ, len(fs) - 1, True)
else :
expansion_ring = JacobiD1NNFourierExpansionModule(QQ, len(fs) - 1, True)
f_exps = list()
for (i,f) in enumerate(fs) :
if f == 0 :
f_exps.append(lambda p : 0)
elif isinstance(f, ModularFormElement) :
f_exps.append(f.qexp)
if weight is None :
weight = f.weight() - 2 * i
else :
if not weight == f.weight() - 2 * i :
ValueError("Weight of the i-th form must be k + 2*i.")
if i != 0 and not f.is_cuspidal() :
ValueError("All but the first form must be cusp forms.")
else :
f_exps.append(f)
if weight is None :
raise ValueError("Either one element of fs must be a modular form or " + \
"the weight must be passed.")
coefficients_factory = DelayedFactory_JacobiFormD1NN_taylor_expansion_weak( factory, f_exps, weight )
return EquivariantMonoidPowerSeries_lazy(expansion_ring, expansion_ring.monoid().filter(precision), coefficients_factory.getcoeff)
#===============================================================================
# DelayedFactory_JacobiFormD1NN_taylor_expansion
#===============================================================================
class DelayedFactory_JacobiFormD1NN_taylor_expansion_weak :
def __init__(self, factory, fs, weight) :
self.__factory = factory
self.__fs = fs
self.__weight = weight
self.__series = None
def getcoeff(self, key, **kwds) :
(_, k) = key
# for speed we ignore the character
if self.__series is None :
self.__series = \
self.__factory.by_taylor_expansion( self.__fs, self.__weight,
is_integral = True )
try :
return self.__series[k]
except KeyError :
return 0
#===============================================================================
# JacobiFormD1NNFactory
#===============================================================================
_jacobi_form_d1nn_factory_cache = dict()
def JacobiFormD1NNFactory(precision, m=None) :
if not isinstance(precision, JacobiFormD1NNFilter) :
if m is None :
raise ValueError("if precision is not filter the index m must be passed.")
precision = JacobiFormD1NNFilter(precision, m)
global _jacobi_form_d1nn_factory_cache
try :
return _jacobi_form_d1nn_factory_cache[precision]
except KeyError :
tmp = JacobiFormD1NNFactory_class(precision)
_jacobi_form_d1nn_factory_cache[precision] = tmp
return tmp
#===============================================================================
# JacobiFormD1NNFactory_class
#===============================================================================
class JacobiFormD1NNFactory_class (SageObject) :
def __init__(self, precision) :
self.__precision = precision
self.__power_series_ring_ZZ = PowerSeriesRing(ZZ, 'q')
self.__power_series_ring = PowerSeriesRing(QQ, 'q')
def index(self) :
return self.__precision.jacobi_index()
def power_series_ring(self) :
return self.__power_series_ring
def integral_power_series_ring(self) :
return self.__power_series_ring_ZZ
def _qexp_precision(self) :
return self.__precision.index()
def _set_theta_factors(self, theta_factors) :
self.__theta_factors = theta_factors
def _theta_factors(self, p = None) :
r"""
Return the factor `W^\# (\theta_0, .., \theta_{2m - 1})^{\mathrm{T}}` as a list.
The `q`-expansion is shifted by `-(m + 1)(2*m + 1) / 24` which will be compensated
for by the eta factor.
"""
try :
if p is None :
return self.__theta_factors
else :
P = PowerSeriesRing(GF(p), 'q')
return [map(P, facs) for facs in self.__theta_factors]
except AttributeError :
qexp_prec = self._qexp_precision()
if p is None :
PS = self.integral_power_series_ring()
else :
PS = PowerSeriesRing(GF(p), 'q')
m = self.__precision.jacobi_index()
twom = 2 * m
frmsq = twom ** 2
thetas = dict( ((i, j), dict())
for i in xrange(m + 1) for j in xrange(m + 1) )
## We want to calculate \hat \theta_{j,l} = sum_r (2 m r + j)**2l q**(m r**2 + j r).
for r in xrange(0, isqrt((qexp_prec - 1 + m)//m) + 2) :
for j in [0,m] :
fact = (twom*r + j)**2
coeff = 2
for l in xrange(0, m + 1) :
thetas[(j,l)][m*r**2 + r*j] = coeff
coeff = coeff * fact
thetas[(0,0)][0] = 1
for r in xrange(0, isqrt((qexp_prec - 1 + m)//m) + 2) :
for j in xrange(1, m) :
fact_p = (twom*r + j)**2
fact_m = (twom*r - j)**2
coeff_p = 2
coeff_m = 2
for l in xrange(0, m + 1) :
thetas[(j,l)][m*r**2 + r*j] = coeff_p
thetas[(j,l)][m*r**2 - r*j] = coeff_m
coeff_p = coeff_p * fact_p
coeff_m = coeff_m * fact_m
thetas = dict( ( k, PS(th).add_bigoh(qexp_prec) )
for (k,th) in thetas.iteritems() )
W = matrix(PS, m + 1, [ thetas[(j, l)]
for j in xrange(m + 1) for l in xrange(m + 1) ])
## Since the adjoint of matrices with entries in a general ring
## is extremely slow for matrices of small size, we hard code the
## the cases `m = 2` and `m = 3`. The expressions are obtained by
## computing the adjoint of a matrix with entries `w_{i,j}` in a
## polynomial algebra.
if m == 2 and qexp_prec > 10**5 :
adj00 = W[1,1] * W[2,2] - W[2,1] * W[1,2]
adj01 = - W[1,0] * W[2,2] + W[2,0] * W[1,2]
adj02 = W[1,0] * W[2,1] - W[2,0] * W[1,1]
adj10 = - W[0,1] * W[2,2] + W[2,1] * W[0,2]
adj11 = W[0,0] * W[2,2] - W[2,0] * W[0,2]
adj12 = - W[0,0] * W[2,1] + W[2,0] * W[0,1]
adj20 = W[0,1] * W[1,2] - W[1,1] * W[0,2]
adj21 = - W[0,0] * W[1,2] + W[1,0] * W[0,2]
adj22 = W[0,0] * W[1,1] - W[1,0] * W[0,1]
Wadj = matrix(PS, [ [adj00, adj01, adj02],
[adj10, adj11, adj12],
[adj20, adj21, adj22] ])
elif m == 3 and qexp_prec > 10**5 :
adj00 = -W[0,2]*W[1,1]*W[2,0] + W[0,1]*W[1,2]*W[2,0] + W[0,2]*W[1,0]*W[2,1] - W[0,0]*W[1,2]*W[2,1] - W[0,1]*W[1,0]*W[2,2] + W[0,0]*W[1,1]*W[2,2]
adj01 = -W[0,3]*W[1,1]*W[2,0] + W[0,1]*W[1,3]*W[2,0] + W[0,3]*W[1,0]*W[2,1] - W[0,0]*W[1,3]*W[2,1] - W[0,1]*W[1,0]*W[2,3] + W[0,0]*W[1,1]*W[2,3]
adj02 = -W[0,3]*W[1,2]*W[2,0] + W[0,2]*W[1,3]*W[2,0] + W[0,3]*W[1,0]*W[2,2] - W[0,0]*W[1,3]*W[2,2] - W[0,2]*W[1,0]*W[2,3] + W[0,0]*W[1,2]*W[2,3]
adj03 = -W[0,3]*W[1,2]*W[2,1] + W[0,2]*W[1,3]*W[2,1] + W[0,3]*W[1,1]*W[2,2] - W[0,1]*W[1,3]*W[2,2] - W[0,2]*W[1,1]*W[2,3] + W[0,1]*W[1,2]*W[2,3]
adj10 = -W[0,2]*W[1,1]*W[3,0] + W[0,1]*W[1,2]*W[3,0] + W[0,2]*W[1,0]*W[3,1] - W[0,0]*W[1,2]*W[3,1] - W[0,1]*W[1,0]*W[3,2] + W[0,0]*W[1,1]*W[3,2]
adj11 = -W[0,3]*W[1,1]*W[3,0] + W[0,1]*W[1,3]*W[3,0] + W[0,3]*W[1,0]*W[3,1] - W[0,0]*W[1,3]*W[3,1] - W[0,1]*W[1,0]*W[3,3] + W[0,0]*W[1,1]*W[3,3]
adj12 = -W[0,3]*W[1,2]*W[3,0] + W[0,2]*W[1,3]*W[3,0] + W[0,3]*W[1,0]*W[3,2] - W[0,0]*W[1,3]*W[3,2] - W[0,2]*W[1,0]*W[3,3] + W[0,0]*W[1,2]*W[3,3]
adj13 = -W[0,3]*W[1,2]*W[3,1] + W[0,2]*W[1,3]*W[3,1] + W[0,3]*W[1,1]*W[3,2] - W[0,1]*W[1,3]*W[3,2] - W[0,2]*W[1,1]*W[3,3] + W[0,1]*W[1,2]*W[3,3]
adj20 = -W[0,2]*W[2,1]*W[3,0] + W[0,1]*W[2,2]*W[3,0] + W[0,2]*W[2,0]*W[3,1] - W[0,0]*W[2,2]*W[3,1] - W[0,1]*W[2,0]*W[3,2] + W[0,0]*W[2,1]*W[3,2]
adj21 = -W[0,3]*W[2,1]*W[3,0] + W[0,1]*W[2,3]*W[3,0] + W[0,3]*W[2,0]*W[3,1] - W[0,0]*W[2,3]*W[3,1] - W[0,1]*W[2,0]*W[3,3] + W[0,0]*W[2,1]*W[3,3]
adj22 = -W[0,3]*W[2,2]*W[3,0] + W[0,2]*W[2,3]*W[3,0] + W[0,3]*W[2,0]*W[3,2] - W[0,0]*W[2,3]*W[3,2] - W[0,2]*W[2,0]*W[3,3] + W[0,0]*W[2,2]*W[3,3]
adj23 = -W[0,3]*W[2,2]*W[3,1] + W[0,2]*W[2,3]*W[3,1] + W[0,3]*W[2,1]*W[3,2] - W[0,1]*W[2,3]*W[3,2] - W[0,2]*W[2,1]*W[3,3] + W[0,1]*W[2,2]*W[3,3]
adj30 = -W[1,2]*W[2,1]*W[3,0] + W[1,1]*W[2,2]*W[3,0] + W[1,2]*W[2,0]*W[3,1] - W[1,0]*W[2,2]*W[3,1] - W[1,1]*W[2,0]*W[3,2] + W[1,0]*W[2,1]*W[3,2]
adj31 = -W[1,3]*W[2,1]*W[3,0] + W[1,1]*W[2,3]*W[3,0] + W[1,3]*W[2,0]*W[3,1] - W[1,0]*W[2,3]*W[3,1] - W[1,1]*W[2,0]*W[3,3] + W[1,0]*W[2,1]*W[3,3]
adj32 = -W[1,3]*W[2,2]*W[3,0] + W[1,2]*W[2,3]*W[3,0] + W[1,3]*W[2,0]*W[3,2] - W[1,0]*W[2,3]*W[3,2] - W[1,2]*W[2,0]*W[3,3] + W[1,0]*W[2,2]*W[3,3]
adj33 = -W[1,3]*W[2,2]*W[3,1] + W[1,2]*W[2,3]*W[3,1] + W[1,3]*W[2,1]*W[3,2] - W[1,1]*W[2,3]*W[3,2] - W[1,2]*W[2,1]*W[3,3] + W[1,1]*W[2,2]*W[3,3]
Wadj = matrix(PS, [ [adj00, adj01, adj02, adj03],
[adj10, adj11, adj12, adj13],
[adj20, adj21, adj22, adj23],
[adj30, adj31, adj32, adj33] ])
else :
Wadj = W.adjoint()
theta_factors = [ [ Wadj[i,r] for i in xrange(m + 1) ]
for r in xrange(m + 1) ]
if p is None :
self.__theta_factors = theta_factors
return theta_factors
def _set_eta_factor(self, eta_factor) :
self.__eta_factor = eta_factor
def _eta_factor(self) :
r"""
The inverse determinant of `W`, which in these cases is always a negative
power of the eta function.
"""
try :
return self.__eta_factor
except AttributeError :
m = self.__precision.jacobi_index()
pw = (m + 1) * (2 * m + 1)
qexp_prec = self._qexp_precision()
self.__eta_factor = self.integral_power_series_ring() \
( [ number_of_partitions(n) for n in xrange(qexp_prec) ] ) \
.add_bigoh(qexp_prec) ** pw
return self.__eta_factor
def by_taylor_expansion(self, fs, k, is_integral=False) :
r"""
We combine the theta decomposition and the heat operator as in [Sko].
This yields a bijections of Jacobi forms of weight `k` and
`M_k \times S_{k+2} \times .. \times S_{k+2m}`.
"""
## we introduce an abbreviations
if is_integral :
PS = self.integral_power_series_ring()
else :
PS = self.power_series_ring()
if not len(fs) == self.__precision.jacobi_index() + 1 :
raise ValueError("fs must be a list of m + 1 elliptic modular forms or their fourier expansion")
qexp_prec = self._qexp_precision()
if qexp_prec is None : # there are no forms below the precision
return dict()
f_divs = dict()
for (i, f) in enumerate(fs) :
f_divs[(i, 0)] = PS(f(qexp_prec), qexp_prec)
if self.__precision.jacobi_index() == 1 :
return self._by_taylor_expansion_m1(f_divs, k, is_integral)
for i in xrange(self.__precision.jacobi_index() + 1) :
for j in xrange(1, self.__precision.jacobi_index() - i + 1) :
f_divs[(i,j)] = f_divs[(i, j - 1)].derivative().shift(1)
phi_divs = list()
for i in xrange(self.__precision.jacobi_index() + 1) :
## This is the formula in Skoruppas thesis. He uses d/ d tau instead of d / dz which yields
## a factor 4 m
phi_divs.append( sum( f_divs[(j, i - j)] * (4 * self.__precision.jacobi_index())**i
* binomial(i,j) / 2**i#2**(self.__precision.jacobi_index() - i + 1)
* prod(2*(i - l) + 1 for l in xrange(1, i))
/ factorial(i + k + j - 1)
* factorial(2*self.__precision.jacobi_index() + k - 1)
for j in xrange(i + 1) ) )
phi_coeffs = dict()
for r in xrange(self.__precision.jacobi_index() + 1) :
series = sum( map(operator.mul, self._theta_factors()[r], phi_divs) )
series = self._eta_factor() * series
for n in xrange(qexp_prec) :
phi_coeffs[(n, r)] = series[n]
return phi_coeffs
def _by_taylor_expansion_m1(self, f_divs, k, is_integral=False) :
r"""
This provides special, faster code in the Jacobi index `1` case.
"""
if is_integral :
PS = self.integral_power_series_ring()
else :
PS = self.power_series_ring()
qexp_prec = self._qexp_precision()
fderiv = f_divs[(0,0)].derivative().shift(1)
f = f_divs[(0,0)] * Integer(k/2)
gfderiv = f_divs[(1,0)] - fderiv
ab_prec = isqrt(qexp_prec + 1)
a1dict = dict(); a0dict = dict()
b1dict = dict(); b0dict = dict()
for t in xrange(1, ab_prec + 1) :
tmp = t**2
a1dict[tmp] = -8*tmp
b1dict[tmp] = -2
tmp += t
a0dict[tmp] = 8*tmp + 2
b0dict[tmp] = 2
b1dict[0] = -1
a0dict[0] = 2; b0dict[0] = 2
a1 = PS(a1dict); b1 = PS(b1dict)
a0 = PS(a0dict); b0 = PS(b0dict)
Ifg0 = (self._eta_factor() * (f*a0 + gfderiv*b0)).list()
Ifg1 = (self._eta_factor() * (f*a1 + gfderiv*b1)).list()
if len(Ifg0) < qexp_prec :
Ifg0 += [0]*(qexp_prec - len(Ifg0))
if len(Ifg1) < qexp_prec :
Ifg1 += [0]*(qexp_prec - len(Ifg1))
Cphi = dict([(0,0)])
for i in xrange(qexp_prec) :
Cphi[-4*i] = Ifg0[i]
Cphi[1-4*i] = Ifg1[i]
del Ifg0[:], Ifg1[:]
phi_coeffs = dict()
m = self.__precision.jacobi_index()
for r in xrange(2 * self.__precision.jacobi_index()) :
for n in xrange(qexp_prec) :
k = 4 * m * n - r**2
if k >= 0 :
phi_coeffs[(n, r)] = Cphi[-k]
return phi_coeffs
| Python |
import sqrt5, sqrt5_fast
from sage.misc.all import cputime
from sage.rings.all import Integer, ZZ
F = sqrt5.F
def ideals_of_bounded_norm(B):
return sum([v for n, v in F.ideals_of_bdd_norm(B).iteritems() if n != 1], [])
def ideals_of_norm(v):
try:
v = list(v)
except TypeError:
v = [Integer(v)]
z = F.ideals_of_bdd_norm(max(v))
return sum([z[n] for n in v if n>1],[])
def canonical_gen(I):
"""
Return a canonical choice of generator for this ideal I (of a
PID).
The implementation computes the Hermite normal form (HNF) basis of
the ideal, which is canonical, then finds a generator for the
ideal it defines.
EXAMPLES::
sage: import psage.modform.hilbert.sqrt5.tables as tables
sage: a = tables.F.gen()
sage: z = a^30 * (-45*a+28); z
-37284985*a - 23043388
sage: tables.canonical_gen(tables.F.ideal(z))
-45*a + 28
"""
try:
g = I.ring().ideal(I.basis()).gens_reduced()
assert len(g) == 1
return g[0]
except AttributeError:
# sometimes I is just a usuaul integer
return Integer(I)
def canonical_rep(z):
"""
Return canonical generator for the ideal generated by z. See the
documentation for the canonical_gen function.
"""
return canonical_gen(z.parent().ideal(z))
def test_canonical_gen(B=50):
a = F.gen()
z = -45*a + 28
v = [canonical_rep(a**i * z) for i in range(-B,B)]
assert len(set(v)) == 1
def no_space(s):
return str(s).replace(' ', '')
def dimensions(v, filename=None):
"""
Compute dimensions of spaces of Hilbert modular forms for all the levels in v.
The format is:
Norm dimension generator time
"""
F = open(filename,'a') if filename else None
for N in ideals_of_norm(v):
t = cputime()
H = sqrt5_fast.IcosiansModP1ModN(N)
tm = cputime(t)
s = '%s %s %s %s'%(N.norm(), H.cardinality(), no_space(canonical_gen(N)), tm)
print s
if F:
F.write(s+'\n')
F.flush()
def charpolys(v, B, filename=None):
"""
Compute characteristic polynomials of T_P for primes P with norm <= B
for spaces of Hilbert modular forms for all the levels in v.
"""
F = open(filename,'a') if filename else None
P = [p for p in ideals_of_bounded_norm(B) if p.is_prime()]
for N in ideals_of_norm(v):
t = cputime()
H = sqrt5_fast.IcosiansModP1ModN(N)
T = [(p.smallest_integer(),H.hecke_matrix(p).fcp()) for p in P if
gcd(Integer(p.norm()), Integer(N.norm())) == 1]
tm = cputime(t)
s = '%s %s %s %s'%(N.norm(), no_space(canonical_gen(N)), tm, no_space(T))
print s
if F:
F.write(s+'\n')
F.flush()
def one_charpoly(v, filename=None):
"""
Compute and factor one characteristic polynomials for all the
levels in v. Always compute the charpoly of T_P where P is the
smallest prime not dividing the level.
"""
F = open(filename,'a') if filename else None
P = [p for p in ideals_of_bounded_norm(100) if p.is_prime()]
for N in ideals_of_norm(v):
NN = Integer(N.norm())
t = cputime()
H = sqrt5_fast.IcosiansModP1ModN(N)
t0 = cputime(t)
for p in P:
if Integer(p.norm()).gcd(NN) == 1:
break
t = cputime()
T = H.hecke_matrix(p)
t1 = cputime(t)
t = cputime()
f = T.fcp()
t2 = cputime(t)
s = '%s\t%s\t%s\t%s\t%s\t(%.1f,%.1f,%.1f)'%(N.norm(), no_space(canonical_gen(N)),
p.smallest_integer(), no_space(canonical_gen(p)), no_space(f),
t0, t1, t2,)
print s
if F:
F.write(s+'\n')
F.flush()
def elliptic_curves(v, B=100, filename=None):
from hmf import HilbertModularForms
F = open(filename,'a') if filename else None
for N in ideals_of_norm(v):
H = HilbertModularForms(N)
for i, E in enumerate(H.elliptic_curve_factors()):
v = E.aplist(B)
s = '%s\t%s\t%s\t%s'%(N.norm(), no_space(canonical_gen(N)), i, ' '.join([no_space(x) for x in v]))
print s
if F:
F.write(s+'\n')
F.flush()
def elliptic_curves_parallel(v, B, dir, ncpu=16):
from hmf import HilbertModularForms
from sage.all import parallel, set_random_seed
import os
@parallel(ncpu)
def f(N):
set_random_seed(0) # to replicate any linear algebra issues?
level = no_space(canonical_gen(N)).replace('*','').replace('-','_')
F = open(os.path.join(dir,'%s.txt'%level),'w')
H = HilbertModularForms(N)
level = no_space(canonical_gen(N))
try:
D = H.elliptic_curve_factors()
F.write('count %s %s %s\n'%(N.norm(), level, len(D)))
F.flush()
for i, E in enumerate(D):
v = E.aplist(B)
s = '%s\t%s\t%s\t%s'%(N.norm(), level, i, ' '.join([no_space(x) for x in v]))
print s
F.write(s+'\n')
F.flush()
except Exception, msg:
F.write('exception %s %s "%s"\n'%(N.norm(), level, msg))
F.close()
for X in f(ideals_of_norm(v)):
print X
#################################################################
from sage.libs.all import pari
from sage.rings.all import primes
def primes_of_bounded_norm(B):
"""
Return the prime ideals of the integers of the field Q(sqrt(5)) of
norm at most B, ordered first by norm, then by the image of the
golden ratio mod the prime in GF(p)={0,1,...,p-1}.
INPUT:
- B -- integer
OUTPUT:
- list of prime ideals
EXAMPLES::
sage: import psage
sage: psage.modform.hilbert.sqrt5.primes_of_bounded_norm(4)
[Fractional ideal (2)]
sage: len(psage.modform.hilbert.sqrt5.primes_of_bounded_norm(10^4))
1233
sage: v = psage.modform.hilbert.sqrt5.primes_of_bounded_norm(11); v
[Fractional ideal (2), Fractional ideal (2*a - 1), Fractional ideal (3), Fractional ideal (3*a - 1), Fractional ideal (3*a - 2)]
Check that the sort order is as claimed::
sage: P0 = v[-2]; P1 = v[-1]
sage: K = P0.number_field(); K
Number Field in a with defining polynomial x^2 - x - 1
sage: P0.residue_field()(K.gen())
4
sage: P1.residue_field()(K.gen()) # yep, 4 < 8
8
"""
v = []
g = F.gen()
for p in primes(B+1):
if p == 5:
v.append((5, F.ideal(2*g-1)))
elif p%5 in [2,3]:
Norm = p*p
if Norm <= B:
v.append((Norm, F.ideal(p)))
else:
s = pari(5).Mod(p).sqrt()
a = int(((1 + s)/2).lift()); b = int(((1 - s)/2).lift())
v.append((p, a, F.ideal([p, g - a])))
v.append((p, b, F.ideal([p, g - b])))
v.sort()
return [z[-1] for z in v]
| Python |
#################################################################################
#
# (c) Copyright 2010 William Stein
#
# This file is part of PSAGE
#
# PSAGE is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# PSAGE is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
#
#################################################################################
"""
Toy Implementation of Hilbert Modular Forms
This file contains an incredibly slow naive toy implementation of
Dembele's quaternion algebra algorithm for computing Hilbert modular
forms of weight (2,2) and ramified or split prime level. This is for
testing and educational purposes only. The file sqrt5_fast.pyx
contains a dramatically faster version. That said, figuring out the
content of this file based on the contents of Dembele's paper
"Explicit Computations of Hilbert Modular Forms on Q(sqrt(5))"
was a timing consuming and very painful task.
EXAMPLES:
LEVEL 31::
sage: from psage.modform.hilbert.sqrt5.sqrt5 import THETA, hecke_ops, F
sage: B.<i,j,k> = QuaternionAlgebra(F,-1,-1)
sage: c = F.factor(31)[1][0]
sage: P = F.primes_above(5)[0]
sage: TH = THETA(20) # about 1 minute
pi = [...]
Sorting through 22440 elements
sage: T = hecke_ops(c, TH); T # random output do to choice of basis
[(5, a + 2, [1 5]
[3 3]), (9, 3, [5 5]
[3 7]), (11, a + 3, [ 2 10]
[ 6 6]), (11, 2*a + 3, [7 5]
[3 9]), (19, a + 4, [10 10]
[ 6 14]), (19, 3*a + 4, [ 5 15]
[ 9 11])]
sage: for nm,p,t in T:
... print nm, p, t.charpoly().factor()
5 a + 2 (x - 6) * (x + 2)
9 3 (x - 10) * (x - 2)
11 a + 3 (x - 12) * (x + 4)
11 2*a + 3 (x - 12) * (x - 4)
19 a + 4 (x - 20) * (x - 4)
19 3*a + 4 (x - 20) * (x + 4)
LEVEL 41::
sage: from psage.modform.hilbert.sqrt5.sqrt5 import THETA, hecke_ops, F
sage: B.<i,j,k> = QuaternionAlgebra(F,-1,-1)
sage: F.primes_above(41)
[Fractional ideal (a - 7), Fractional ideal (a + 6)]
sage: c = F.primes_above(41)[0]
sage: TH = THETA(11) # about 30 seconds
pi = [...]
Sorting through 6660 elements
sage: T = hecke_ops(c, TH); T # random output do to choice of basis
[(5, a + 2, [4 2]
[5 1]), (9, 3, [ 6 4]
[10 0]), (11, a + 3, [10 2]
[ 5 7]), (11, 2*a + 3, [ 8 4]
[10 2])]
sage: for nm,p,t in T:
... print nm, p, t.charpoly().factor()
5 a + 2 (x - 6) * (x + 1)
9 3 (x - 10) * (x + 4)
11 a + 3 (x - 12) * (x - 5)
11 2*a + 3 (x - 12) * (x + 2)
LEVEL 389!:
This relies on having TH from above (say from the level 31 block above)::
sage: F.primes_above(389)
[Fractional ideal (18*a - 5), Fractional ideal (-18*a + 13)]
sage: c = F.primes_above(389)[0]
sage: T = hecke_ops(c, TH)
sage: for nm,p,t in T:
... print nm, p, t.charpoly().factor()
5 a + 2 (x - 6) * (x^2 + 4*x - 1) * (x^2 - x - 4)^2
9 3 (x - 10) * (x^2 + 3*x - 9) * (x^4 - 5*x^3 + 3*x^2 + 6*x - 4)
11 a + 3 (x - 12) * (x + 3)^2 * (x^4 - 17*x^2 + 68)
11 2*a + 3 (x - 12) * (x^2 + 5*x + 5) * (x^4 - x^3 - 23*x^2 + 18*x + 52)
"""
from sage.all import NumberField, polygen, QQ, ZZ, QuaternionAlgebra, cached_function, disk_cached_function
x = polygen(QQ,'x')
F = NumberField(x**2 - x -1, 'a')
O_F = F.ring_of_integers()
B = QuaternionAlgebra(F,-1,-1,'i,j,k')
def modp_splitting(p):
"""
INPUT:
- p -- ideal of the number field K = B.base() with ring O of integers.
OUTPUT:
- matrices I, J in M_2(O/p) such that i |--> I and j |--> J defines
an algebra morphism, i.e., I^2=a, J^2=b, I*J=-J*I.
EXAMPLES::
sage: from psage.modform.hilbert.sqrt5.sqrt5 import F, B, modp_splitting
sage: c = F.factor(31)[0][0]
sage: modp_splitting(c)
(
[ 0 30] [18 4]
[ 1 0], [ 4 13]
)
sage: c = F.factor(37)[0][0]; c
Fractional ideal (37)
sage: I, J = modp_splitting(c); I, J
(
[ 0 36] [23*abar + 21 36*abar + 8]
[ 1 0], [ 36*abar + 8 14*abar + 16]
)
sage: I^2
[36 0]
[ 0 36]
sage: J^2
[36 0]
[ 0 36]
sage: I*J == -J*I
True
AUTHOR: William Stein
"""
global B, F
# Inspired by the code in the function
# modp_splitting_data in algebras/quatalg/quaternion_algebra.py
if p.number_field() != B.base():
raise ValueError, "p must be a prime ideal in the base field of the quaternion algebra"
if not p.is_prime():
raise ValueError, "p must be prime"
if F is not p.number_field():
raise ValueError, "p must be a prime of %s"%F
k = p.residue_field()
from sage.all import MatrixSpace
M = MatrixSpace(k, 2)
i2, j2 = B.invariants()
i2 = k(i2); j2 = k(j2)
if k.characteristic() == 2:
if i2 == 0 or j2 == 0:
raise NotImplementedError
return M([0,1,1,0]), M([1,1,0,1])
# Find I -- just write it down
I = M([0,i2,1,0])
# Find J -- I figured this out by just writing out the general case
# and seeing what the parameters have to satisfy
i2inv = 1/i2
a = None
for b in list(k):
if not b: continue
c = j2 + i2inv * b*b
if c.is_square():
a = -c.sqrt()
break
if a is None:
# do a fallback search; needed in char 3 sometimes.
for J in M:
K = I*J
if J*J == j2 and K == -J*I:
return I, J, K
J = M([a,b,(j2-a*a)/b, -a])
K = I*J
assert K == -J*I, "bug in that I,J don't skew commute"
return I, J
def modp_splitting_map(p):
"""
Return a map from subset of B to 2x2 matrix space isomorphic
to R tensor OF/p.
INPUT:
- `B` -- quaternion algebra over F=Q(sqrt(5))
with invariants -1, -1.
- `p` -- prime ideal of F=Q(sqrt(5))
EXAMPLES::
sage: from psage.modform.hilbert.sqrt5.sqrt5 import F, B, modp_splitting_map
sage: i,j,k = B.gens()
sage: theta = modp_splitting_map(F.primes_above(5)[0])
sage: theta(i + j - k)
[2 1]
[3 3]
sage: s = 2 + 3*i - 2*j - 2*k
sage: theta(s)
[1 3]
[4 3]
sage: s.reduced_characteristic_polynomial()
x^2 - 4*x + 21
sage: theta(s).charpoly()
x^2 + x + 1
sage: s.reduced_characteristic_polynomial().change_ring(GF(5))
x^2 + x + 1
sage: theta = modp_splitting_map(F.primes_above(3)[0])
sage: smod = theta(s); smod
[2*abar + 1 abar + 1]
[ abar + 1 abar]
sage: smod^2 - 4*smod + 21
[0 0]
[0 0]
"""
I, J = modp_splitting(p)
F = p.residue_field()
def f(x):
return F(x[0]) + I*F(x[1]) + J*F(x[2]) + I*J*F(x[3])
return f
def icosian_gens():
"""
Return generators of the icosian group, as elements of the
Hamilton quaternion algebra B over Q(sqrt(5)).
AUTHOR: William Stein
EXAMPLES::
sage: from psage.modform.hilbert.sqrt5.sqrt5 import icosian_gens
sage: icosian_gens()
[i, j, k, -1/2 + 1/2*i + 1/2*j + 1/2*k, 1/2*i + 1/2*a*j + (-1/2*a + 1/2)*k]
sage: [a.reduced_norm() for a in icosian_gens()]
[1, 1, 1, 1, 1]
"""
global B, F
omega = F.gen() # (1+sqrt(5))/2
omega_bar = 1 - F.gen() # (1-sqrt(5))/2 = 1 - (1+sqrt(5))/2
return [B(v)/2 for v in [(0,2,0,0), (0,0,2,0),
(0,0,0,2), (-1,1,1,1), (0,1,omega,omega_bar)]]
def compute_all_icosians():
"""
Return a list of the elements of the Icosian group of order 120,
which we compute by generating enough products of icosian
generators.
EXAMPLES::
sage: from psage.modform.hilbert.sqrt5.sqrt5 import compute_all_icosians, all_icosians
sage: v = compute_all_icosians()
sage: len(v)
120
sage: v
[1/2 + 1/2*a*i + (-1/2*a + 1/2)*k, 1/2 + (-1/2*a + 1/2)*i + 1/2*a*j,..., -k, i, j, -i]
sage: assert set(v) == set(all_icosians()) # double check
"""
from sage.all import permutations, cartesian_product_iterator
Icos = []
ig = icosian_gens()
per = permutations(range(5))
exp = cartesian_product_iterator([range(1,i) for i in [5,5,5,4,5]])
for f in exp:
for p in per:
e0 = ig[p[0]]**f[0]
e1 = ig[p[1]]**f[1]
e2 = ig[p[2]]**f[2]
e3 = ig[p[3]]**f[3]
e4 = ig[p[4]]**f[4]
elt = e0*e1*e2*e3*e4
if elt not in Icos:
Icos.append(elt)
if len(Icos) == 120:
return Icos
@cached_function
def all_icosians():
"""
Return a list of all 120 icosians, from a precomputed table.
EXAMPLES::
sage: from psage.modform.hilbert.sqrt5.sqrt5 import all_icosians
sage: v = all_icosians()
sage: len(v)
120
"""
s = '[1+a*i+(-a+1)*k,1+(-a+1)*i+a*j,-a+i+(a-1)*j,1+(-a)*i+(-a+1)*k,-a-j+(-a+1)*k,1+(a-1)*i+(-a)*j,-1+(-a)*i+(a-1)*k,-1+(a-1)*i+(-a)*j,-a+1+(-a)*j-k,-1+a*i+(-a+1)*k,-a+1+i+(-a)*k,-1+(-a+1)*i+(-a)*j,(-a+1)*i+j+(-a)*k,a-1+(-a)*j+k,(a-1)*i-j+a*k,a+i+(-a+1)*j,1+a*i+(a-1)*k,-1+(-a)*i+(-a+1)*k,a*i+(-a+1)*j-k,a-1+i+a*k,(-a)*i+(a-1)*j+k,a+j+(-a+1)*k,1+(-a+1)*i+(-a)*j,-1+(a-1)*i+a*j,a-i+(-a+1)*j,-1+a*i+(a-1)*k,a+j+(a-1)*k,-1+(-a+1)*i+a*j,(-a+1)*i+j+a*k,a-1+a*j+k,-a+i+(-a+1)*j,1+(-a)*i+(a-1)*k,a*i+(-a+1)*j+k,a-1-i+a*k,-a+j+(a-1)*k,1+(a-1)*i+a*j,(a-1)*i+j+a*k,-a+1+a*j+k,(-a)*i+(-a+1)*j+k,-a+1+i+a*k,-a-i+(-a+1)*j,-a+1+(-a)*j+k,(-a+1)*i-j+a*k,(a-1)*i+j+(-a)*k,a+i+(a-1)*j,a-1+a*j-k,-a+j+(-a+1)*k,-a+1-i+a*k,a*i+(a-1)*j+k,(-a)*i+(-a+1)*j-k,a-j+(a-1)*k,a-1+i+(-a)*k,-1+i+j+k,-1-i-j+k,1-i-j-k,1+i-j+k,a-j+(-a+1)*k,-1+i-j-k,1-i+j+k,(a-1)*i-j+(-a)*k,-a-j+(a-1)*k,1+i+j-k,a*i+(a-1)*j-k,-1-i+j-k,a-1+(-a)*j-k,-a+1+a*j-k,(-a)*i+(a-1)*j-k,-a+1-i+(-a)*k,-a-i+(a-1)*j,a-1-i+(-a)*k,(-a+1)*i-j+(-a)*k,a-i+(a-1)*j,-i+(-a)*j+(a-1)*k,i+a*j+(a-1)*k,i+a*j+(-a+1)*k,-i+a*j+(a-1)*k,-i+a*j+(-a+1)*k,i+(-a)*j+(a-1)*k,-i+(-a)*j+(-a+1)*k,i+(-a)*j+(-a+1)*k,-1-i-j-k,1+i+j+k,2,-a+1+a*i-j,-2,-a+(-a+1)*i-k,a-1+a*i+j,a+(-a+1)*i+k,a-1+(-a)*i+j,1+(-a+1)*j+(-a)*k,-a+1+a*i+j,-1+(-a+1)*j+a*k,a+(a-1)*i+k,-1+(a-1)*j+a*k,-a+(-a+1)*i+k,1+(-a+1)*j+a*k,-a+1+(-a)*i+j,-a+(a-1)*i+k,a-1+a*i-j,1+(a-1)*j+a*k,a+(-a+1)*i-k,-1+(-a+1)*j+(-a)*k,-a+1+(-a)*i-j,-a+(a-1)*i-k,a-1+(-a)*i-j,1+(a-1)*j+(-a)*k,a+(a-1)*i-k,-1+(a-1)*j+(-a)*k,-1+i+j-k,1-i+j-k,1-i-j+k,-1-i+j+k,-1+i-j+k,1+i-j-k,2*k,(-2)*j,(-2)*k,2*i,2*j,(-2)*i]'
v = eval(s, {'a':F.gen(), 'i':B.gen(0), 'j':B.gen(1), 'k':B.gen(0)*B.gen(1)})
return [B(x)/B(2) for x in v]
def icosian_ring_gens():
"""
Return ring generators for the icosian ring (a maximal order) in the
quaternion algebra ramified only at infinity over F=Q(sqrt(5)).
These are generators over the ring of integers of F.
OUTPUT:
- list
EXAMPLES::
sage: from psage.modform.hilbert.sqrt5.sqrt5 import icosian_ring_gens
sage: icosian_ring_gens()
[1/2 + (1/2*a - 1/2)*i + 1/2*a*j, (1/2*a - 1/2)*i + 1/2*j + 1/2*a*k, 1/2*a*i + (1/2*a - 1/2)*j + 1/2*k, 1/2*i + 1/2*a*j + (1/2*a - 1/2)*k]
"""
global B, F
# See page 6 of Dembele.
# DO NOT CHANGE THESE! You'll break, e.g., the optimized code for
# writing elements in terms of these...
omega = F.gen()
omega_bar = 1 - F.gen()
return [B(v)/2 for v in [(1,-omega_bar,omega,0),
(0,-omega_bar,1,omega),
(0,omega,-omega_bar,1),
(0,1,omega,-omega_bar)]]
def icosian_ring_gens_over_ZZ():
"""
Return basis over ZZ for the icosian ring, which has ZZ-rank 8.
EXAMPLES::
sage: from psage.modform.hilbert.sqrt5.sqrt5 import icosian_ring_gens_over_ZZ
sage: v = icosian_ring_gens_over_ZZ(); v
[1/2 + (1/2*a - 1/2)*i + 1/2*a*j, (1/2*a - 1/2)*i + 1/2*j + 1/2*a*k, 1/2*a*i + (1/2*a - 1/2)*j + 1/2*k, 1/2*i + 1/2*a*j + (1/2*a - 1/2)*k, 1/2*a + 1/2*i + (1/2*a + 1/2)*j, 1/2*i + 1/2*a*j + (1/2*a + 1/2)*k, (1/2*a + 1/2)*i + 1/2*j + 1/2*a*k, 1/2*a*i + (1/2*a + 1/2)*j + 1/2*k]
sage: len(v)
8
"""
global B, F
I = icosian_ring_gens()
omega = F.gen()
return I + [omega*x for x in I]
def tensor_over_QQ_with_RR(prec=53):
"""
Return map from the quaternion algebra B to the tensor product of
B over QQ with RealField(prec), viewed as an 8-dimensional real
vector space.
INPUT:
- prec -- (integer: default 53); bits of real precision
OUTPUT:
- a Python function
EXAMPLES::
sage: from psage.modform.hilbert.sqrt5.sqrt5 import tensor_over_QQ_with_RR, B
sage: f = tensor_over_QQ_with_RR()
sage: B.gens()
[i, j, k]
sage: f(B.0)
(0.000000000000000, 1.00000000000000, 0.000000000000000, 0.000000000000000, 0.000000000000000, 1.00000000000000, 0.000000000000000, 0.000000000000000)
sage: f(B.1)
(0.000000000000000, 0.000000000000000, 1.00000000000000, 0.000000000000000, 0.000000000000000, 0.000000000000000, 1.00000000000000, 0.000000000000000)
sage: f = tensor_over_QQ_with_RR(20)
sage: f(B.0 - (1/9)*B.1)
(0.00000, 1.0000, -0.11111, 0.00000, 0.00000, 1.0000, -0.11111, 0.00000)
"""
global B, F
from sage.all import RealField
RR = RealField(prec=prec)
V = RR**8
S = F.embeddings(RR)
def f(x):
return V(sum([[sigma(a) for a in x] for sigma in S],[]))
return f
def modp_icosians(p):
"""
Return matrices of images of all 120 icosians modulo p.
INPUT:
- p -- *split* or ramified prime ideal of real quadratic field F=Q(sqrt(5))
OUTPUT:
- list of matrices modulo p.
EXAMPLES::
sage: from psage.modform.hilbert.sqrt5.sqrt5 import F, modp_icosians
sage: len(modp_icosians(F.primes_above(5)[0]))
120
sage: v = modp_icosians(F.primes_above(11)[0])
sage: len(v)
120
sage: v[0]
[10 8]
[ 8 1]
sage: v[-1]
[0 3]
[7 0]
"""
I, J = modp_splitting(p); K = I*J
k = p.residue_field()
G = [k(g[0]) + k(g[1])*I + k(g[2])*J + k(g[3])*K for g in icosian_gens()]
from sage.all import MatrixGroup
return [g.matrix() for g in MatrixGroup(G)]
class P1ModList(object):
"""
Object the represents the elements of the projective line modulo
a nonzero *prime* ideal of the ring of integers of Q(sqrt(5)).
Elements of the projective line are represented by elements of a 2-dimension
vector space over the residue field.
EXAMPLES::
We construct the projective line modulo the ideal (2), and illustrate
all the standard operations with it::
sage: from psage.modform.hilbert.sqrt5.sqrt5 import F, P1ModList
sage: P1 = P1ModList(F.primes_above(2)[0]); P1
Projective line over Residue field in abar of Fractional ideal (2)
sage: len(P1)
5
sage: list(P1)
[(0, 1), (1, 0), (1, abar), (1, abar + 1), (1, 1)]
sage: P1.random_element() # random output
(1, abar + 1)
sage: z = P1.random_element(); z # random output
(1, 0)
sage: z[0].parent()
Residue field in abar of Fractional ideal (2)
sage: g = z[0].parent().gen()
sage: P1.normalize((g,g))
(1, 1)
sage: P1((g,g))
(1, 1)
"""
def __init__(self, c):
"""
INPUT:
- c -- a nonzero prime of the ring of integers of Q(sqrt(5))
EXAMPLES::
sage: from psage.modform.hilbert.sqrt5.sqrt5 import F, P1ModList
sage: P1ModList(F.primes_above(3)[0])
Projective line over Residue field in abar of Fractional ideal (3)
sage: P1ModList(F.primes_above(11)[1])
Projective line over Residue field of Fractional ideal (3*a - 1)
sage: list(P1ModList(F.primes_above(5)[0]))
[(0, 1), (1, 0), (1, 1), (1, 2), (1, 3), (1, 4)]
"""
self._c = c
F = c.residue_field()
V = F**2
self._V = V
self._F = F
self._list = [ V([0,1]) ] + [V([1,a]) for a in F]
for a in self._list:
a.set_immutable()
def random_element(self):
"""
Return a random element of this projective line.
sage: from psage.modform.hilbert.sqrt5.sqrt5 import F, P1ModList
sage: P1 = P1ModList(F.primes_above(13)[0]); P1
Projective line over Residue field in abar of Fractional ideal (13)
sage: P1.random_element() # random output
(1, 10*abar + 5)
"""
import random
return random.choice(self._list)
def normalize(self, uv):
"""
Normalize a representative element so it is either of the form
(1,*) if the first entry is nonzero, or of the form (0,1)
otherwise.
EXAMPLES::
sage: from psage.modform.hilbert.sqrt5.sqrt5 import F, P1ModList
sage: p = F.primes_above(13)[0]
sage: P1 = P1ModList(p)
sage: k = p.residue_field()
sage: g = k.gen()
sage: P1.normalize([3,4])
(1, 10)
sage: P1.normalize([g,g])
(1, 1)
sage: P1.normalize([0,g])
(0, 1)
"""
w = self._V(uv)
if w[0]:
w = (~w[0]) * w
w.set_immutable()
#assert w in self._list
return w
else:
return self._list[0]
def __len__(self):
"""
Return number of elements of this P1.
EXAMPLES::
sage: from psage.modform.hilbert.sqrt5.sqrt5 import F, P1ModList
sage: len(P1ModList(F.primes_above(3)[0]))
10
sage: len(P1ModList(F.primes_above(5)[0]))
6
sage: len(P1ModList(F.primes_above(19)[0]))
20
sage: len(P1ModList(F.primes_above(19)[1]))
20
"""
return len(self._list)
def __getitem__(self, i):
"""
Return i-th element.
EXAMPLES::
sage: from psage.modform.hilbert.sqrt5.sqrt5 import F, P1ModList
sage: P = P1ModList(F.primes_above(3)[0]); list(P)
[(0, 1), (1, 0), (1, 2*abar), (1, abar + 1), (1, abar + 2), (1, 2), (1, abar), (1, 2*abar + 2), (1, 2*abar + 1), (1, 1)]
sage: P[2]
(1, 2*abar)
"""
return self._list[i]
def __call__(self, x):
"""
Coerce x into this P1 list. Here x is anything that coerces to
the 2-dimensional vector space over the residue field. The
result is normalized (in fact this function is just an alias
for the normalize function).
EXAMPLES::
sage: from psage.modform.hilbert.sqrt5.sqrt5 import F, P1ModList
sage: p = F.primes_above(13)[0]
sage: k = p.residue_field(); g = k.gen()
sage: P1 = P1ModList(p)
sage: P1([3,4])
(1, 10)
sage: P1([g,g])
(1, 1)
sage: P1(P1([g,g]))
(1, 1)
"""
return self.normalize(x)
def __repr__(self):
"""
EXAMPLES::
sage: from psage.modform.hilbert.sqrt5.sqrt5 import F, P1ModList
sage: P1ModList(F.primes_above(19)[1]).__repr__()
'Projective line over Residue field of Fractional ideal (-4*a + 3)'
"""
return 'Projective line over %s'%self._F
def P1_orbits(p):
"""
INPUT:
- p -- a split or ramified prime of the integers of Q(sqrt(5)).
OUTPUT:
- ``orbits`` -- dictionary mapping elements of P1 to a choice of orbit rep
- ``reps`` -- list of representatives for the orbits
- ``P1`` -- the P1ModList object
AUTHOR: William Stein
EXAMPLES::
sage: from psage.modform.hilbert.sqrt5.sqrt5 import P1_orbits, F
sage: orbits, reps, P1 = P1_orbits(F.primes_above(5)[0])
sage: orbits # random output
{(1, 2): (1, 0), (0, 1): (1, 0), (1, 3): (1, 0), (1, 4): (1, 0), (1, 0): (1, 0), (1, 1): (1, 0)}
sage: reps # random output
[(1, 1)]
sage: len(reps)
1
sage: P1
Projective line over Residue field of Fractional ideal (2*a - 1)
sage: orbits, reps, P1 = P1_orbits(F.primes_above(41)[0])
sage: reps # random output
[(1, 40), (1, 5)]
sage: len(reps)
2
"""
global B
P1 = P1ModList(p)
ICO = modp_icosians(p)
def act(u, t):
return P1(u*t)
cur = P1.random_element()
reps = [cur]
orbits = {cur:cur}
while len(orbits) < len(P1):
for u in ICO:
s = act(u, cur)
if not orbits.has_key(s):
orbits[s] = cur
if len(orbits) < len(P1):
# choose element of P1 not a key
while True:
c = P1.random_element()
if c not in orbits:
cur = c
reps.append(cur)
orbits[cur] = cur
break
# done
return orbits, reps, P1
def P1_orbits2(p):
"""
INPUT:
- p -- a split or ramified prime of the integers of Q(sqrt(5)).
OUTPUT:
- list of disjoint sets of elements of P1 that are orbits
AUTHOR: William Stein
EXAMPLES::
sage: from psage.modform.hilbert.sqrt5.sqrt5 import P1_orbits2, F
sage: P1_orbits2(F.primes_above(5)[0]) # random output
[set([(1, 2), (0, 1), (1, 3), (1, 4), (1, 0), (1, 1)])]
sage: P1_orbits2(F.primes_above(11)[0]) # random output
[set([(0, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 8), (1, 6), (1, 9), (1, 7), (1, 10), (1, 0), (1, 1)])]
sage: len(P1_orbits2(F.primes_above(41)[0]))
2
"""
global B
P1 = P1ModList(p)
ICO = modp_icosians(p)
orbits = []
while sum(len(x) for x in orbits) < len(P1):
v = P1.random_element()
skip = False
for O in orbits:
if v in O:
skip = True
break
if skip: continue
O = set([P1(g*v) for g in ICO])
orbits.append(O)
# Now make a dictionary
return orbits
def totally_pos_gen(p):
"""
Given a prime ideal p of a narrow class number 1 real quadratic
field, return a totally positive generator for p.
INPUT:
- p -- prime ideal of narrow class number 1 real
quadratic field
OUTPUT:
- generator of p that is totally positive
AUTHOR: William Stein
EXAMPLES::
sage: from psage.modform.hilbert.sqrt5.sqrt5 import F, totally_pos_gen
sage: g = totally_pos_gen(F.factor(19)[0][0]); g
3*a + 4
sage: g.norm()
19
sage: g.complex_embeddings()
[2.14589803375032, 8.85410196624968]
sage: for p in primes(14):
... for P, e in F.factor(p):
... g = totally_pos_gen(P)
... print P, g, g.complex_embeddings()
Fractional ideal (2) 2 [2.00000000000000, 2.00000000000000]
Fractional ideal (3) 3 [3.00000000000000, 3.00000000000000]
Fractional ideal (2*a - 1) a + 2 [1.38196601125011, 3.61803398874989]
Fractional ideal (7) 7 [7.00000000000000, 7.00000000000000]
Fractional ideal (3*a - 2) a + 3 [2.38196601125011, 4.61803398874989]
Fractional ideal (3*a - 1) 2*a + 3 [1.76393202250021, 6.23606797749979]
Fractional ideal (13) 13 [13.0000000000000, 13.0000000000000]
"""
F = p.number_field()
assert F.degree() == 2 and F.discriminant() > 0
G = p.gens_reduced()
if len(G) != 1:
raise ValueError, "ideal not principal"
g = G[0]
from sage.all import RR
sigma = F.embeddings(RR)
e = [s(g) for s in sigma]
u = F.unit_group().gen(1)
ue = [s(u) for s in sigma]
if ue[0] > 0 and ue[1] < 0:
u *= -1
if e[0] < 0 and e[1] < 0:
return -g
elif e[0] < 0 and e[1] > 0:
if ue[0] < 0 and ue[1] > 0:
return u*g
else:
raise ValueError, "no totally positive generator"
elif e[0] > 0 and e[1] > 0:
return g
elif e[0] > 0 and e[1] < 0:
if ue[0] < 0 and ue[1] > 0:
return -u*g
else:
raise ValueError, "no totally positive generator"
assert False, "bug"
def gram_matrix_of_maximal_order(R):
"""
Return 8x8 Gram matrix of maximal order defined by R, which is assumed to be
a basis for maximal order over ZZ.
EXAMPLES::
sage: from psage.modform.hilbert.sqrt5.sqrt5 import icosian_ring_gens_over_ZZ, gram_matrix_of_maximal_order
sage: R = icosian_ring_gens_over_ZZ()
sage: gram_matrix_of_maximal_order(R)
[4 2 2 1 2 1 1 3]
[2 4 1 1 1 2 3 3]
[2 1 4 1 1 3 2 3]
[1 1 1 4 3 3 3 2]
[2 1 1 3 6 3 3 4]
[1 2 3 3 3 6 4 4]
[1 3 2 3 3 4 6 4]
[3 3 3 2 4 4 4 6]
"""
G = [[(R[i]*R[j].conjugate()).reduced_trace().trace()
for i in range(8)] for j in range(8)]
from sage.all import matrix
return matrix(ZZ, G)
def qfminim(qf, N):
"""
Call the PARI qfminim method on qf and 2*N, with smaller and
and smaller search range, until a MemoryError is *not* raised.
On a large-memory machine this will succeed the first time.
EXAMPLES::
sage: from psage.modform.hilbert.sqrt5.sqrt5 import icosian_ring_gens_over_ZZ, gram_matrix_of_maximal_order
sage: R = icosian_ring_gens_over_ZZ()
sage: G = gram_matrix_of_maximal_order(R)
sage: qf = pari(G)
sage: from psage.modform.hilbert.sqrt5.sqrt5 import icosian_ring_gens_over_ZZ, gram_matrix_of_maximal_order, qfminim
sage: n, m, v = qfminim(qf, 2)
sage: n
120
sage: m
4
sage: v[0]
[0, 0, 0, -1, 1, 0, 0, 0]~
"""
i = 32
while i>10:
try:
return qf.qfminim(2*N, 2**i)
except MemoryError:
i -= 1
def bounded_elements(N):
"""
Return elements in maximal order of B that have reduced norm
whose trace is at most N.
EXAMPLES::
sage: from psage.modform.hilbert.sqrt5.sqrt5 import bounded_elements
sage: X = bounded_elements(3)
sage: len(X)
180
sage: rnX = [a.reduced_norm() for a in X]
sage: set([a.trace() for a in rnX])
set([2, 3])
sage: set([a.norm() for a in rnX])
set([1])
sage: X = bounded_elements(5)
sage: len(X)
1200
sage: rnX = [a.reduced_norm() for a in X]
sage: set([a.trace() for a in rnX])
set([2, 3, 4, 5])
sage: set([a.norm() for a in rnX])
set([1, 4, 5])
"""
# Get our maximal order
R = icosian_ring_gens_over_ZZ()
# Compute Gram matrix of R
G = gram_matrix_of_maximal_order(R)
# Make PARI quadratic form
from sage.all import pari
qf = pari(G)
# Get the vectors of norm up to N.
# The 2 is because we had to scale by 2 to get
# rid of denominator in Gram matrix.
Z = qfminim(qf, N)
Z2 = Z[2].sage().transpose()
# For each vector, make the corresponding element of B.
# TODO: This step massively dominates the runtime, and can be
# easily made trivial with careful thought.
V = []
for i in range(Z2.nrows()):
w = Z2[i]
V.append(sum(w[j]*R[j] for j in range(8)))
return V
from tables import primes_of_bounded_norm
def THETA(N):
r"""
Return representative elements of the maximal order of `R` of
reduced norm `\pi_p` up to `N` modulo the left action of the units
of `R` (the icosians). Here `\pi_p` runs through totally positive
generators of the odd prime ideals with norm up to `N`.
INPUT:
- `N` -- a positive integer >= 4.
OUTPUT:
- dictionary with keys the totally positive generators of the
odd prime ideals with norm up to and including `N`, and values
a dictionary with values the actual elements of reduced norm
`\pi_p`.
AUTHOR: William Stein
EXAMPLES::
sage: from psage.modform.hilbert.sqrt5.sqrt5 import THETA
sage: d = THETA(9)
pi = [2, a + 2, 3]
Sorting through 2400 elements
sage: d.keys()
[a + 2, 3]
sage: d[3]
{(0, 1): a + 1/2*i + (-1/2*a + 1)*j + (-1/2*a + 1/2)*k, (1, 2): a - 1 + a*j, (1, abar): a - 1/2 + (1/2*a + 1/2)*i + (-1/2*a + 1)*j, (1, abar + 1): a - 1/2 + 1/2*i + 1/2*j + (-a + 1/2)*k, (1, abar + 2): a - 1 + (1/2*a + 1/2)*i + 1/2*j + (-1/2*a)*k, (1, 2*abar + 2): a - 1 + 1/2*a*i + (1/2*a + 1/2)*j + 1/2*k, (1, 2*abar): a - 1/2 + i + (-1/2*a + 1/2)*j + (-1/2*a)*k, (1, 2*abar + 1): a - 1/2 + (-1/2*a)*i + j + (-1/2*a + 1/2)*k, (1, 0): a + (-a + 1)*k, (1, 1): a - 1/2 + 1/2*a*i + j + (-1/2*a + 1/2)*k}
sage: k = d[3].keys(); k
[(0, 1), (1, 2), (1, abar), (1, abar + 1), (1, abar + 2), (1, 2*abar + 2), (1, 2*abar), (1, 2*abar + 1), (1, 0), (1, 1)]
sage: d[3][k[0]]
a + 1/2*i + (-1/2*a + 1)*j + (-1/2*a + 1/2)*k
sage: d[3][k[0]].reduced_norm()
3
"""
# ** NOTE: This algorithm will not scale up well, because there
# are so many vectors of bounded norm.
####################################################################
# Algorithm:
# * Enumerate set S of primes of norm <= N.
# * For each prime p in S:
# - Find a totally positive generator pi_p for p.
# - Compute mod-p local splitting theta_p.
# * Compute set X of elements in maximal order of B of norm <= N
# using the Gram matrix of the icosian ring (maximal order).
# * For each element z of X, compute the reduced norm of z.
# If it equals pi_p for one of the pi_p, compute the
# top row v of the reduced row echelon form of theta_p(z).
# Store v:z if there isn't already something for v.
# Also, of course, store this stuff separately for each p.
####################################################################
global B, F
# Get primes of norm up to N.
S = primes_of_bounded_norm(N)
# Find totally positive generators pi_p
pi = [totally_pos_gen(p) for p in S]
print "pi =",pi
# Compute traces of the generators, since that's what
# the bounded_elements command computes up to.
tr = [abs(x.trace()) for x in pi]
N = max(tr)
# A list that at least includes all elements (up to -1) whose
# reduced norm has trace at most N.
X = bounded_elements(N)
# Compute mod-p local splitting maps
theta_map = {}
for i, p in enumerate(S):
theta_map[pi[i]] = modp_splitting_map(p)
# Sort through the elements of X.
pi_set = set(pi)
# TODO: We skip the prime 2, since the mod-p splitting map is
# broken there.
pi_set.remove(2)
Theta = {}
for pi_p in pi_set:
Theta[pi_p] = {}
# The dictionary Theta will have keys the pi_p and
# the dictionary for pi_p has keys reduced vectors
# in (OF/p)^2. Here "reduced" just means "reduced
# row echelon form", so scaled so first entry is 1.
print "Sorting through %s elements"%len(X)
for a in X:
nrm = a.reduced_norm()
if nrm in pi_set:
# this is: mod right action of R^* acting on the right,
# so column echelon form
v = theta_map[nrm](a).transpose().echelon_form()[0]
## for reference, this is: mod left action of R^*,
## which is wrong, I guess:
# v = theta_map[nrm](a).echelon_form()[0]
z = Theta[nrm]
if z.has_key(v):
pass
else:
z[v] = a
return Theta
def hecke_ops(c, X):
orbits, reps, P1 = P1_orbits(c)
theta_c = modp_splitting_map(c)
def Tp(pi):
z = X[pi]
mat = []
for x in reps:
row = [0]*len(reps)
for _, w in z.iteritems():
w_c = theta_c(w)
y = w_c**(-1) * x
y_red = orbits[P1.normalize(y)]
row[reps.index(y_red)] += 1
mat.append(row)
from sage.all import matrix
return matrix(ZZ, mat)
ans = [(pi.norm(), pi, Tp(pi)) for pi in X.keys()]
ans.sort()
return ans
def hecke_ops2(c, X):
reduce, reps, P1 = P1_orbits(c)
theta_c = modp_splitting_map(c)
def Tp(pi):
z = X[pi]
mat = []
for x in reps:
print "x = %s, card = %s"%(x, len([M for M in reduce.keys() if reduce[M]==x]))
row = [0]*len(reps)
for _, w in z.iteritems():
w_c = theta_c(w)
y = w_c**(-1) * x
print "y =", y
y_red = reduce[P1(y)]
row[reps.index(y_red)] += 1
print "y_red =", y_red
mat.append(row)
from sage.all import matrix
return matrix(ZZ, mat)
ans = [(pi.norm(), pi, Tp(pi)) for pi in X.keys()]
ans.sort()
return ans
class AlphaZ:
def __init__(self, P):
"""
Computing elements with norm pi, where P=(pi).
INPUT:
- P - a prime of O_F
OUTPUT:
- element alpha in B with norm pi
whose image via the mod-p splitting map
has column echelon form with first column z
"""
self.R_Z = icosian_ring_gens_over_ZZ()
self.P = P
self.p = P.smallest_integer()
self.pi = totally_pos_gen(P)
self.deg = P.residue_class_degree()
f = modp_splitting_map(self.P)
self.n = [f(g) for g in self.R_Z]
def local_map(self):
n = self.n
if self.deg == 1:
k = n[0].parent().base_ring()
W = k**4
V = k**8
return V.hom([W(x.list()) for x in n])
else:
# P is an inert prime
from sage.all import GF
k = GF(self.p)
W = k**8
V = k**8
return V.hom([W(sum([y._vector_().list() for y in x.list()],[])) for x in n])
def ideal_mod_p(self, z):
"""
INPUT:
- z - an element of P^1(O_F/p).
"""
A = self.local_map()
phi = self.local_map()
V = phi.codomain()
if self.deg == 1:
g0 = V([z[0],0,z[1],0])
g1 = V([0,z[0],0,z[1]])
W = V.span([g0,g1])
else:
n = self.n
M2 = n[0].parent()
a = M2.base_ring().gen()
g0 = M2([z[0],0,z[1],0])
g1 = a*g0
g2 = M2([0,z[0],0,z[1]])
g3 = a*g2
z = [g0,g1,g2,g3]
W = V.span([V(sum([y._vector_().list() for y in x.list()],[])) for x in z])
return phi.inverse_image(W)
def ideal(self, z):
Imod = self.ideal_mod_p(z)
A = Imod.basis_matrix().lift()
from sage.all import identity_matrix
p = self.p
B = A.stack(p*identity_matrix(ZZ,8))
V = B.row_module()
return V
def ideal_basis(self, z):
J = self.ideal(z)
R = self.R_Z
return [sum(g[i]*R[i] for i in range(8)) for g in J.gens()]
def ideal_gram(self, W):
G = [[(W[i]*W[j].conjugate()).reduced_trace().trace()
for i in range(8)] for j in range(8)]
from sage.all import matrix
return matrix(ZZ, G)
def alpha(self, z):
"""
INPUT:
- z - an element of P^1(O_F/P).
"""
W = self.ideal_basis(z)
G = self.ideal_gram(W)
from sage.all import pari
qf = pari(G)
t = self.pi.trace()
c = qfminim(qf, t)
#print "number of vectors", c[0]
for r in c[2].sage().transpose():
a = sum([W[i]*r[i] for i in range(8)])
if a.reduced_norm() == self.pi:
return a
raise ValueError, "bug"
def all_alpha(self):
return [self.alpha(z) for z in P1ModList(self.P)]
#@cached_function
import os
path = '/tmp/hmf-%s'%os.environ['USER']
if not os.path.exists(path):
os.makedirs(path)
@disk_cached_function(path, memory_cache=True)
def hecke_elements(P):
if P.norm() == 4:
# hardcode this special case.
return [~a for a in hecke_elements_2()]
else:
return [~a for a in AlphaZ(P).all_alpha()]
# Dumb code to get this special case. The answer turns out to be:
# The following elements, divided by 2, where coordinates are in terms of 1,i,j,k, and a=(1+sqrt(5))/2:
# [[-a-1,0,a-2,1], [-a-1,a-1,-a+1,a-1], [-a-1,-a+1,-a+1,a-1], [-a-1,-a+2,-1,0], [-a-1,a-2,-1,0]]
def hecke_elements_2():
P = F.primes_above(2)[0]
from sqrt5_fast import ModN_Reduction
from sage.matrix.all import matrix
f = ModN_Reduction(P)
G = icosian_ring_gens()
k = P.residue_field()
g = k.gen()
def pi(z):
# Note that f(...) returns a string right now, since it's all done at C level.
# This will prboably change, breaking this code.
M = matrix(k,2,eval(f(z).replace(';',','), {'g':g})).transpose()
v = M.echelon_form()[0]
v.set_immutable()
return v
# now just run through elements of icosian ring until we find enough...
ans = {}
a = F.gen()
B = 1
X = [i + a*j for i in range(-B,B+1) for j in range(-B,B+1)]
from sage.misc.all import cartesian_product_iterator
for v in cartesian_product_iterator([X]*4):
z = sum(v[i]*G[i] for i in range(4))
if z.reduced_norm() == 2:
t = pi(z)
if not ans.has_key(t):
ans[t] = z
if len(ans) == 5:
return [x for _, x in ans.iteritems()]
raise RuntimeError
class HMF:
def __init__(self, N):
from sage.all import QuadraticField, QuaternionAlgebra
self._N = N
red, reps, P1 = P1_orbits(N)
self._reduce = red
self._reps = reps
self._P1 = P1
self._theta_N = modp_splitting_map(N)
def __repr__(self):
return "Space of Hilbert modular forms over Q(sqrt(5)) of level %s (norm=%s) and dimension %s"%(
self._N, self._N.norm(), self.dimension())
def dimension(self):
return len(self._reps)
def hecke_matrix(self, P):
mat = []
alpha = AlphaZ(P)
theta = self._theta_N
Z = [theta(x)**(-1) for x in alpha.all_alpha()]
P1 = self._P1
red = self._reduce
for x in self._reps:
row = [0]*len(self._reps)
for w in Z:
y_red = red[P1(w*x)]
row[self._reps.index(y_red)] += 1
mat.append(row)
from sage.all import matrix
return matrix(ZZ, mat)
Tp = hecke_matrix
########################################
# Generalizing to arbitrary level
########################################
def residue_ring(N):
fac = N.factor()
if len(fac) != 1:
raise NotImplementedError, "P must be a prime power"
from sage.rings.all import kronecker_symbol
P, e = fac[0]
p = P.smallest_integer()
s = kronecker_symbol(p, 5)
if e == 1:
return P.residue_field()
if s == 1:
return ResidueRing_split(N, P, p, e)
elif s == -1:
return ResidueRing_inert(N, P, p, e)
else:
if e % 2 == 0:
# easy case
return ResidueRing_ramified_even(N, P, p, e)
else:
# hardest case
return ResidueRing_ramified_odd(N, P, p, e)
class ResidueRing_base:
def __call__(self, x):
if x.parent() is not self._F:
x = self._F(x)
return self._to_ring(x)
def list(self):
return self._ring.list()
def _to_ring(self, x):
return self._ring(x[0]) + self._im_gen*self._ring(x[1])
def ring(self):
return self._ring
def __repr__(self):
return "Residue class ring of ZZ[(1+sqrt(5))/2] modulo %s of characteristic %s"%(
self._N, self._p)
class ResidueRing_split(ResidueRing_base):
"""
Quotient of ring of integers of F by a prime power N.
"""
def __init__(self, N, P, p, e):
self._N = N
self._F = P.number_field()
self._p = p
# Figure out the map to Z/p^e.
fac = self._F.defining_polynomial().factor_padic(p, prec=e+1)
assert len(fac) == 2
roots = [(-a[0][0]).lift() for a in fac]
gen = self._F.gen()
if gen - roots[0] in N:
im_gen = roots[0]
elif gen - roots[1] in N:
im_gen = roots[1]
else:
raise RuntimError, 'bug'
self._ring = ZZ.quotient(p**e)
self._im_gen = self._ring(im_gen)
def lift(self, x):
return self._F(x.lift())
class ResidueRing_inert(ResidueRing_base):
def __init__(self, N, P, p, e):
self._N = N
self._F = P.number_field()
self._p = p
from sage.rings.all import Integers
R = Integers(p**e)
modulus = self._F.defining_polynomial().change_ring(R)
S = R['x']
self._base = R
self._ring = S.quotient_by_principal_ideal(modulus)
self._im_gen = self._ring.gen()
def lift(self, x):
f = x.lift().change_ring(ZZ)
# f is a linear poly in generator of field
return self._F(f)
def list(self):
R = self._ring
x = R.gen()
return [R(a + b*x) for a in self._base for b in self._base]
class ResidueRing_ramified_even(ResidueRing_base):
def __init__(self, N, P, p, e):
self._N = N
self._F = P.number_field()
self._p = p
from sage.rings.all import Integers
assert e%2 == 0
R = Integers(p**(e//2))
modulus = self._F.defining_polynomial().change_ring(R)
S = R['x']
self._ring = S.quotient_by_principal_ideal(modulus)
self._im_gen = self._ring.gen()
def lift(self, x):
f = x.lift().change_ring(ZZ)
return self._F(f)
class ResidueRing_ramified_odd(ResidueRing_base):
"""
Residue class ring R = O_F / P^(2f-1), where e=2f-1
is odd, and P=sqrt(5)O_F is the ramified prime.
Computing with this ring is trickier than all the rest,
since it's not a quotient of Z[x] of the form Z[x]/(m,g),
where m is an integer and g is a polynomial.
The ring R is the quotient of
O_F/P^(2f) = O_F/5^f = (Z/5^fZ)[x]/(x^2-x-1),
by the ideal x^e. We have
O_F/P^(2f-2) subset R subset O_F/P^(2f)
and each successive quotient has order 5 = #(O_F/P).
Thus R has cardinality 5^(2f-1) and characteristic 5^f.
The ring R can't be a quotient of Z[x] of the
form Z[x]/(m,g), since such a quotient has
cardinality m^deg(g) and characteristic m, and
5^(2f-1) is not a power of 5^f.
We thus view R as
R = (Z/5^fZ)[x] / (x^2 - 5, 5^(f-1)*x).
The elements of R are pairs (a,b) in (Z/5^fZ) x (Z/5^(f-1)Z),
which correspond to the class of a + b*x. The arithmetic laws
are thus:
(a,b) + (c,d) = (a+c mod 5^f, b+d mod 5^(f-1))
and
(a,b) * (c,d) = (a*c+b*d*5 mod 5^f, a*d+b*c mod 5^(f-1))
The element omega = F.gen(), which is (1+sqrt(5))/2 maps to
(1+x)/2 = (1/2, 1/2), which is the generator of this ring.
EXAMPLES::
sage: from psage.modform.hilbert.sqrt5.sqrt5 import F, residue_ring
sage: P = F.primes_above(5)[0]; P
Fractional ideal (2*a - 1)
sage: R = residue_ring(P^5)
sage: a = R(F.gen()); a
[0 + 1*sqrt(5)]
sage: a*a
[5 + 0*sqrt(5)]
sage: a*a*a
[0 + 5*sqrt(5)]
sage: a*a*a*a
[0 + 0*sqrt(5)]
"""
def __init__(self, N, P, p, e):
self._N = N
self._F = P.number_field()
self._p = p
from sage.rings.all import Integers
f = e//2 + 1
assert f*2 - 1 == e
R0 = Integers(p**f)
R1 = Integers(p**(f-1))
self._ring = RamifiedProductRing(R0, R1)
self._im_gen = self._ring.gen()
self._sqrt5 = (self._F.gen()*2-1)**2
def lift(self, x):
return x[0].lift() + self._sqrt5 * x[1].lift()
class RamifiedProductRingElement:
def __init__(self, parent, x, check=True):
self._parent = parent
if isinstance(x, RamifiedProductRingElement) and x._parent is parent:
self._x = x
else:
if check:
if isinstance(x, (list, tuple, RamifiedProductRingElement)):
self._x = (parent._R0(x[0]), parent._R1(x[1]))
else:
self._x = (parent._R0(x), parent._R1(0))
else:
self._x = (x[0], x[1])
def __getitem__(self, i):
return self._x[i]
def __repr__(self):
return '[%s + %s*sqrt(5)]'%self._x
def __add__(left, right):
a, b = left._x
c, d = right._x
return RamifiedProductRingElement(left._parent, [a+b, c+d], check=False)
def __sub__(left, right):
a, b = left._x
c, d = right._x
return RamifiedProductRingElement(left._parent, [a-b, c-d], check=False)
def __mul__(left, right):
a, b = left._x
c, d = right._x
return RamifiedProductRingElement(left._parent, [a*c+b*d*5, a*d+b*c], check=False)
class RamifiedProductRing:
def __init__(self, R0, R1):
self._R0 = R0
self._R1 = R1
self._gen = self([ZZ(1)/2, ZZ(1)/2])
def __call__(self, x):
return RamifiedProductRingElement(self, x)
def gen(self):
return self._gen
class Mod_P_reduction_map:
def __init__(self, P):
FAC = P.factor()
assert len(FAC) == 1
self._p, self._e = FAC[0]
self._I, self._J, self._residue_ring = self._compute_IJ(self._p, self._e)
self._IJ = self._I*self._J
def __repr__(self):
return "(Partial) homomorphism from %s onto 2x2 matrices modulo %s^%s"%(
B, self._p._repr_short(), self._e)
def domain(self):
return B
def codomain(self):
return self._I.parent()
def __call__(self, x):
R = self._residue_ring
if x.parent() is not B:
x = B(x)
return R(x[0]) + self._I*R(x[1]) + self._J*R(x[2]) + self._IJ*R(x[3])
def _compute_IJ(self, p, e):
global B, F
if p.number_field() != B.base():
raise ValueError, "p must be a prime ideal in the base field of the quaternion algebra"
if not p.is_prime():
raise ValueError, "p must be prime"
if p.number_field() != B.base():
raise ValueError, "p must be a prime ideal in the base field of the quaternion algebra"
if not p.is_prime():
raise ValueError, "p must be prime"
if F is not p.number_field():
raise ValueError, "p must be a prime of %s"%F
R = residue_ring(p**e)
if isinstance(R, ResidueRing_base):
k = R.ring()
else:
k = R
from sage.all import MatrixSpace
M = MatrixSpace(k, 2)
i2, j2 = B.invariants()
i2 = R(i2); j2 = R(j2)
if k.characteristic() == 2:
raise NotImplementedError
# Find I -- just write it down
I = M([0,i2,1,0])
# Find J -- I figured this out by just writing out the general case
# and seeing what the parameters have to satisfy
i2inv = k(1)/i2
a = None
for b in R.list():
if not b: continue
c = j2 + i2inv * b*b
if c.is_square():
a = -c.sqrt()
break
if a is None:
# do a fallback search; needed in char 3 sometimes.
for J in M:
K = I*J
if J*J == j2 and K == -J*I:
return I, J, K
J = M([a,b,(j2-a*a)/b, -a])
K = I*J
assert K == -J*I, "bug in that I,J don't skew commute"
return I, J, R
| Python |
#################################################################################
#
# (c) Copyright 2010 William Stein
#
# This file is part of PSAGE
#
# PSAGE is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# PSAGE is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
#
#################################################################################
"""
Weight 2 Hilbert modular forms over F = Q(sqrt(5)).
"""
from sage.misc.cachefunc import cached_method
from sqrt5 import F, O_F
from psage.number_fields.sqrt5 import primes_of_bounded_norm
from sqrt5_fast import IcosiansModP1ModN
from sage.rings.all import is_Ideal, Integer, prime_divisors, QQ, next_prime, ZZ
from tables import ideals_of_norm
from sage.matrix.all import matrix
from sage.structure.all import Sequence
def ideal(X):
if not is_Ideal(X):
return O_F.ideal(X)
return X
def next_prime_of_characteristic_coprime_to(P, I):
p = next_prime(P.smallest_integer())
N = ZZ(I.norm())
while N%p == 0:
p = next_prime(p)
return F.primes_above(p)[0]
def next_prime_not_dividing(P, I):
while True:
p = P.smallest_integer()
if p == 1:
Q = F.ideal(2)
elif p % 5 in [2,3]: # inert
Q = F.primes_above(next_prime(p))[0]
elif p == 5:
Q = F.ideal(7)
else: # p split
A = F.primes_above(p)
if A[0] == P:
Q = A[1]
else:
Q = F.primes_above(next_prime(p))[0]
if not Q.divides(I):
return Q
else:
P = Q # try again
class Space(object):
def __cmp__(self, right):
if not isinstance(right, Space):
raise NotImplementedError
return cmp((self.level(), self.dimension(), self.vector_space()),
(right.level(), right.dimension(), right.vector_space()))
def subspace(self, V):
raise NotImplementedError
def vector_space(self):
raise NotImplementedError
def basis(self):
return self.vector_space().basis()
def new_subspace(self, p=None):
"""
Return (p-)new subspace of this space of Hilbert modular forms.
WARNING: There are known examples where this is still wrong somehow...
INPUT:
- p -- None or a prime divisor of the level
OUTPUT:
- subspace of this space of Hilbert modular forms
EXAMPLES::
We make a space of level a product of 2 split primes and (2)::
sage: from psage.modform.hilbert.sqrt5.hmf import F, HilbertModularForms
sage: P = F.prime_above(31); Q = F.prime_above(11); R = F.prime_above(2)
sage: H = HilbertModularForms(P*Q*R); H
Hilbert modular forms of dimension 32, level 2*a-38 (of norm 1364=2^2*11*31) over QQ(sqrt(5))
The full new space::
sage: N = H.new_subspace(); N
Subspace of dimension 22 of Hilbert modular forms of dimension 32, level 2*a-38 (of norm 1364=2^2*11*31) over QQ(sqrt(5))
The new subspace for each prime divisor of the level::
sage: N_P = H.new_subspace(P); N_P
Subspace of dimension 31 of Hilbert modular forms of dimension 32, level 2*a-38 (of norm 1364=2^2*11*31) over QQ(sqrt(5))
sage: N_Q = H.new_subspace(Q); N_Q
Subspace of dimension 28 of Hilbert modular forms of dimension 32, level 2*a-38 (of norm 1364=2^2*11*31) over QQ(sqrt(5))
sage: N_R = H.new_subspace(R); N_R
Subspace of dimension 24 of Hilbert modular forms of dimension 32, level 2*a-38 (of norm 1364=2^2*11*31) over QQ(sqrt(5))
sage: N_P.intersection(N_Q).intersection(N_R) == N
True
"""
V = self.degeneracy_matrix(p).kernel()
return self.subspace(V)
def decomposition(self, B, verbose=False):
"""
Return Hecke decomposition of self using Hecke operators T_p
coprime to the level with norm(p) <= B.
"""
# TODO: rewrite to use primes_of_bounded_norm so that we
# iterate through primes ordered by *norm*, which is
# potentially vastly faster. Delete these functions
# involving characteristic!
p = next_prime_of_characteristic_coprime_to(F.ideal(1), self.level())
T = self.hecke_matrix(p)
D = T.decomposition()
while len([X for X in D if not X[1]]) > 0:
p = next_prime_of_characteristic_coprime_to(p, self.level())
if p.norm() > B:
break
if verbose: print p.norm()
T = self.hecke_matrix(p)
D2 = []
for X in D:
if X[1]:
D2.append(X)
else:
if verbose: print T.restrict(X[0]).fcp()
for Z in T.decomposition_of_subspace(X[0]):
D2.append(Z)
D = D2
D = [self.subspace(X[0]) for X in D]
D.sort()
S = Sequence(D, immutable=True, cr=True, universe=int, check=False)
return S
def new_decomposition(self, verbose=False):
"""
Return complete irreducible Hecke decomposition of new subspace of self.
"""
V = self.degeneracy_matrix().kernel()
p = next_prime_of_characteristic_coprime_to(F.ideal(1), self.level())
T = self.hecke_matrix(p)
D = T.decomposition_of_subspace(V)
while len([X for X in D if not X[1]]) > 0:
p = next_prime_of_characteristic_coprime_to(p, self.level())
if verbose: print p.norm()
T = self.hecke_matrix(p)
D2 = []
for X in D:
if X[1]:
D2.append(X)
else:
if verbose: print T.restrict(X[0]).fcp()
for Z in T.decomposition_of_subspace(X[0]):
D2.append(Z)
D = D2
D = [self.subspace(X[0]) for X in D]
D.sort()
S = Sequence(D, immutable=True, cr=True, universe=int, check=False)
return S
class HilbertModularForms(Space):
def __init__(self, level):
"""
Space of Hilbert modular forms of weight (2,2) over Q(sqrt(5)).
INPUT:
- level -- an ideal or element of ZZ[(1+sqrt(5))/2].
TESTS::
sage: import psage
sage: H = psage.hilbert.sqrt5.HilbertModularForms(3); H
Hilbert modular forms of dimension 1, level 3 (of norm 9=3^2) over QQ(sqrt(5))
sage: loads(dumps(H)) == H
True
"""
self._level = ideal(level)
self._gen = self._level.gens_reduced()[0]
self._icosians_mod_p1 = IcosiansModP1ModN(self._level)
self._dimension = self._icosians_mod_p1.cardinality()
self._vector_space = QQ**self._dimension
self._hecke_matrices = {}
self._degeneracy_matrices = {}
def __repr__(self):
return "Hilbert modular forms of dimension %s, level %s (of norm %s=%s) over QQ(sqrt(5))"%(
self._dimension, str(self._gen).replace(' ',''),
self._level.norm(), str(self._level.norm().factor()).replace(' ',''))
def intersection(self, M):
if isinstance(M, HilbertModularForms):
assert self == M
return self
if isinstance(M, HilbertModularFormsSubspace):
assert self == M.ambient()
return M
raise TypeError
def level(self):
return self._level
def vector_space(self):
return self._vector_space
def weight(self):
return (Integer(2),Integer(2))
def dimension(self):
return self._dimension
def hecke_matrix(self, n):
# I'm not using @cached_method, since I want to ensure that
# the input "n" is properly normalized. I also want it
# to be transparent to see which matrices have been computed,
# to clear the cache, etc.
n = ideal(n)
if self._hecke_matrices.has_key(n):
return self._hecke_matrices[n]
t = self._icosians_mod_p1.hecke_matrix(n)
t.set_immutable()
self._hecke_matrices[n] = t
return t
T = hecke_matrix
def degeneracy_matrix(self, p=None):
if self.level().is_prime():
return matrix(QQ, self.dimension(), 0, sparse=True)
if p is None:
A = None
for p in prime_divisors(self._level):
if A is None:
A = self.degeneracy_matrix(p)
else:
A = A.augment(self.degeneracy_matrix(p))
return A
p = ideal(p)
if self._degeneracy_matrices.has_key(p):
return self._degeneracy_matrices[p]
d = self._icosians_mod_p1.degeneracy_matrix(p)
d.set_immutable()
self._degeneracy_matrices[p] = d
return d
def __cmp__(self, other):
if not isinstance(other, HilbertModularForms):
raise NotImplementedError
# first sort by norms
return cmp((self._level.norm(), self._level), (other._level.norm(), other._level))
def subspace(self, V):
return HilbertModularFormsSubspace(self, V)
def elliptic_curve_factors(self):
D = [X for X in self.new_decomposition() if X.dimension() == 1]
# Have to get rid of the Eisenstein factor
p = next_prime_of_characteristic_coprime_to(F.ideal(1), self.level())
while True:
q = p.residue_field().cardinality() + 1
E = [A for A in D if A.hecke_matrix(p)[0,0] == q]
if len(E) == 0:
break
elif len(E) == 1:
D = [A for A in D if A != E[0]]
break
else:
p = next_prime_of_characteristic_coprime_to(p, self.level())
return Sequence([EllipticCurveFactor(X, number) for number, X in enumerate(D)],
immutable=True, cr=True, universe=int, check=False)
class HilbertModularFormsSubspace(Space):
def __init__(self, H, V):
assert H.dimension() == V.degree()
self._H = H
self._V = V
def __repr__(self):
return "Subspace of dimension %s of %s"%(self._V.dimension(), self._H)
def subspace(self, V):
raise NotImplementedError
#return HilbertModularFormsSubspace(self._H, V)
def intersection(self, M):
if isinstance(M, HilbertModularForms):
assert self.ambient() == M
return self
if isinstance(M, HilbertModularFormsSubspace):
assert self.ambient() == M.ambient()
H = self.ambient()
V = self.vector_space().intersection(M.vector_space())
return HilbertModularFormsSubspace(H, V)
raise TypeError
def ambient(self):
return self._H
def vector_space(self):
return self._V
def hecke_matrix(self, n):
return self._H.hecke_matrix(n).restrict(self._V)
T = hecke_matrix
def degeneracy_matrix(self, p):
return self._H.degeneracy_matrix(p).restrict_domain(self._V)
def level(self):
return self._H.level()
def dimension(self):
return self._V.dimension()
class EllipticCurveFactor(object):
"""
A subspace of the new subspace of a space of weight 2 Hilbert
modular forms that (conjecturally) corresponds to an elliptic
curve.
"""
def __init__(self, S, number):
"""
INPUT:
- S -- subspace of a space of Hilbert modular forms
- ``number`` -- nonnegative integer indicating some
ordering among the factors of a given level.
"""
self._S = S
self._number = number
def __repr__(self):
"""
EXAMPLES::
sage: from psage.modform.hilbert.sqrt5.hmf import HilbertModularForms, F
sage: H = HilbertModularForms(F.prime_above(31)).elliptic_curve_factors()[0]
sage: type(H)
<class 'psage.modform.hilbert.sqrt5.hmf.EllipticCurveFactor'>
sage: H.__repr__()
'Isogeny class of elliptic curves over QQ(sqrt(5)) attached to form number 0 in Hilbert modular forms of dimension 2, level 5*a-2 (of norm 31=31) over QQ(sqrt(5))'
"""
return "Isogeny class of elliptic curves over QQ(sqrt(5)) attached to form number %s in %s"%(self._number, self._S.ambient())
def base_field(self):
"""
Return the base field of this elliptic curve factor.
OUTPUT:
- the field Q(sqrt(5))
EXAMPLES::
sage: from psage.modform.hilbert.sqrt5.hmf import HilbertModularForms, F
sage: H = HilbertModularForms(F.prime_above(31)).elliptic_curve_factors()[0]
sage: H.base_field()
Number Field in a with defining polynomial x^2 - x - 1
"""
return F
def conductor(self):
"""
Return the conductor of this elliptic curve factor, which is
the level of the space of Hilbert modular forms.
OUTPUT:
- ideal of the ring of integers of Q(sqrt(5))
EXAMPLES::
"""
return self._S.level()
def ap(self, P):
"""
Return the trace of Frobenius at the prime P, for a prime P of
good reduction.
INPUT:
- `P` -- a prime ideal of the ring of integers of Q(sqrt(5)).
OUTPUT:
- an integer
EXAMPLES::
sage: from psage.modform.hilbert.sqrt5.hmf import HilbertModularForms, F
sage: H = HilbertModularForms(F.primes_above(31)[0]).elliptic_curve_factors()[0]
sage: H.ap(F.primes_above(11)[0])
4
sage: H.ap(F.prime_above(5))
-2
sage: H.ap(F.prime_above(7))
2
We check that the ap we compute here match with those of a known elliptic curve
of this conductor::
sage: a = F.0; E = EllipticCurve(F, [1,a+1,a,a,0])
sage: E.conductor().norm()
31
sage: 11+1 - E.change_ring(F.primes_above(11)[0].residue_field()).cardinality()
4
sage: 5+1 - E.change_ring(F.prime_above(5).residue_field()).cardinality()
-2
sage: 49+1 - E.change_ring(F.prime_above(7).residue_field()).cardinality()
2
"""
if P.divides(self.conductor()):
if (P*P).divides(self.conductor()):
# It is 0, because the reduction is additive.
return ZZ(0)
else:
# TODO: It is +1 or -1, but I do not yet know how to
# compute which without using the L-function.
return '?'
else:
return self._S.hecke_matrix(P)[0,0]
@cached_method
def dual_eigenspace(self, B=None):
"""
Return 1-dimensional subspace of the dual of the ambient space
with the same system of eigenvalues as self. This is useful when
computing a large number of `a_P`.
If we can't find such a subspace using Hecke operators of norm
less than B, then we raise a RuntimeError. This should only happen
if you set B way too small, or self is actually not new.
INPUT:
- B -- Integer or None; if None, defaults to a heuristic bound.
"""
N = self.conductor()
H = self._S.ambient()
V = H.vector_space()
if B is None:
# TODO: This is a heuristic guess at a "Sturm bound"; it's the same
# formula as the one over QQ for Gamma_0(N). I have no idea if this
# is correct or not yet. It is probably much too large. -- William Stein
from sage.modular.all import Gamma0
B = Gamma0(N.norm()).index()//6 + 1
for P in primes_of_bounded_norm(B+1):
P = P.sage_ideal()
if V.dimension() == 1:
return V
if not P.divides(N):
T = H.hecke_matrix(P).transpose()
V = (T - self.ap(P)).kernel_on(V)
raise RuntimeError, "unable to isolate 1-dimensional space"
@cached_method
def dual_eigenvector(self, B=None):
# 1. compute dual eigenspace
E = self.dual_eigenspace(B)
assert E.dimension() == 1
# 2. compute normalized integer eigenvector in dual
return E.basis_matrix()._clear_denom()[0][0]
def aplist(self, B, dual_bound=None, algorithm='dual'):
"""
Return list of traces of Frobenius for all primes P of norm
less than bound. Use the function
psage.number_fields.sqrt5.primes_of_bounded_norm(B)
to get the corresponding primes.
INPUT:
- `B` -- a nonnegative integer
- ``dual_bound`` -- default None; passed to dual_eigenvector function
- ``algorithm`` -- 'dual' (default) or 'direct'
OUTPUT:
- a list of Sage integers
EXAMPLES::
We compute the aplists up to B=50::
sage: from psage.modform.hilbert.sqrt5.hmf import HilbertModularForms, F
sage: H = HilbertModularForms(F.primes_above(71)[1]).elliptic_curve_factors()[0]
sage: v = H.aplist(50); v
[-1, 0, -2, 0, 0, 2, -4, 6, -6, 8, 2, 6, 12, -4]
This agrees with what we get using an elliptic curve of this
conductor::
sage: a = F.0; E = EllipticCurve(F, [a,a+1,a,a,0])
sage: from psage.ellcurve.lseries.aplist_sqrt5 import aplist
sage: w = aplist(E, 50)
sage: v == w
True
We compare the output from the two algorithms up to norm 75::
sage: H.aplist(75, algorithm='direct') == H.aplist(75, algorithm='dual')
True
"""
primes = [P.sage_ideal() for P in primes_of_bounded_norm(B)]
if algorithm == 'direct':
return [self.ap(P) for P in primes]
elif algorithm == 'dual':
v = self.dual_eigenvector(dual_bound)
i = v.nonzero_positions()[0]
c = v[i]
I = self._S.ambient()._icosians_mod_p1
N = self.conductor()
aplist = []
for P in primes:
if P.divides(N):
ap = self.ap(P)
else:
ap = (I.hecke_operator_on_basis_element(P,i).dot_product(v))/c
aplist.append(ap)
return aplist
else:
raise ValueError, "unknown algorithm '%s'"%algorithm
| Python |
#################################################################################
#
# (c) Copyright 2010 William Stein
#
# This file is part of PSAGE
#
# PSAGE is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# PSAGE is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
#
#################################################################################
_multiprocess_can_split_ = True
import random
from sage.all import set_random_seed, primes
from sqrt5 import *
from sqrt5_fast import *
def prime_powers(B=100, emax=5):
for p in primes(B+1):
for P in F.primes_above(p):
for e in range(1,emax+1):
yield p, P, e
################################################################
# Tests of Residue Rings
################################################################
def residue_rings(B=100, emax=5):
for p, P, e in prime_powers(B, emax):
yield ResidueRing(P, e)
def residue_ring_creation(B=100, emax=5):
alpha = -F.gen() - 3
for R in residue_rings(B, emax):
R.residue_field()
R._moduli()
zero = R(0); one = R(1)
assert R(alpha) - R(alpha) == zero
assert one - one == zero
str(R)
assert R[0] == zero
assert R[1] == one
def test_residue_ring_1():
residue_ring_creation(B=100, emax=4)
def test_residue_ring_2():
residue_ring_creation(B=35, emax=6)
def test_residue_ring_3():
residue_ring_creation(B=200, emax=2)
def residue_ring_arith(P, e, n=None):
"""
Test that arithmetic in the residue field is correct.
"""
set_random_seed(0)
R = ResidueRing(P, e)
n0, n1 = R._moduli()
alpha = F.gen()
reps = [i+j*alpha for i in range(n0) for j in range(n1)]
if n is not None:
reps = [reps[random.randrange(len(reps))] for i in range(n)]
reps_mod = [R(a) for a in reps]
for i in range(len(reps)):
for j in range(len(reps)):
assert reps_mod[i] * reps_mod[j] == R(reps[i] * reps[j])
assert reps_mod[i] + reps_mod[j] == R(reps[i] + reps[j])
assert reps_mod[i] - reps_mod[j] == R(reps[i] - reps[j])
def test_residue_ring_arith2():
for i in range(1,4):
residue_ring_arith(F.primes_above(2)[0], i)
def test_residue_ring_arith3():
for i in range(1,4):
residue_ring_arith(F.primes_above(2)[0], i, 50)
def test_residue_ring_arith5():
for i in range(1,4):
residue_ring_arith(F.primes_above(5)[0], i, 50)
def test_residue_ring_arith11():
for i in range(1,4):
residue_ring_arith(F.primes_above(11)[0], i, 50)
residue_ring_arith(F.primes_above(11)[1], i, 50)
################################################################
# Testing pow function on elements
################################################################
def test_pow():
def f(B,e):
for R in residue_rings(B,e):
for a in R:
b = a*a
for i in range(4):
assert b == a**(i+2)
if a.is_unit():
assert ~b == a**(-(i+2))
b *= a
f(100,1)
f(11,3)
################################################################
# Testing is_square in case of degree 1
################################################################
def is_square_0(B=11, emax=2):
for R in residue_rings(B, emax):
assert set([x*x for x in R]) == set([x for x in R if x.is_square()])
def test_is_square_0():
is_square_0(20,2)
is_square_0(12,3)
def test_is_square_2(emax=6):
for R in residue_rings(2, emax):
assert set([x*x for x in R]) == set([x for x in R if x.is_square()])
def test_is_square_5(emax=5):
P = F.primes_above(5)[0]
for e in range(1,emax+1):
R = ResidueRing(P, e)
assert set([x*x for x in R]) == set([x for x in R if x.is_square()])
################################################################
# Testing sqrt function on elements
################################################################
def test_sqrt1(B=11,emax=2):
for R in residue_rings(B,emax):
for a in R:
b = a*a
assert b.is_square()
assert b.sqrt()**2 == b
def test_sqrt2(B=11,emax=2):
for R in residue_rings(B,emax):
for a in R:
if a.is_square():
assert a.sqrt()**2 == a
def test_sqrt5(emax=4):
P = F.primes_above(5)[0]
for e in range(1,emax+1):
for a in ResidueRing(P, e):
if a.is_square():
assert a.sqrt()**2 == a
def test_sqrt5b(emax=4):
P = F.primes_above(5)[0]
for e in range(1,emax+1):
if e % 2: continue
for a in ResidueRing(P,e):
b = a*a
assert b.is_square()
assert b.sqrt()**2 == b
################################################################
# Test computing local splitting map
################################################################
def test_local_splitting_maps(B=11,e=3, verbose=True):
ans = []
for p, P, e in prime_powers(B,e):
print p, P, e
r = ModN_Reduction(P**e)
def test_local_splitting_maps_1():
test_local_splitting_maps(100,2)
def test_local_splitting_maps_2():
test_local_splitting_maps(11,5)
################################################################
# Test computing R^* \ P^1
################################################################
def test_icosians_mod_p1(B=11, e=3):
for p, P, e in prime_powers(B,e):
H = IcosiansModP1ModN(P**e)
################################################################
# Testing mod_long functions
################################################################
def test_sqrtmod_long_2(e_max=15):
for e in range(1, e_max+1):
R = Integers(2**e)
X = set([a*a for a in R])
for b in X:
c = sqrtmod_long(int(b), 2, e)
assert c*c == b
################################################################
# Test Hecke operators commute
################################################################
def test_hecke_commutes(Bmin=2, Bmax=50):
from tables import ideals_of_bounded_norm
from hmf import HilbertModularForms, next_prime_of_characteristic_coprime_to
for N in ideals_of_bounded_norm(Bmax):
if N.norm() < Bmin: continue
print N.norm()
H = HilbertModularForms(N)
p = next_prime_of_characteristic_coprime_to(F.ideal(1), N)
q = next_prime_of_characteristic_coprime_to(p, N)
print p, q
T_p = H.T(p)
T_q = H.T(q)
assert T_p*T_q == T_q*T_p, "Hecke operators T_{%s} and T_{%s} at level %s (of norm %s) don't commute"%(p, q, N, N.norm())
################################################################
# New subspaces
################################################################
## def test_compute_new_subspace(Bmin=2, Bmax=200, try_hecke=False):
## from tables import ideals_of_bounded_norm
## from hmf import HilbertModularForms, next_prime_of_characteristic_coprime_to
## for N in ideals_of_bounded_norm(Bmax):
## if N.norm() < Bmin: continue
## print N.norm()
## H = HilbertModularForms(N)
## NS = H.new_subspace()
## if try_hecke:
## p = next_prime_of_characteristic_coprime_to(F.ideal(1), N)
## NS.hecke_matrix(p)
def test_hecke_invariance_of_new_subspace(Bmin=2, Bmax=300):
from tables import ideals_of_bounded_norm
from hmf import HilbertModularForms, next_prime_of_characteristic_coprime_to
for N in ideals_of_bounded_norm(Bmax):
if N.norm() < Bmin: continue
print N.norm()
H = HilbertModularForms(N)
NS = H.new_subspace()
p = next_prime_of_characteristic_coprime_to(F.ideal(1), N)
q = next_prime_of_characteristic_coprime_to(p, N)
print p, q
T_p = NS.T(p)
T_q = NS.T(q)
assert T_p*T_q == T_q*T_p, "Hecke operators T_{%s} and T_{%s} at level %s (of norm %s) don't commute"%(p, q, N, N.norm())
| Python |
#######################################################################################
# Compute local splitting at 2 by successive lifting argument.
#######################################################################################
"""
This is on pages 9-10 of my research notes on 2010-11-07.
The mod-2 splitting must be done differently because I,J do *not*
generate the icosian ring over O_F, because of the 2's in the
denominator.
The icosian ring has generators given above, call them w0,w1,w2,w3. Using linear algebra
we find that w0^2=w0-1, w1^2=-1, w2^2=-1, w3^2=-1. Moreover, and most importantly, we have
letting g=(1+sqrt(5))/2, that
w0 = (g-1)*(2*g*w3 - w1 - w2 - w1*w2)
w3 = g*w0 + w2*w1
Thus mod 2, w0 and w3 are completely determined by w1 and w2.
Also, because of the 2 coefficient of w3 in the first equation,
modulo 2^i, w0 and w3 are completely determined if we know w1, w2, and w3 mod 2^(i-1).
We have several functions below. The one called find_mod2_splitting iterates
through all of M_2(O/2O) finding the possibilities for w1 and w2, i.e., matrices
with square minus 1. For each, we let w0 and w3 be the corresponding matrices
given by the above formulas, verify that we get four independent matrices, and
that the minpoly conditions on w0 and w3 hold. We thus construct a matrix
algebra Alg over F_4 satisfying all the above relations, and get a map R -->> Alg.
[[I have some worry though -- what if somehow not *all* the right relations hold?!]]
Next we lift from mod p^(i-1) to mod p^i. This uses the following algebra.
Suppose A^2 = -1 (mod 2^(i-1)) and (A+2^(i-1)*B)^2 = -1 (mod 2^i).
Then A^2+2^(i-1)(AB+BA) + 2^(2(i-1))*B^2=-1 (mod 2^i).
Thus (-1+2^(i-1)*C) + 2^i*(AB+BA) = -1 (mod 2^i)
So we need C + AB + BA = 0 (mod 2), where C = (A^2+1)/2^i in Mat(O/2O).
To find the B's with this property, we just loop through Mat(O/2O), and test
the condition C+AB+BA in Mat(O/2O).
TODO: This implementation is slow. This is since matrix arithmetic is
generic, and generic matrix arithmetic is double dog slow (100 times
too slow). I think the algorithm itself is solid.
"""
from sqrt5_fast import ResidueRing
from sage.matrix.all import MatrixSpace, matrix
from sqrt5 import F, B, icosian_ring_gens
from sage.misc.all import cached_function
@cached_function
def find_mod2_splitting():
P = F.primes_above(2)[0]
k = P.residue_field()
M = MatrixSpace(k,2)
V = k**4
g = k.gen() # image of golden ratio
m1 = M(-1)
sqrt_minus_1 = [(w, V(w.list())) for w in M if w*w == m1]
one = M(1)
v_one = V(one.list())
for w1, v1 in sqrt_minus_1:
for w2, v2 in sqrt_minus_1:
w0 = (g-1)*(w1+w2 - w1*w2)
w3 = g*w0 + w2*w1
if w0*w0 != w0 - 1:
continue
if w3*w3 != -1:
continue
if V.span([w0.list(),v1,v2,w3.list()]).dimension() == 4:
return w0, w1, w2, w3
def matrix_lift(A):
R = A.base_ring()
return matrix(A.nrows(),A.ncols(),[R.lift(x) for x in A.list()])
@cached_function
def find_mod2pow_splitting(i):
P = F.primes_above(2)[0]
if i == 1:
R = ResidueRing(P, 1)
M = MatrixSpace(R,2)
return [M(matrix_lift(a).list()) for a in find_mod2_splitting()]
R = ResidueRing(P, i)
M = MatrixSpace(R,2)
# arbitrary lift
wbar = [M(matrix_lift(a).list()) for a in find_mod2pow_splitting(i-1)]
# Find lifts of wbar[1] and wbar[2] that have square -1
k = P.residue_field()
Mk = MatrixSpace(k, 2)
t = 2**(i-1)
s = M(t)
L = []
for j in [1,2]:
C = Mk(matrix_lift(wbar[j]**2 + M(1)) / t)
A = Mk(matrix_lift(wbar[j]))
# Find all matrices B in Mk such that AB+BA=C.
L.append([wbar[j]+s*M(matrix_lift(B)) for B in Mk if A*B + B*A == C])
g = M(F.gen())
t = M(t)
two = M(2)
ginv = M(F.gen()**(-1))
for w1 in L[0]:
for w2 in L[1]:
w0 = ginv*(two*g*wbar[3] -w1 -w2 - w1*w2)
w3 = g*w0 + w2*w1
if w0*w0 != w0 - M(1):
continue
if w3*w3 != M(-1):
continue
return w0, w1, w2, w3
raise ValueError
| Python |
#################################################################################
#
# (c) Copyright 2010 William Stein
#
# This file is part of PSAGE
#
# PSAGE is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# PSAGE is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
#
#################################################################################
from hmf import HilbertModularForms
from tables import primes_of_bounded_norm
| Python |
#################################################################################
#
# (c) Copyright 2010 William Stein
#
# This file is part of PSAGE
#
# PSAGE is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# PSAGE is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
#
#################################################################################
import sqrt5
| Python |
"""
Theta constants
"""
def _compute_theta_char_poly(char_dict, f):
r"""
Return the coefficient at ``f`` of the Siegel modular form
.. math:
\sum_{l \in\text{char_dict}} \alpha[l] * \prod_i \theta_l[i](8Z).
INPUT:
- ``char_dict`` -- a dictionary whose keys are *tuples* of theta
characteristics and whose values are in some ring.
- ``f`` -- a triple `(a,b,c)` of rational numbers such that the
quadratic form `[a,b,c]` is semi positive definite
(i.e. `a,c \geq 0` and `b^2-4ac \leq 0`).
EXAMPLES::
sage: from sage.modular.siegel.theta_constant import _multiply_theta_char
sage: from sage.modular.siegel.theta_constant import _compute_theta_char_poly
sage: theta_constants = {((1, 1, 0, 0), (0, 0, 1, 1), (1, 1, 0, 0), (0, 0, 1, 1)): 1}
sage: _compute_theta_char_poly(theta_constants, [2, 0, 10])
32
sage: _compute_theta_char_poly(theta_constants, [2, 0, 2])
8
sage: _compute_theta_char_poly(theta_constants, [0, 0, 0])
0
"""
return sum(_multiply_theta_char(list(l), f)*char_dict[l] for l in char_dict)
def _multiply_theta_char(l, f):
r"""
Return the coefficient at ``f`` of the theta series `\prod_t \theta_t`
where `t` runs through the list ``l`` of theta characteristics.
INPUT:
- ``l`` -- a list of quadruples `t` in `{0,1}^4`
- ``f`` -- a triple `(a,b,c)` of rational numbers such that the
quadratic form `[a,b,c]` is semi positive definite
(i.e. `a,c \geq 0` and `b^2-4ac \leq 0`).
EXAMPLES::
sage: from sage.modular.siegel.theta_constant import _multiply_theta_char
sage: from sage.modular.siegel.theta_constant import _compute_theta_char_poly
sage: tc = [(1, 1, 0, 0), (0, 0, 1, 1), (1, 1, 0, 0), (0, 0, 1, 1)]
sage: _multiply_theta_char(tc, [2, 0, 6])
-32
sage: _multiply_theta_char(tc, [2, 0, 10])
32
sage: _multiply_theta_char(tc, [0, 0, 0])
0
"""
if 0 == len(l):
return (1 if (0, 0, 0) == f else 0)
a, b, c = f
m1, m2, m3, m4 = l[0]
# if the characteristic is not even:
if 1 == (m1*m3 + m2*m4)%2:
return 0
coeff = 0
from sage.misc.all import isqrt, xsrange
for u in xsrange(m1, isqrt(a)+1, 2):
for v in xsrange(m2, isqrt(c)+1, 2):
if 0 == u and 0 == v:
coeff += _multiply_theta_char(l[1:], (a, b, c))
continue
ap, bp, cp = (a-u*u, b-2*u*v, c-v*v)
if bp*bp-4*ap*cp <= 0:
val = (2 if 0 == (u*m3 + v*m4)%4 else -2)
coeff += val * _multiply_theta_char(l[1:], (ap, bp, cp))
if u != 0 and v != 0:
ap, bp, cp = (a-u*u, b+2*u*v, c-v*v)
if bp*bp-4*ap*cp <= 0:
val = (2 if 0 == (u*m3 - v*m4)%4 else -2)
coeff += val * _multiply_theta_char(l[1:], (ap, bp, cp))
return coeff
| Python |
r"""
Siegel modular forms
Implementation of a class describing (scalar and vector valued) Siegel
modular forms of degree 2 and arbitrary group and weight.
AUTHORS:
- CC: Craig Citro
- MR: Martin Raum
- NR: Nathan Ryan
- NS: Nils-Peter Skoruppa
HISTORY:
- NS: Class SiegelModularForm_class.
- NS: Factory function SiegelModularForm().
Code parts concerning the Maass lift are partly based on code
written by David Gruenewald in August 2006 which in turn is
based on the PARI/GP code by Nils-Peter Skoruppa from 2003.
- CC, NR: _mult_, _reduce_GL using Cython.
- NR: Hecke operators.
- CC: Rewriting of fastmult.spyx for arbitrary base rings.
- NS: Class Morp.
- MR, NS: SiegelModularFormsAlgebra_class, SiegelModularFormsAlgebra
REFERENCES:
- [Sko] Nils-Peter Skoruppa, ...
- [I-H] Tomoyoshi Ibukiyama and Shuichi Hayashida, ...
"""
#*****************************************************************************
# Copyright (C) 2008 Nils-Peter Skoruppa <nils.skoruppa@uni-siegen.de>
#
# Distributed under the terms of the GNU General Public License (GPL)
# http://www.gnu.org/licenses/
#*****************************************************************************
import cPickle
import urllib
from siegel_modular_form_prec import SiegelModularFormPrecision
from sage.rings.all import ZZ
from sage.algebras.all import AlgebraElement
SMF_DEFAULT_PREC = 101
class SiegelModularForm_class(AlgebraElement):
r"""
Describes a Siegel modular form of degree 2.
"""
def __init__(self, parent, weight, coeffs, prec=SMF_DEFAULT_PREC, name=None):
r"""
Create a Siegel modular form of degree 2.
INPUT:
- ``parent`` -- SiegelModularFormsAlgebra (ambient space).
- ``weight`` -- the weight of the form.
- ``coeffs`` -- a dictionary whose keys are triples `(a,b,c)`
of integers representing `GL(2,\ZZ)`-reduced quadratic forms
(i.e. forms satisfying `0 \le b \le a \le c`).
- ``name`` -- an optional string giving a name to the form,
e.g. 'Igusa_4'. This modifies the text and latex
representations of the form.
OUTPUT:
- a Siegel modular form
EXAMPLES::
sage: E10 = ModularForms(1, 10).0
sage: Delta = CuspForms(1, 12).0
sage: F = SiegelModularForm(E10, Delta); F
Siegel modular form on Sp(4,Z) of weight 10
TESTS::
sage: TestSuite(F).run()
"""
self.__group = parent.group()
self.__weight = weight
self.__coeffs = coeffs
# TODO: check whether we have enough coeffs
self.__coeff_ring = parent.coeff_ring()
self.__precision = SiegelModularFormPrecision(prec)
self.__prec = _normalized_prec(prec)
self.__name = name
self.__rep_lists = dict()
AlgebraElement.__init__(self, parent)
def base_ring(self):
"""
Return the ring of coefficients of the Siegel modular form ``self``.
EXAMPLES::
sage: S = SiegelModularFormsAlgebra()
sage: A = S.gen(0)
sage: A.base_ring()
Integer Ring
sage: C = S.gen(2)
sage: onehalfC = C * (-1/2)
sage: onehalfC.base_ring()
Rational Field
sage: B = S.gen(1)
sage: AB = A.satoh_bracket(B)
sage: AB.base_ring()
Multivariate Polynomial Ring in x, y over Rational Field
"""
return self.__coeff_ring
def _repr_(self):
r"""
Return the plain text representation of ``self``.
EXAMPLES::
sage: C = SiegelModularFormsAlgebra().gen(2)
sage: C._repr_()
'Igusa_10'
sage: (C^2)._repr_()
'Siegel modular form on Sp(4,Z) of weight 20'
"""
if self.name() is None:
return 'Siegel modular form on %s of weight %d' % (self.group(), self.weight())
else:
return self.name()
def _latex_(self):
r"""
Return the latex representation of ``self``.
EXAMPLES::
sage: A = SiegelModularFormsAlgebra().gen(0)
sage: A._latex_()
'Igusa_4'
sage: (A^2)._latex_()
'\\texttt{Siegel modular form on }Sp(4,Z)\\texttt{ of weight }8'
"""
if self.name() is None:
return r'\texttt{Siegel modular form on }%s\texttt{ of weight }%d' % (self.group(), self.weight())
else:
return self.name()
def group(self):
r"""
Return the modular group of ``self`` as a string.
EXAMPLES::
sage: C = SiegelModularFormsAlgebra().gen(2)
sage: C.group()
'Sp(4,Z)'
"""
return self.__group
def weight(self):
r"""
Return the weight of ``self``.
EXAMPLES::
sage: A, B, C, D = SiegelModularFormsAlgebra().gens()
sage: A.weight()
4
sage: B.weight()
6
sage: C.weight()
10
sage: D.weight()
12
sage: (A * B).weight()
10
sage: (A*B + C).weight()
10
"""
return self.__weight
def precision(self):
r"""
Return the Precision class object that describes the precision of ``self``.
EXAMPLES::
sage: A = SiegelModularFormsAlgebra().gen(0)
sage: A.precision()
Discriminant precision for Siegel modular form with bound 101
"""
return self.__precision
def __getitem__(self, key):
r"""
Return the coefficient indexed by ``key`` in the Fourier expansion
of ``self``.
INPUT:
- ``key`` -- a triple of integers `(a, b, c)` defining a quadratic form
OUTPUT:
- the coefficient of `q^{(a,b,c)}` as an element of the coefficient
ring of ``self``
EXAMPLES::
sage: A, B, C, D = SiegelModularFormsAlgebra().gens()
sage: A[(0, 0, 10)]
272160
sage: A[(0, 0, 25)]
3780240
sage: A[(5, 0, 5)]
97554240
sage: A[(0, 0, 26)]
Traceback (most recent call last):
...
ValueError: precision 101 is not high enough to extract coefficient at (0, 0, 26)
sage: A[(100, 0, 1)]
Traceback (most recent call last):
...
ValueError: precision 101 is not high enough to extract coefficient at (100, 0, 1)
sage: C[(2, 1, 3)]
2736
sage: C[(3, 1, 2)]
2736
Any coefficient indexed by a quadratic form that is not semi-positive
definite is by definition zero::
sage: A[(-1, 1, 1)]
0
sage: A[(1, 10, 1)]
0
TESTS::
sage: A[(1/2, 0, 6)]
Traceback (most recent call last):
...
TypeError: the key (1/2, 0, 6) must be an integral quadratic form
"""
a, b, c = key
try:
a = ZZ(a)
b = ZZ(b)
c = ZZ(c)
except TypeError:
raise TypeError, "the key %s must be an integral quadratic form" %str(key)
if b**2 - 4*a*c > 0 or a < 0 or c < 0:
return self.base_ring()(0)
## otherwise we have a semi-positive definite form
if self.__coeffs.has_key((a, b, c)):
return self.__coeffs[(a, b, c)]
## otherwise GL2(ZZ)-reduce (a,b,c) and try again
from fastmult import reduce_GL
(a0, b0, c0) = reduce_GL(a, b, c)
if self.precision().is_in_bound((a0, b0, c0)):
## return get_coeff_with_action( a,b,c,self.coeffs(),self.base_ring())
return self.__coeffs.get((a0, b0, c0), self.base_ring()(0))
## otherwise error - precision is too low
raise ValueError, 'precision %s is not high enough to extract coefficient at %s' %(self.prec(), str(key))
def coeffs(self, disc=None):
r"""
Return the dictionary of coefficients of ``self``. If ``disc`` is
specified, return the dictionary of coefficients indexed by
semi-positive definite quadratic forms of discriminant ``disc``.
INPUT:
- ``disc`` -- optional (default: None); a negative integer giving
the discriminant of a semi-positive definite quadratic form
EXAMPLES::
sage: A, B, C, D = SiegelModularFormsAlgebra().gens(prec=20)
sage: C.coeffs().has_key((3, 0, 1))
False
sage: C.coeffs().has_key((1, 0, 3))
True
sage: C.coeffs()[(1, 0, 3)]
-272
sage: len(D.coeffs(disc=-16).keys())
2
sage: D.coeffs(disc=-16)[(2, 0, 2)]
17600
TESTS::
sage: A.coeffs(disc=-20)
Traceback (most recent call last):
...
ValueError: precision is not high enough to extract coefficients of discriminant -20
"""
if disc is None:
return self.__coeffs
elif -disc < self.prec():
if disc < 0 and (disc % 4) in [0, 1]:
from sage.quadratic_forms.binary_qf import BinaryQF_reduced_representatives
forms = [f[:] for f in BinaryQF_reduced_representatives(disc)]
return dict([(Q, self[Q]) for Q in forms])
else:
return {}
else:
raise ValueError, 'precision is not high enough to extract coefficients of discriminant %s' %disc
def support(self):
r"""
Return the support of ``self``, i.e. the list of reduced quadratic
forms indexing non-zero Fourier coefficients of ``self``.
EXAMPLES::
sage: A, B, C, D = SiegelModularFormsAlgebra().gens(prec=15)
sage: A.support()
[(0, 0, 0), (0, 0, 1), (0, 0, 2), (0, 0, 3), (1, 0, 1), (1, 0, 2), (1, 0, 3), (1, 1, 1), (1, 1, 2), (1, 1, 3), (2, 2, 2)]
sage: (0, 0, 2) in C._keys()
True
sage: C[(0, 0, 2)]
0
sage: (0, 0, 2) in C.support()
False
"""
return [k for k in self._keys() if self[k] != 0]
def max_disc(self):
r"""
Return the largest discriminant corresponding to a non-zero Fourier
coefficient of ``self``.
Note that since these discriminants are all non-positive, this
corresponds in some sense to the "smallest" non-zero Fourier
coefficient. It is analogous to the valuation of a power series
(=smallest degree of a non-zero term).
EXAMPLES::
sage: gens = SiegelModularFormsAlgebra().gens()
sage: [f.max_disc() for f in gens]
[0, 0, -3, -3]
"""
return max([b**2 - 4*a*c for (a, b, c) in self.support()])
def _keys(self):
r"""
Return the keys of the dictionary of coefficients of ``self``.
EXAMPLES::
sage: A, B, C, D = SiegelModularFormsAlgebra().gens(prec=15)
sage: A._keys()
[(0, 0, 0), (0, 0, 1), (0, 0, 2), (0, 0, 3), (1, 0, 1), (1, 0, 2), (1, 0, 3), (1, 1, 1), (1, 1, 2), (1, 1, 3), (2, 2, 2)]
"""
return sorted(self.coeffs().keys())
def prec(self):
r"""
Return the precision of ``self``.
EXAMPLES::
sage: B = SiegelModularFormsAlgebra().gen(1)
sage: B.prec()
101
"""
return self.precision().prec()
def name(self):
r"""
Return the name of the Siegel modular form ``self``, or None if
``self`` does not have a custom name.
EXAMPLES::
sage: A, B = SiegelModularFormsAlgebra().gens()[:2]
sage: A.name()
'Igusa_4'
sage: (A*B).name() is None
True
"""
return self.__name
def truncate(self, prec):
r"""
Return a Siegel modular form with the same parent as ``self``, but
with Fourier expansion truncated at the new precision ``prec``.
EXAMPLES::
sage: A = SiegelModularFormsAlgebra().gen(0, prec=20); A
Igusa_4
sage: A.prec()
20
sage: len(A._keys())
18
sage: A[(1, 1, 5)]
1330560
sage: At = A.truncate(16); At
Igusa_4
sage: At.prec()
16
sage: len(At._keys())
14
sage: At[(1, 1, 5)]
Traceback (most recent call last):
...
ValueError: precision 16 is not high enough to extract coefficient at (1, 1, 5)
sage: At[(1, 1, 4)] == A[(1, 1, 4)]
True
TESTS::
sage: A.truncate(30)
Traceback (most recent call last):
...
ValueError: truncated precision 30 cannot be larger than the current precision 20
"""
if prec > self.prec():
raise ValueError, 'truncated precision %s cannot be larger than the current precision %s' %(prec, self.prec())
else:
return _SiegelModularForm_from_dict(group=self.group(), weight=self.weight(), coeffs=self.coeffs(), prec=prec, parent=None, name=self.name())
################
## Arithmetic ##
################
def _add_(left, right):
r"""
Return the sum of ``left`` and ``right``.
There are some compatibility conditions that the forms ``left``
and ``right`` must satisfy in order for addition to work:
- they must have the same weight
- they must be defined on the same group, or one of them must
be defined on the whole group 'Sp(4,Z)'
The precision of the sum of ``left`` and ``right`` is the minimum
of the precisions of ``left`` and ``right``.
EXAMPLES::
sage: A, B, C, D = SiegelModularFormsAlgebra().gens()
sage: twoA = A + A
sage: A2 = A * 2
sage: A2 == twoA
True
sage: A*B + C
Siegel modular form on Sp(4,Z) of weight 10
sage: E = C._add_(A*B)
sage: E
Siegel modular form on Sp(4,Z) of weight 10
sage: C[(1, 1, 1)]
1
sage: (A*B)[(1, 1, 1)]
57792
sage: E[(1, 1, 1)]
57793
sage: F = SiegelModularForm('Gamma0(2)', 4, A.coeffs())
sage: F
Siegel modular form on Gamma0(2) of weight 4
sage: A + F
Siegel modular form on Gamma0(2) of weight 4
sage: F + A == F + A
True
sage: (A + F)[(1, 1, 1)] == A[(1, 1, 1)] + F[(1, 1, 1)]
True
sage: A1 = SiegelModularFormsAlgebra().gen(0, prec=20)
sage: (A1 + F).prec()
20
sage: (A1 + F)[(1, 1, 1)] == (A + F)[(1, 1, 1)]
True
TESTS::
sage: A + B
Traceback (most recent call last):
...
ValueError: cannot add Siegel modular forms of different weights
sage: F = SiegelModularForm('Gamma0(2)', 4, A.coeffs())
sage: G = SiegelModularForm('Gamma0(5)', 4, A.coeffs())
sage: F + G
Traceback (most recent call last):
...
TypeError: unsupported operand parent(s) for '+': 'Algebra of Siegel modular forms of degree 2 and even weights on Gamma0(2) over Integer Ring' and 'Algebra of Siegel modular forms of degree 2 and even weights on Gamma0(5) over Integer Ring'
sage: Z = A + (-A)
sage: Z
Siegel modular form on Sp(4,Z) of weight 4
sage: Z.prec()
101
sage: Z.coeffs()
{}
"""
# take the minimum of the precisions and truncate the forms if necessary
lp = left.prec()
rp = right.prec()
if lp < rp:
prec = lp
right = right.truncate(prec)
elif rp < lp:
prec = rp
left = left.truncate(prec)
else:
prec = lp
# figure out the group of the sum = intersection of the groups
# of the two forms
# right now, we only allow two identical groups, or different
# groups where one of them is all of 'Sp(4,Z)'
lg = left.group()
rg = right.group()
if lg is None or lg == 'Sp(4,Z)':
group = rg
elif rg is None or rg == 'Sp(4,Z)':
group = lg
elif lg != rg:
raise NotImplementedError, "addition of forms on different groups not yet implemented"
else:
group = lg
# the sum of two Siegel modular forms is another Siegel modular
# form only if the weights are equal
if left.weight() != right.weight():
raise ValueError, 'cannot add Siegel modular forms of different weights'
else:
wt = left.weight()
# compute the coefficients of the sum
d = dict()
for f in set(left._keys() + right._keys()):
v = left[f] + right[f]
if not v.is_zero(): d[f] = v
par = left.parent()
from sage.modular.siegel.siegel_modular_forms_algebra import SiegelModularFormsAlgebra
par2 = SiegelModularFormsAlgebra(coeff_ring=par.coeff_ring(), group=group, weights=par.weights(), degree=par.degree())
return par2.element_class(parent=par, weight=wt, coeffs=d, prec=prec)
def _mul_(left, right):
r"""
Return the product of the Siegel modular form ``left`` by the
element ``right``, which can be a scalar or another Siegel modular
form.
The multiplication of two forms on arbitrary groups is not yet
implemented. At the moment, the forms must either be on the same
group, or one of the groups must be the full 'Sp(4,Z)'.
EXAMPLES::
sage: A, B, C, D = SiegelModularFormsAlgebra().gens()
sage: A3 = A * 3
sage: B2 = 2 * B
sage: Conehalf = C / 2
sage: Donehalf = (1/2) * D
sage: A3[(1, 1, 1)] / A[(1, 1, 1)]
3
sage: B2[(2, 1, 3)] / B[(2, 1, 3)]
2
sage: Conehalf[(2, 0, 1)] / C[(2, 0, 1)]
1/2
sage: Donehalf[(3, 3, 3)] / D[(3, 3, 3)]
1/2
sage: E = C._mul_(D)
sage: E[(0, 0, 5)]
0
sage: E[(2, 3, 3)]
8
TESTS::
sage: A = SiegelModularFormsAlgebra(default_prec=61).0
sage: A.prec()
61
sage: C = SiegelModularFormsAlgebra(default_prec=81).2
sage: C.prec()
81
sage: A*C == C*A
True
sage: (A*C).prec()
64
"""
from sage.modular.siegel.siegel_modular_forms_algebra import SiegelModularFormsAlgebra
par = left.parent()
from sage.rings.all import infinity
if left.prec() is infinity:
tmp = right
right = left
left = tmp
wt = left.weight() + right.weight()
if wt % 2:
weights = 'all'
else:
weights = 'even'
if right.prec() is infinity:
prec = left.prec()
c = right[(0, 0, 0)]
d = dict()
for f in left.coeffs():
v = left[f] * c
if not v.is_zero(): d[f] = v
par = SiegelModularFormsAlgebra(coeff_ring=par.coeff_ring(), group=par.group(), weights=weights, degree=par.degree())
return par.element_class(parent=par, weight=left.weight(), coeffs=d, prec=prec)
lp = left.prec()
rp = right.prec()
if lp < rp:
right = right.truncate(lp)
elif rp < lp:
left = left.truncate(rp)
prec = min(lp - right.max_disc(), rp - left.max_disc())
if left.group() is None:
group = right.group()
elif right.group() is None:
group = left.group()
elif left.group() != right.group():
raise NotImplementedError, "multiplication for differing groups not yet implemented"
else:
group = left.group()
s1, s2, R = left.coeffs(), right.coeffs(), left.base_ring()
d = dict()
_prec = SiegelModularFormPrecision(prec)
if ZZ == R:
from fastmult import mult_coeff_int
for x in _prec:
v = mult_coeff_int(x[0], x[1], x[2], s1, s2)
if not v.is_zero(): d[x] = v
elif left.parent().base_ring() == left.parent().coeff_ring():
from fastmult import mult_coeff_generic
for x in _prec:
v = mult_coeff_generic(x[0], x[1], x[2], s1, s2, R)
if not v.is_zero(): d[x] = v
else:
from fastmult import mult_coeff_generic_with_action
for x in _prec:
v = mult_coeff_generic_with_action(x[0], x[1], x[2], s1, s2, R)
if not v.is_zero(): d[x] = v
par = SiegelModularFormsAlgebra(coeff_ring=par.coeff_ring(), group=group, weights=weights, degree=par.degree())
return par.element_class(parent=par, weight=wt, coeffs=d, prec=prec)
def _rmul_(self, c):
r"""
Right multiplication -- only by scalars.
EXAMPLES::
sage: A, B, C, D = SiegelModularFormsAlgebra().gens()
sage: onehalfC = C._rmul_(-1/2)
sage: C[(2, 1, 3)]
2736
sage: onehalfC[(2, 1, 3)]
-1368
TESTS::
sage: Z = A._rmul_(0)
sage: Z
Siegel modular form on Sp(4,Z) of weight 4
sage: Z.coeffs()
{}
"""
d = dict()
for f in self.coeffs():
v = self[f] * c
if not v.is_zero(): d[f] = v
par = self.parent()
return par.element_class(parent=par, weight=self.weight(), coeffs=d, prec=self.prec())
def _lmul_(self, c):
r"""
Left multiplication -- only by scalars.
EXAMPLES::
sage: A = SiegelModularFormsAlgebra(default_prec=51).0
sage: A3 = A._lmul_(3)
sage: A[(1, 1, 1)]
13440
sage: A3[(1, 1, 1)]
40320
"""
return self._rmul_(c)
def __eq__(left, right):
r"""
Return True if the Siegel modular forms ``left`` and ``right``
have the same group and weight, and the same coefficients up to
the smaller of the two precisions.
EXAMPLES::
sage: A, B, C, D = SiegelModularFormsAlgebra(default_prec=20).gens()
sage: A2, B2, C2, D2 = SiegelModularFormsAlgebra().gens()
sage: A2 == A
True
sage: A == A
True
sage: A == B
False
TESTS::
sage: E = SiegelModularForm('Gamma0(2)', 6, B.coeffs())
sage: E == B
False
sage: S = SiegelModularFormsAlgebra(default_prec=21)
sage: S(0) == S(0)
True
sage: S(0) == S(1)
False
"""
if not isinstance(right, SiegelModularForm_class):
return False
if left.group() != right.group():
return False
if left.weight() != right.weight():
return False
# we compare up to the minimum of the two precisions
new_prec = min(left.prec(), right.prec())
# if new_prec is infinity, then left and right are both
# constant Siegel modular forms
from sage.rings.all import infinity
if new_prec is infinity:
return left[0, 0, 0] == right[0, 0, 0]
left = left.truncate(new_prec)
right = right.truncate(new_prec)
new_smf_prec = SiegelModularFormPrecision(new_prec)
lc = left.coeffs()
rc = right.coeffs()
# make coefficients that are implicitly zero be actually zero
for k in new_smf_prec:
if not lc.has_key(k):
lc[k] = 0
if not rc.has_key(k):
rc[k] = 0
return lc == rc
def pickle(self, file, format=1, name=None):
r"""
Dump to a file in a portable format.
EXAMPLES::
sage: A = SiegelModularFormsAlgebra(default_prec=20).0
sage: FILE = open('A.sobj', 'w')
sage: A.pickle(FILE)
TO DO
I don't really think I have the right syntax since I couldn't
load it after doing this
"""
from sage.rings.all import QQ
if self.base_ring().fraction_field() == QQ:
pol = [0, 1]
coeffs = self.coeffs()
else:
pol = self.base_ring().polynomial().list()
coeffs = dict()
for k in self.coeffs():
coeffs[k] = self.coeffs()[k].list()
if None == name:
_name = self._repr_()
f1 = 'format %d: [this string, wt, name, pol., prec., dict. of coefficients]' %1
data = [f1, self.weight(), _name, pol, self.prec(), coeffs]
cPickle.dump(data, file)
return
def fourier_jacobi_coeff(self, N):
r"""
Return the `N`-th Fourier-Jacobi coefficient of the Siegel modular
form ``self`` as a dictionary indexed by pairs `(disc,r)` with
`disc<0` and `r^2 \equiv disc \bmod 4N`.
EXAMPLES::
sage: A = SiegelModularFormsAlgebra(default_prec=51).0
sage: fj = A.fourier_jacobi_coeff(1)
sage: fj[(-8, 0)]
181440
"""
prec = self.prec()
NN = 4*N
keys = [(disc, r) for disc in range(prec) for r in range(NN) if (r**2 - disc)%NN == 0]
coeff = dict()
for disc, r in keys:
(a, b, c) = (-(r**2 - disc)/NN, r, N)
coeff[(-disc, r)] = self[(a, b, c)]
return coeff
def satoh_bracket(left, right, names = ['x', 'y']):
r"""
Return the Satoh bracket [``left``, ``right``], where ``left``
and ``right`` are scalar-valued Siegel modular forms.
The result is a vector-valued Siegel modular form whose coefficients
are polynomials in the two variables specified by ``names``.
EXAMPLES::
sage: A, B = SiegelModularFormsAlgebra().gens()[:2]
sage: AB = A.satoh_bracket(B)
sage: AB[(1, 0, 1)]
-20160*x^2 - 40320*y^2
"""
from sage.rings.all import PolynomialRing
R = PolynomialRing(ZZ, names)
x, y = R.gens()
d_left_coeffs = dict((f, (f[0]*x*x + f[1]*x*y + f[2]*y*y)*left[f])
for f in left.coeffs())
d_left = SiegelModularForm(left.group(), left.weight(),
d_left_coeffs, left.prec())
d_right_coeffs = dict((f, (f[0]*x*x + f[1]*x*y + f[2]*y*y)*right[f])
for f in right.coeffs())
d_right = SiegelModularForm(right.group(), right.weight(),
d_right_coeffs, right.prec())
return d_left*right/left.weight() - d_right*left/right.weight()
#################
# Hecke operators
#################
def hecke_image(self, ell):
r"""
Return the Siegel modular form which is the image of ``self`` under
the Hecke operator T(``ell``).
EXAMPLES::
sage: A, B, C, D = SiegelModularFormsAlgebra().gens()
sage: Ups20 = -1/1785600*A*B*C - 1/1785600*A^2*D + C^2
sage: TUps20 = Ups20.hecke_image(2)
sage: TUps20[(1, 1, 1)] / Ups20[(1, 1, 1)]
-840960
sage: TUps20
Siegel modular form on Sp(4,Z) of weight 20
sage: A.hecke_image(5)
T(5)(Igusa_4)
"""
# TODO: compute precision for T(ell)F
from sage.functions.all import ceil
try:
# TODO: I am not sure whether this sets the right prec
a, b, c = self.prec()
prec = (ceil(a/ell), ceil(b/ell), ceil(c/ell))
except TypeError:
prec = ceil(self.prec()/ell/ell)
prec = _normalized_prec(prec)
d = dict((f, self.hecke_coefficient(ell, f)) for f in self._keys() if _is_bounded(f, prec))
if self.name():
name = 'T(' + str(ell) + ')(' + self.name() + ')'
else:
name = None
par = self.parent()
from sage.modular.siegel.siegel_modular_forms_algebra import SiegelModularFormsAlgebra
par = SiegelModularFormsAlgebra(coeff_ring=par.coeff_ring(), group=par.group(), weights=par.weights(), degree=par.degree())
return par.element_class(parent=par, weight=self.weight(), coeffs=d, prec=prec, name=name)
def hecke_coefficient(self, ell, (a, b, c)):
r"""
Return the `(a, b, c)`-indexed coefficient of the image of ``self``
under the Hecke operator T(``ell``).
EXAMPLES::
sage: A, B, C, D = SiegelModularFormsAlgebra().gens()
sage: Ups20 = -1/1785600*A*B*C - 1/1785600*A^2*D + C^2
sage: Ups20.hecke_coefficient(5, (1, 1, 1))
5813608045/992
sage: Ups20.hecke_coefficient(5, (1, 0, 1))
5813608045/248
sage: Ups20.hecke_coefficient(5, (1, 0, 1)) / Ups20[(1, 0, 1)]
-5232247240500
"""
k = self.weight()
coeff = 0
from sage.rings.all import divisors
from sage.quadratic_forms.binary_qf import BinaryQF
qf = BinaryQF([a, b, c])
for t1 in divisors(ell):
for t2 in divisors(t1):
cosets = self._get_representatives(ell, t1/t2)
for V in cosets:
aprime, bprime, cprime = qf.matrix_action_right(V)[:]
if aprime % t1 == 0 and bprime % t2 == 0 and cprime % t2 == 0:
try:
coeff = coeff + t1**(k-2)*t2**(k-1)*self[(ell*aprime/t1**2, ell*bprime/t1/t2, ell*cprime/t2**2)]
except KeyError, msg:
raise ValueError, '%s' %(self,msg)
return coeff
def _get_representatives(self, ell, t):
r"""
A helper function used in hecke_coefficient that computes the right
coset representatives of `\Gamma^0(t)\SL(2,Z)` where `\Gamma^0(t)`
is the subgroup of `SL(2,Z)` where the upper left hand corner is
divisible by `t`.
EXAMPLES::
sage: A = SiegelModularFormsAlgebra().0
sage: A._get_representatives(5, 3)
[
[ 0 1] [1 0] [1 1] [1 2]
[-1 0], [0 1], [0 1], [0 1]
]
NOTE
We use the bijection $\Gamma^0(t)\SL(2,Z) \rightarrow P^1(\Z/t\Z)$
given by $A \mapsto [1:0]A$.
"""
try:
return self.__rep_lists[(ell, t)]
except KeyError:
from sage.matrix.all import MatrixSpace
M = MatrixSpace(ZZ, 2, 2)
if t == 1:
return [M([1, 0, 0, 1])]
from sage.modular.all import P1List
P = list(P1List(t))
from sage.rings.all import IntegerModRing, xgcd
ZZt = IntegerModRing(t)
rep_list = []
for x, y in P1List(t):
e, d, c = xgcd(x, y)
rep = M([x, y, -c, d])
rep_list.append(rep)
self.__rep_lists[(ell, t)] = rep_list
return rep_list
def SiegelModularForm(arg0, arg1=None, arg2=None, prec=None, name=None, hint=None):
r"""
Construct a Siegel modular form.
INPUT:
Supported formats
1. SiegelModularForm(f, g):
creates the Siegel modular form VI(f,g) from the elliptic
modular forms f, g as in [Sko].
Shortforms:
SiegelModularForm(f) for SiegelModularForm(f, 0-form),
SiegelModularForm(f, 0) for SiegelModularForm(f, 0-form),
SiegelModularForm(0, f) for SiegelModularForm(0-form, f).
2. SiegelModularForm(x):
if x is an element of a commutative ring creates the constant
Siegel modular form with value x.
3. SiegelModularForm(string):
creates the Siegel modular form pickled at the location
described by string (url or path_to_file).
4. SiegelModularForm(qf):
constructs the degree 2 theta series associated to the given
quadratic form.
5. SiegelModularForm(f):
--- TODO: Borcherds lift
6. SiegelModularForm(f, g):
--- TODO: Yoshida lift
7. SiegelModularForm(repr):
--- TODO: Lift from Weil representation
8. SiegelModularForm(char):
--- TODO: Singular weight
9. SiegelModularForm(group, weight, dict):
if group is a string, weight an integer and dict a dictionary,
creates a Siegel modular form whose coefficients are contained
in dict.
EXAMPLES::
sage: M4 = ModularForms(1, 4)
sage: M6 = ModularForms(1, 6)
sage: E4 = M4.basis()[0]
sage: F = SiegelModularForm(E4, M6(0), 16); F
Siegel modular form on Sp(4,Z) of weight 4
sage: url = 'http://sage.math.washington.edu/home/nils/Siegel-Modular-Forms/data/upsilon-forms_20-32_1000/Upsilon_20.p' # optional -- internet
sage: H = SiegelModularForm(url); H # optional - internet
Upsilon_20
sage: H[(4, 4, 4)] # optional - internet
248256200704
sage: url = 'http://sage.math.washington.edu/home/nils/Siegel-Modular-Forms/data/upsilon-forms_20-32_1000/Upsilon_28.p' # optional -- internet
sage: L = SiegelModularForm(url); L # optional - internet
Upsilon_28
sage: L.prec() # optional - internet
1001
sage: L[(3, 3, 3)] # optional - internet
-27352334316369546*a^2 + 3164034718941090318*a + 2949217207771097198880
sage: L[(3, 3, 3)].parent() # optional - internet
Number Field in a with defining polynomial x^3 - x^2 - 294086*x - 59412960
sage: l = [(0, 0, 0, 0)]*2 + [(1, 0, 0, 0)] + [(0, 1, 0, 0)] + [(0, 0, 0, 1)] + [(0, 0, 1, 1)]
sage: char_dict = {tuple(l): 1/4}
sage: F = SiegelModularForm(char_dict, prec=100, name="van Geemen F_7"); F
van Geemen F_7
sage: F.coeffs()[(1, 0, 9)]
-7
sage: Q37 = QuadraticForm(ZZ, 4, [1,0,1,1, 2,2,3, 10,2, 6])
sage: Q37.level()
37
sage: F37 = SiegelModularForm(Q37, prec=100); F37
Siegel modular form on Gamma0(37) of weight 2
sage: F37[(2, 1, 3)]
0
sage: F37[(2, 1, 7)]
4
"""
try:
from sage.structure.element import py_scalar_to_element
arg0 = py_scalar_to_element(arg0)
except TypeError:
pass
from sage.modular.modform.element import ModularFormElement
from sage.rings.all import RingElement
if isinstance(arg0, ModularFormElement)\
and isinstance(arg1, ModularFormElement):
return _SiegelModularForm_as_Maass_spezial_form(arg0, arg1, prec, name)
if isinstance(arg0, ModularFormElement) \
and (0 == arg1 or arg1 is None):
M = ModularForms(1, arg0.weight() + 2)
return _SiegelModularForm_as_Maass_spezial_form(arg0, M(0), prec, name)
if 0 == arg0 and isinstance(arg1, ModularFormElement):
M = ModularForms(1, arg1.weight() - 2)
return _SiegelModularForm_as_Maass_spezial_form(M(0), arg1, prec, name)
from sage.quadratic_forms.all import QuadraticForm
if isinstance(arg0, QuadraticForm):
return _SiegelModularForm_from_QuadraticForm(arg0, prec, name)
if isinstance(arg0, RingElement) and arg1 is None:
from sage.rings.all import infinity
return _SiegelModularForm_from_dict(group='Sp(4,Z)', weight=0, coeffs={(0, 0, 0): arg0}, prec=infinity)
if isinstance(arg0, str) and arg1 is None:
return _SiegelModularForm_from_file(arg0)
if isinstance(arg0, dict) and arg1 is None:
return _SiegelModularForm_from_theta_characteristics(arg0, prec=prec, name=name, hint=hint)
from sage.rings.all import Integer
if isinstance(arg0, str) and isinstance(arg1, (int, Integer)) and isinstance(arg2, dict):
return _SiegelModularForm_from_dict(group=arg0, weight=arg1, coeffs=arg2, prec=prec, name=name)
raise TypeError, "wrong arguments"
def _SiegelModularForm_as_Maass_spezial_form(f, g, prec=SMF_DEFAULT_PREC, name=None):
"""
Return the Siegel modular form I(f,g) (Notation as in [Sko]).
EXAMPLES::
sage: M14 = ModularForms(group=1, weight=14)
sage: E14 = M14.eisenstein_subspace()
sage: f = M14.basis()[0]
sage: S16 = ModularForms(group=1, weight=16).cuspidal_subspace()
sage: g = S16.basis()[0]
sage: from sage.modular.siegel.siegel_modular_form import _SiegelModularForm_as_Maass_spezial_form
sage: IFG = _SiegelModularForm_as_Maass_spezial_form(f, g, prec=100, name=None)
sage: IFG[(2, 1, 3)]
-1080946527072
INPUT
f: -- modular form of level 1
g: -- cusp form of level 1 amd wt = wt of f + 2
prec -- either a triple (amax,bmac,cmax) or an integer Dmax
"""
k = f.weight()
assert(k+2 == g.weight()) | (f==0) | (g==0), "incorrect weights!"
assert(g.q_expansion(1) == 0), "second argument is not a cusp form"
if isinstance(prec, tuple):
(amax, bmax, cmax) = prec
amax = min(amax, cmax)
bmax = min(bmax, amax)
clean_prec = (amax, bmax, cmax)
if bmax <= 0:
# no reduced forms below prec
return _SiegelModularForm_from_dict(group='Sp(4,Z)', weight=k, coeffs=dict(), prec=0)
if 1 == amax:
# here prec = (0,0,>=0)
Dtop = 0
else:
Dtop = 4*(amax-1)*(cmax-1)
else:
clean_prec = max(0, prec)
if 0 == clean_prec:
# no reduced forms below prec
return _SiegelModularForm_from_dict(group='Sp(4,Z)', weight=k, coeffs=dict(), prec=0)
while 0 != clean_prec%4 and 1 != clean_prec%4:
clean_prec -= 1
Dtop = clean_prec - 1
precision = (Dtop+1)//4 + 1
# TODO: examine error when called with 1 == prec
if 1 == precision:
precision = 2
"""
Create the Jacobi form I(f,g) as in [Sko].
It suffices to construct for all Jacobi forms phi only the part
sum_{r=0,1;n} c_phi(r^2-4n) q^n zeta^r.
When, in this code part, we speak of Jacobi form we only mean this part.
We need to compute Ifg = \sum_{r=0,1; n} c(r^2-4n) q^n zeta^r up to
4n-r^2 <= Dtop, i.e. n < precision
"""
## print 'Creating I(f,g)'
from sage.rings.all import PowerSeriesRing, QQ
PS = PowerSeriesRing(QQ, name='q')
q = PS.gens()[0]
## Create the quasi Dedekind eta^-6 power series:
pari_prec = max(1, precision - 1) # next line yields error if 0 == pari_prec
from sage.libs.pari.gen import pari
from sage.rings.all import O
pari.set_series_precision(pari_prec)
eta_quasi = PS(pari('Vec(eta(q))')) + O(q**precision)
etapow = eta_quasi**-6
## Create the Jacobi forms A=a*etapow and B=b*etapow in stages.
## Recall a = sum_{s != r mod 2} s^2*(-1)^r*q^((s^2+r^2-1)/4)*zeta^r
## b = sum_{s != r mod 2} (-1)^r*q^((s^2+r^2-1)/4)*zeta^r
## r, s run over ZZ but with opposite parities.
## For r=0, we need s odd, (s^2-1)/4 < precision, with s=2t+1 hence t^2+t < precision.
## For r=1, we need s even, s^2/4 < precision, with s=2t hence t^2 < precision.
from sage.misc.all import xsrange
a1 = -2*sum((2*t)**2 * q**(t**2) for t in xsrange(1, precision) if t*t < precision)
b1 = -2*sum( q**(t**2) for t in xsrange(1, precision) if t*t < precision)
a0 = 2*sum((2*t+1)**2 * q**(t**2+t) for t in xsrange(precision) if t*t +t < precision)
b0 = 2*sum( q**(t**2+t) for t in xsrange(precision) if t*t +t < precision)
b1 = b1 - 1
## print 'Done'
## Form A and B - the Jacobi forms used in [Sko]'s I map.
(A0, A1, B0, B1) = (a0*etapow, a1*etapow, b0*etapow, b1*etapow)
## Calculate the image of the pair of modular forms (f,g) under
## [Sko]'s isomorphism I : M_{k} \oplus S_{k+2} -> J_{k,1}.
fderiv = PS(q * f.qexp(precision).derivative())
(f, g) = (PS(f.qexp(precision)), PS(g.qexp(precision)))
## Finally: I(f,g) is given by the formula below:
Ifg0 = k/2*f*A0 - fderiv*B0 + g*B0 + O(q**precision)
Ifg1 = k/2*f*A1 - fderiv*B1 + g*B1 + O(q**precision)
## For applying the Maass' lifting to genus 2 modular forms.
## we put the coefficients og Ifg into a dictionary Chi
## so that we can access the coefficient corresponding to
## discriminant D by going Chi[D].
## Note: Ifg.list()[i].list()[j] gives the coefficient of q^i*zeta^j
Cphi = {0: 0} ## initialise dictionary. Value changed in the loop if we have a 'noncusp form'
qcoeffs0 = Ifg0.list()
qcoeffs1 = Ifg1.list()
for i in xsrange(len(qcoeffs0)):
Cphi[-4*i] = qcoeffs0[i]
Cphi[1-4*i] = qcoeffs1[i]
## the most negative discriminant occurs when i is largest
## and j is zero. That is, discriminant 0^2-4*i
## Note that i < precision.
maxD = -4*i
"""
Create the Maass lift F := VI(f,g) as in [Sko].
"""
## The constant term is given by -Cphi[0]*B_{2k}/(4*k)
## (note in [Sko] this coeff has typos).
## For nonconstant terms,
## The Siegel coefficient of q^n * zeta^r * qdash^m is given
## by the formula \sum_{ a | gcd(n,r,m) } Cphi[D/a^2] where
## D = r^2-4*n*m is the discriminant.
## Hence in either case the coefficient
## is fully deterimined by the pair (D,gcd(n,r,m)).
## Put (D,t) -> \sum_{ a | t } Cphi[D/a^2]
## in a dictionary (hash table) maassc.
maassc = dict();
## First calculate maass coefficients corresponding to strictly positive definite matrices:
from sage.rings.all import is_fundamental_discriminant
from sage.misc.all import isqrt
for disc in [d for d in xsrange(maxD, 0) if is_fundamental_discriminant(d)]:
for s in xsrange(1, isqrt(maxD//disc)+1):
## add (disc*s^2,t) as a hash key, for each t that divides s
for t in s.divisors():
maassc[(disc*s**2, t)] = sum([a**(k-1)*Cphi[disc*s**2/a**2] for a in t.divisors()])
## Compute the coefficients of the Siegel form $F$:
from sage.rings.all import gcd
siegelq = dict();
if isinstance(prec, tuple):
## Note: m>=n>=r, n>=1 implies m>=n>r^2/4n
for r in xsrange(0, bmax):
for n in xsrange(max(r, 1), amax):
for m in xsrange(n, cmax):
D=r**2 - 4*m*n
g=gcd([n, r, m])
siegelq[(n, r, m)] = maassc[(D, g)]
bound = cmax
else:
bound = 0
for n in xsrange(1, isqrt(Dtop//3)+1):
for r in xsrange(n + 1):
bound = max(bound, (Dtop + r*r)//(4*n) + 1)
for m in xsrange(n, (Dtop + r*r)//(4*n) + 1):
D=r**2 - 4*m*n
g=gcd([n, r, m])
siegelq[(n, r, m)] = maassc[(D, g)]
## Secondly, deal with the singular part.
## Include the coeff corresponding to (0,0,0):
## maassc = {(0,0): -bernoulli(k)/(2*k)*Cphi[0]}
from sage.rings.all import bernoulli
siegelq[(0, 0, 0)] = -bernoulli(k)/(2*k)*Cphi[0]
## Calculate the other discriminant-zero maass coefficients:
from sage.rings.all import sigma
for i in xsrange(1, bound):
## maassc[(0,i)] = sigma(i, k-1) * Cphi[0]
siegelq[(0, 0, i)] = sigma(i, k-1) * Cphi[0]
return _SiegelModularForm_from_dict(group='Sp(4,Z)', weight=k, coeffs=siegelq, prec=clean_prec, name=name)
def _SiegelModularForm_from_file(loc):
r"""
Initialize an instance of SiegelModularForm_class from a file.
EXAMPLE::
sage: from sage.modular.siegel.siegel_modular_form import _SiegelModularForm_from_file
sage: url = 'http://sage.math.washington.edu/home/nils/Siegel-Modular-Forms/data/upsilon-forms_20-32_1000/Upsilon_20.p' # optional -- internet
sage: H = _SiegelModularForm_from_file(url); H # optional - internet
Upsilon_20
sage: H[(4, 4, 4)] # optional - internet
248256200704
"""
if 'http://' == loc[:7]:
f = urllib.urlopen(loc)
else:
f = open(loc, 'r')
data = cPickle.load(f)
f.close()
fmt, wt, name, pol, prec, coeffs = data
if len(pol) > 2:
from sage.rings.all import PolynomialRing, NumberField
R = PolynomialRing(ZZ, 'x')
K = NumberField(R(pol), name='a')
for k in coeffs.iterkeys():
coeffs[k] = K(coeffs[k])
return _SiegelModularForm_from_dict(group='Sp(4,Z)', weight=wt, coeffs=coeffs, prec=prec, name=name)
def _SiegelModularForm_from_theta_characteristics(char_dict, prec=SMF_DEFAULT_PREC, name=None, hint=None):
r"""
Return the Siegel modular form
`\sum_{l \in char_dict} \alpha[l] * \prod_i \theta_l[i](8Z)`,
where `\theta_l[i]` denote the theta constant with characteristic `l`.
INPUT
char_dict - a dictionary whose keys are *tuples* of theta characteristics
and whose values are in some ring.
prec - a precision for Siegel modular forms
name - a string describing this modular form
EXAMPLES::
sage: theta_constants = {((1, 1, 0, 0), (0, 0, 1, 1), (1, 1, 0, 0), (0, 0, 1, 1)): 1}
sage: from sage.modular.siegel.siegel_modular_form import _SiegelModularForm_from_theta_characteristics
sage: _SiegelModularForm_from_theta_characteristics(theta_constants, prec=100)
Siegel modular form on None of weight 2
sage: theta_constants = {((1, 1, 0, 0), (0, 0, 1, 1), (1, 1, 0, 0), (0, 0, 1, 1)): 1}
sage: S = _SiegelModularForm_from_theta_characteristics(theta_constants, prec=100)
sage: S.coeffs()[(2, 0, 10)]
32
TODO:
Implement a parameter hint = "cusp_form" to prevent computing singular parts
"""
coeffs = dict()
smf_prec = SiegelModularFormPrecision(prec)
for f in smf_prec:
if hint is 'cusp_form':
a, b, c = f
if 0 == a: continue
from theta_constant import _compute_theta_char_poly
val = _compute_theta_char_poly(char_dict, f)
if val != 0: coeffs[f] = val
wt = 0
for l in char_dict: wt = max(wt, len(l)/2)
return _SiegelModularForm_from_dict(group=None, weight=wt, coeffs=coeffs, prec=prec, name=name)
def _SiegelModularForm_from_QuadraticForm(Q, prec, name):
"""
Return the theta series of degree 2 for the quadratic form Q.
INPUT:
- ``Q`` - a quadratic form.
- ``prec`` - an integer.
EXAMPLE::
sage: from sage.modular.siegel.siegel_modular_form import _SiegelModularForm_from_QuadraticForm
sage: Q11 = QuadraticForm(ZZ, 4, [3,0,11,0, 3,0,11, 11,0, 11])
sage: _SiegelModularForm_from_QuadraticForm(Q11, 100, None)
Siegel modular form on Gamma0(11) of weight 2
"""
N = Q.level()
k = Q.dim()/2
coeffs = Q.theta_series_degree_2(prec)
return _SiegelModularForm_from_dict(group='Gamma0(%d)'%N, weight=k, coeffs=coeffs, prec=prec, name=name)
def _SiegelModularForm_borcherds_lift(f, prec=SMF_DEFAULT_PREC, name=None):
r"""
Returns Borcherds lift.
EXAMPLES::
sage: from sage.modular.siegel.siegel_modular_form import _SiegelModularForm_borcherds_lift
sage: _SiegelModularForm_borcherds_lift(0)
Traceback (most recent call last):
...
NotImplementedError: Borcherds lift not yet implemented
"""
raise NotImplementedError, "Borcherds lift not yet implemented"
def _SiegelModularForm_yoshida_lift(f, g, prec=SMF_DEFAULT_PREC, name=None):
r"""
Returns the Yoshida lift.
EXAMPLES::
sage: from sage.modular.siegel.siegel_modular_form import _SiegelModularForm_yoshida_lift
sage: _SiegelModularForm_yoshida_lift(0, 0)
Traceback (most recent call last):
...
NotImplementedError: Yoshida lift not yet implemented
"""
raise NotImplementedError, 'Yoshida lift not yet implemented'
def _SiegelModularForm_from_weil_representation(gram, prec=SMF_DEFAULT_PREC, name=None):
r"""
Returns a form associated to a Weil representation.
EXAMPLES::
sage: from sage.modular.siegel.siegel_modular_form import _SiegelModularForm_from_weil_representation
sage: _SiegelModularForm_from_weil_representation(matrix([[2, 1], [1, 1]]))
Traceback (most recent call last):
...
NotImplementedError: Weil representation argument not yet implemented
"""
raise NotImplementedError, 'Weil representation argument not yet implemented'
def _SiegelModularForm_singular_weight(gram, prec=SMF_DEFAULT_PREC, name=None):
r"""
Returns a singular modular form from gram.
EXAMPLES::
sage: from sage.modular.siegel.siegel_modular_form import _SiegelModularForm_singular_weight
sage: _SiegelModularForm_singular_weight(matrix([[2, 1], [1, 1]]))
Traceback (most recent call last):
...
NotImplementedError: singular form argument not yet implemented
"""
raise NotImplementedError, 'singular form argument not yet implemented'
def _SiegelModularForm_from_dict(group, weight, coeffs, prec, degree=2, parent=None, name=None):
r"""
Create an instance of SiegelModularForm_class(), where the parent
is computed from the coeffs.
EXAMPLES::
sage: d = {(1, 1, 1): 1, (1, 0, 2): 2}
sage: from sage.modular.siegel.siegel_modular_form import _SiegelModularForm_from_dict
sage: S = _SiegelModularForm_from_dict('Sp(4,Z)', 2, d, 1); S
Siegel modular form on Sp(4,Z) of weight 2
sage: S.coeffs()
{}
sage: S = _SiegelModularForm_from_dict('Sp(4,Z)', 2, d, 4); S
Siegel modular form on Sp(4,Z) of weight 2
sage: S.coeffs()
{(1, 1, 1): 1}
sage: S = _SiegelModularForm_from_dict('Sp(4,Z)', 2, d, 9); S
Siegel modular form on Sp(4,Z) of weight 2
sage: S.coeffs()
{(1, 1, 1): 1, (1, 0, 2): 2}
"""
if prec is None:
prec = -min([b**2 - 4*a*c for (a, b, c) in coeffs]) + 1
smf_prec = SiegelModularFormPrecision(prec)
coeffs_up_to_prec = {}
for k in coeffs:
if smf_prec.is_in_bound(k):
coeffs_up_to_prec[k] = coeffs[k]
if parent is None:
from sage.structure.all import Sequence
from siegel_modular_forms_algebra import SiegelModularFormsAlgebra
s = Sequence(coeffs_up_to_prec.values())
if weight % 2:
weights = 'all'
else:
weights = 'even'
if len(s) == 0:
coeff_ring = ZZ
else:
coeff_ring = s.universe()
parent = SiegelModularFormsAlgebra(coeff_ring=coeff_ring, group=group, weights=weights, degree=degree)
return parent.element_class(parent=parent, weight=weight, coeffs=coeffs_up_to_prec, prec=prec, name=name)
def _normalized_prec(prec):
r"""
Return a normalized prec for instance of class SiegelModularForm_class.
EXAMPLES::
sage: from sage.modular.siegel.siegel_modular_form import _normalized_prec
sage: _normalized_prec((5, 4, 5))
(5, 4, 5)
sage: _normalized_prec(101)
101
sage: _normalized_prec(infinity)
+Infinity
NOTE:
$(a,b,c)$ is within the precison defined
by prec, if $a,b,c < floor(a),floor(b),floor(c)%
respectively $4ac-b^2 < floor(prec)$.
"""
from sage.rings.all import infinity
if prec is infinity: return prec
from sage.functions.all import floor
if isinstance(prec, tuple):
a, b, c = prec
a = min(floor(a), floor(c))
b = min(floor(b), a)
if b <= 0:
return (0, 0, 0)
return a, b, c
D = max(0, floor(prec))
while 0 != D%4 and 1 != D%4:
D -= 1
return D
def _is_bounded((a, b, c), prec):
r"""
Return True or False accordingly as (a, b, c) is in the
region defined by prec (see. SiegelModularForm_class for what
this means).
EXAMPLES::
sage: from sage.modular.siegel.siegel_modular_form import _is_bounded
sage: _is_bounded((2, 0, 2), 15)
False
sage: _is_bounded((2, 0, 2), 16)
False
sage: _is_bounded((2, 0, 2), 17)
True
NOTE
It is assumed that prec is normalized accordingly to the output
of _normalized_prec().
"""
if isinstance(prec, tuple):
return (a, b, c) < prec
else:
D = 4*a*c - b*b
return D < prec if D != 0 else c < (prec+1)/4
def _prec_min(prec1, prec2):
r"""
Returns the min of two precs.
EXAMPLES::
sage: from sage.modular.siegel.siegel_modular_form import _prec_min
sage: _prec_min(100, 200)
100
sage: _prec_min((1, 0, 1), (2, 0, 1))
(1, 0, 1)
NOTE
It is assumed that the arguments are normalized according to the output
of _normalized_prec().
"""
if type(prec1) != type(prec2):
raise NotImplementedError, "addition for differing precs not yet implemented"
return prec1 if prec1 <= prec2 else prec2
| Python |
from sage.categories.functor import Functor
from sage.categories.basic import *
from sage.structure.parent import CoercionException
# TODO, think through the rankings, and override pushout where necessary.
class ConstructionFunctor(Functor):
def __mul__(self, other):
if not isinstance(self, ConstructionFunctor) and not isinstance(other, ConstructionFunctor):
raise CoercionException, "Non-constructive product"
return CompositConstructionFunctor(other, self)
def pushout(self, other):
if self.rank > other.rank:
return self * other
else:
return other * self
def __cmp__(self, other):
"""
Equality here means that they are mathematically equivalent, though they may have specific implementation data.
See the \code{merge} function.
"""
return cmp(type(self), type(other))
def __str__(self):
s = str(type(self))
import re
return re.sub("<.*'.*\.([^.]*)'>", "\\1", s)
def __repr__(self):
return str(self)
def merge(self, other):
if self == other:
return self
else:
return None
def commutes(self, other):
return False
def expand(self):
return [self]
class CompositConstructionFunctor(ConstructionFunctor):
"""
A Construction Functor composed by other Construction Functors
INPUT:
``F1,F2,...``: A list of Construction Functors. The result is the
composition ``F1`` followed by ``F2`` followed by ...
EXAMPLES::
sage: from sage.categories.pushout import CompositConstructionFunctor
sage: F = CompositConstructionFunctor(QQ.construction()[0],ZZ['x'].construction()[0],QQ.construction()[0],ZZ['y'].construction()[0])
sage: F
Poly[y](FractionField(Poly[x](FractionField(...))))
sage: F == CompositConstructionFunctor(*F.all)
True
sage: F(GF(2)['t'])
Univariate Polynomial Ring in y over Fraction Field of Univariate Polynomial Ring in x over Fraction Field of Univariate Polynomial Ring in t over Finite Field of size 2 (using NTL)
"""
def __init__(self, *args):
"""
TESTS::
sage: from sage.categories.pushout import CompositConstructionFunctor
sage: F = CompositConstructionFunctor(QQ.construction()[0],ZZ['x'].construction()[0],QQ.construction()[0],ZZ['y'].construction()[0])
sage: F
Poly[y](FractionField(Poly[x](FractionField(...))))
sage: F == CompositConstructionFunctor(*F.all)
True
"""
self.all = []
for c in args:
if isinstance(c, list):
self.all += c
elif isinstance(c, CompositConstructionFunctor):
self.all += c.all
else:
self.all.append(c)
Functor.__init__(self, self.all[0].domain(), self.all[-1].codomain())
def __call__(self, R):
for c in self.all:
R = c(R)
return R
def __cmp__(self, other):
if isinstance(other, CompositConstructionFunctor):
return cmp(self.all, other.all)
else:
return cmp(type(self), type(other))
def __mul__(self, other):
"""
Convention: ``(F1*F2)(X) == F1(F2(X))``.
EXAMPLES::
sage: from sage.categories.pushout import CompositConstructionFunctor
sage: F1 = CompositConstructionFunctor(QQ.construction()[0],ZZ['x'].construction()[0])
sage: F2 = CompositConstructionFunctor(QQ.construction()[0],ZZ['y'].construction()[0])
sage: F1*F2
Poly[x](FractionField(Poly[y](FractionField(...))))
"""
if isinstance(self, CompositConstructionFunctor):
all = [other] + self.all
else:
all = other.all + [self]
return CompositConstructionFunctor(*all)
def __str__(self):
s = "..."
for c in self.all:
s = "%s(%s)" % (c,s)
return s
def expand(self):
"""
Return expansion of a CompositConstructionFunctor.
NOTE:
The product over the list of components, as returned by
the ``expand()`` method, is equal to ``self``.
EXAMPLES::
sage: from sage.categories.pushout import CompositConstructionFunctor
sage: F = CompositConstructionFunctor(QQ.construction()[0],ZZ['x'].construction()[0],QQ.construction()[0],ZZ['y'].construction()[0])
sage: F
Poly[y](FractionField(Poly[x](FractionField(...))))
sage: prod(F.expand()) == F
True
"""
return list(reversed(self.all))
class IdentityConstructionFunctor(ConstructionFunctor):
rank = -100
def __init__(self):
Functor.__init__(self, Sets(), Sets())
def __call__(self, R):
return R
def __mul__(self, other):
if isinstance(self, IdentityConstructionFunctor):
return other
else:
return self
class PolynomialFunctor(ConstructionFunctor):
rank = 9
def __init__(self, var, multi_variate=False):
from rings import Rings
Functor.__init__(self, Rings(), Rings())
self.var = var
self.multi_variate = multi_variate
def __call__(self, R):
from sage.rings.polynomial.polynomial_ring_constructor import PolynomialRing
return PolynomialRing(R, self.var)
def __cmp__(self, other):
c = cmp(type(self), type(other))
if c == 0:
c = cmp(self.var, other.var)
elif isinstance(other, MultiPolynomialFunctor):
return -cmp(other, self)
return c
def merge(self, other):
if isinstance(other, MultiPolynomialFunctor):
return other.merge(self)
elif self == other:
return self
else:
return None
def __str__(self):
return "Poly[%s]" % self.var
class MultiPolynomialFunctor(ConstructionFunctor):
"""
A constructor for multivariate polynomial rings.
"""
rank = 9
def __init__(self, vars, term_order):
"""
EXAMPLES:
sage: F = sage.categories.pushout.MultiPolynomialFunctor(['x','y'], None)
sage: F
MPoly[x,y]
sage: F(ZZ)
Multivariate Polynomial Ring in x, y over Integer Ring
sage: F(CC)
Multivariate Polynomial Ring in x, y over Complex Field with 53 bits of precision
"""
Functor.__init__(self, Rings(), Rings())
self.vars = vars
self.term_order = term_order
def __call__(self, R):
"""
EXAMPLES:
sage: R.<x,y,z> = QQ[]
sage: F = R.construction()[0]; F
MPoly[x,y,z]
sage: type(F)
<class 'sage.categories.pushout.MultiPolynomialFunctor'>
sage: F(ZZ)
Multivariate Polynomial Ring in x, y, z over Integer Ring
sage: F(RR)
Multivariate Polynomial Ring in x, y, z over Real Field with 53 bits of precision
"""
from sage.rings.polynomial.polynomial_ring_constructor import PolynomialRing
return PolynomialRing(R, self.vars)
def __cmp__(self, other):
"""
EXAMPLES:
sage: F = ZZ['x,y,z'].construction()[0]
sage: G = QQ['x,y,z'].construction()[0]
sage: F == G
True
sage: G = ZZ['x,y'].construction()[0]
sage: F == G
False
"""
c = cmp(type(self), type(other))
if c == 0:
c = cmp(self.vars, other.vars) or cmp(self.term_order, other.term_order)
elif isinstance(other, PolynomialFunctor):
c = cmp(self.vars, (other.var,))
return c
def __mul__(self, other):
"""
If two MPoly functors are given in a row, form a single MPoly functor
with all of the variables.
EXAMPLES:
sage: F = sage.categories.pushout.MultiPolynomialFunctor(['x','y'], None)
sage: G = sage.categories.pushout.MultiPolynomialFunctor(['t'], None)
sage: G*F
MPoly[x,y,t]
"""
if isinstance(other, MultiPolynomialFunctor):
if self.term_order != other.term_order:
raise CoercionException, "Incompatible term orders (%s,%s)." % (self.term_order, other.term_order)
if set(self.vars).intersection(other.vars):
raise CoercionException, "Overlapping variables (%s,%s)" % (self.vars, other.vars)
return MultiPolynomialFunctor(other.vars + self.vars, self.term_order)
elif isinstance(other, CompositConstructionFunctor) \
and isinstance(other.all[-1], MultiPolynomialFunctor):
return CompositConstructionFunctor(other.all[:-1], self * other.all[-1])
else:
return CompositConstructionFunctor(other, self)
def merge(self, other):
"""
EXAMPLES:
sage: F = sage.categories.pushout.MultiPolynomialFunctor(['x','y'], None)
sage: G = sage.categories.pushout.MultiPolynomialFunctor(['t'], None)
sage: F.merge(G) is None
True
sage: F.merge(F)
MPoly[x,y]
"""
if self == other:
return self
else:
return None
def expand(self):
"""
EXAMPLES:
sage: F = QQ['x,y,z,t'].construction()[0]; F
MPoly[x,y,z,t]
sage: F.expand()
[MPoly[t], MPoly[z], MPoly[y], MPoly[x]]
Now an actual use case:
sage: R.<x,y,z> = ZZ[]
sage: S.<z,t> = QQ[]
sage: x+t
x + t
sage: parent(x+t)
Multivariate Polynomial Ring in x, y, z, t over Rational Field
sage: T.<y,s> = QQ[]
sage: x + s
Traceback (most recent call last):
...
TypeError: unsupported operand parent(s) for '+': 'Multivariate Polynomial Ring in x, y, z over Integer Ring' and 'Multivariate Polynomial Ring in y, s over Rational Field'
sage: R = PolynomialRing(ZZ, 'x', 500)
sage: S = PolynomialRing(GF(5), 'x', 200)
sage: R.gen(0) + S.gen(0)
2*x0
"""
if len(self.vars) <= 1:
return [self]
else:
return [MultiPolynomialFunctor((x,), self.term_order) for x in reversed(self.vars)]
def __str__(self):
"""
EXAMPLES:
sage: QQ['x,y,z,t'].construction()[0]
MPoly[x,y,z,t]
"""
return "MPoly[%s]" % ','.join(self.vars)
class InfinitePolynomialFunctor(ConstructionFunctor):
"""
A Construction Functor for Infinite Polynomial Rings (see :mod:`~sage.rings.polynomial.infinite_polynomial_ring`)
AUTHOR:
-- Simon King
This construction functor is used to provide uniqueness of infinite polynomial rings as parent structures.
As usual, the construction functor allows for constructing pushouts.
Another purpose is to avoid name conflicts of variables of the to-be-constructed infinite polynomial ring with
variables of the base ring, and moreover to keep the internal structure of an Infinite Polynomial Ring as simple
as possible: If variables `v_1,...,v_n` of the given base ring generate an *ordered* sub-monoid of the monomials
of the ambient Infinite Polynomial Ring, then they are removed from the base ring and merged with the generators
of the ambient ring. However, if the orders don't match, an error is raised, since there was a name conflict
without merging.
EXAMPLES::
sage: A.<a,b> = InfinitePolynomialRing(ZZ['t'])
sage: A.construction()
[InfPoly{[a,b], "lex", "dense"},
Univariate Polynomial Ring in t over Integer Ring]
sage: type(_[0])
<class 'sage.categories.pushout.InfinitePolynomialFunctor'>
sage: B.<x,y,a_3,a_1> = PolynomialRing(QQ, order='lex')
sage: B.construction()
(MPoly[x,y,a_3,a_1], Rational Field)
sage: A.construction()[0]*B.construction()[0]
InfPoly{[a,b], "lex", "dense"}(MPoly[x,y](...))
Apparently the variables `a_1,a_3` of the polynomial ring are merged with the variables
`a_0, a_1, a_2, ...` of the infinite polynomial ring; indeed, they form an ordered sub-structure.
However, if the polynomial ring was given a different ordering, merging would not be allowed,
resulting in a name conflict::
sage: A.construction()[0]*PolynomialRing(QQ,names=['x','y','a_3','a_1']).construction()[0]
Traceback (most recent call last):
...
CoercionException: Incompatible term orders lex, degrevlex
In an infinite polynomial ring with generator `a_\\ast`, the variable `a_3` will always be greater
than the variable `a_1`. Hence, the orders are incompatible in the next example as well::
sage: A.construction()[0]*PolynomialRing(QQ,names=['x','y','a_1','a_3'], order='lex').construction()[0]
Traceback (most recent call last):
...
CoercionException: Overlapping variables (('a', 'b'),['a_1', 'a_3']) are incompatible
Another requirement is that after merging the order of the remaining variables must be unique.
This is not the case in the following example, since it is not clear whether the variables `x,y`
should be greater or smaller than the variables `b_\\ast`::
sage: A.construction()[0]*PolynomialRing(QQ,names=['a_3','a_1','x','y'], order='lex').construction()[0]
Traceback (most recent call last):
...
CoercionException: Overlapping variables (('a', 'b'),['a_3', 'a_1']) are incompatible
Since the construction functors are actually used to construct infinite polynomial rings, the following
result is no surprise:
sage: C.<a,b> = InfinitePolynomialRing(B); C
Infinite polynomial ring in a, b over Multivariate Polynomial Ring in x, y over Rational Field
There is also an overlap in the next example::
sage: X.<w,x,y> = InfinitePolynomialRing(ZZ)
sage: Y.<x,y,z> = InfinitePolynomialRing(QQ)
`X` and `Y` have an overlapping generators `x_\\ast, y_\\ast`. Since the default lexicographic order is
used in both rings, it gives rise to isomorphic sub-monoids in both `X` and `Y`. They are merged in the
pushout, which also yields a common parent for doing arithmetic.
sage: P = sage.categories.pushout.pushout(Y,X); P
Infinite polynomial ring in w, x, y, z over Rational Field
sage: w[2]+z[3]
w_2 + z_3
sage: _.parent() is P
True
"""
# We do provide merging with polynomial rings. However, it seems that it is better
# to have a greater rank, since we want to apply InfinitePolynomialFunctor *after*
# [Multi]PolynomialFunktor, which have rank 9. But there is the MatrixFunctor, which
# has rank 10. So, do fine tuning...
rank = 9.5
def __init__(self, gens, order, implementation):
"""
TEST::
sage: F = sage.categories.pushout.InfinitePolynomialFunctor(['a','b','x'],'degrevlex','sparse'); F # indirect doc test
InfPoly{[a,b,x], "degrevlex", "sparse"}
sage: F == loads(dumps(F))
True
"""
if len(gens)<1:
raise ValueError, "Infinite Polynomial Rings have at least one generator"
ConstructionFunctor.__init__(self, Rings(), Rings())
self._gens = tuple(gens)
self._order = order
self._imple = implementation
def __call__(self, R):
"""
TEST::
sage: F = sage.categories.pushout.InfinitePolynomialFunctor(['a','b','x'],'degrevlex','sparse'); F
InfPoly{[a,b,x], "degrevlex", "sparse"}
sage: F(QQ['t']) # indirect doc test
Infinite polynomial ring in a, b, x over Univariate Polynomial Ring in t over Rational Field
"""
from sage.rings.polynomial.infinite_polynomial_ring import InfinitePolynomialRing
return InfinitePolynomialRing(R, self._gens, order=self._order, implementation=self._imple)
def __str__(self):
"""
TEST::
sage: F = sage.categories.pushout.InfinitePolynomialFunctor(['a','b','x'],'degrevlex','sparse'); F # indirect doc test
InfPoly{[a,b,x], "degrevlex", "sparse"}
"""
return 'InfPoly{[%s], "%s", "%s"}'%(','.join(self._gens), self._order, self._imple)
def __cmp__(self, other):
"""
TEST::
sage: F = sage.categories.pushout.InfinitePolynomialFunctor(['a','b','x'],'degrevlex','sparse'); F # indirect doc test
InfPoly{[a,b,x], "degrevlex", "sparse"}
sage: F == loads(dumps(F)) # indirect doc test
True
sage: F == sage.categories.pushout.InfinitePolynomialFunctor(['a','b','x'],'deglex','sparse')
False
"""
c = cmp(type(self), type(other))
if c == 0:
c = cmp(self._gens, other._gens) or cmp(self._order, other._order) or cmp(self._imple, other._imple)
return c
def __mul__(self, other):
"""
TESTS::
sage: F1 = QQ['a','x_2','x_1','y_3','y_2'].construction()[0]; F1
MPoly[a,x_2,x_1,y_3,y_2]
sage: F2 = InfinitePolynomialRing(QQ, ['x','y'],order='degrevlex').construction()[0]; F2
InfPoly{[x,y], "degrevlex", "dense"}
sage: F3 = InfinitePolynomialRing(QQ, ['x','y'],order='degrevlex',implementation='sparse').construction()[0]; F3
InfPoly{[x,y], "degrevlex", "sparse"}
sage: F2*F1
InfPoly{[x,y], "degrevlex", "dense"}(Poly[a](...))
sage: F3*F1
InfPoly{[x,y], "degrevlex", "sparse"}(Poly[a](...))
sage: F4 = sage.categories.pushout.FractionField()
sage: F2*F4
InfPoly{[x,y], "degrevlex", "dense"}(FractionField(...))
"""
if isinstance(other, self.__class__): #
INT = set(self._gens).intersection(other._gens)
if INT:
# if there is overlap of generators, it must only be at the ends, so that
# the resulting order after the merging is unique
if other._gens[-len(INT):] != self._gens[:len(INT)]:
raise CoercionException, "Overlapping variables (%s,%s) are incompatible" % (self._gens, other._gens)
OUTGENS = list(other._gens) + list(self._gens[len(INT):])
else:
OUTGENS = list(other._gens) + list(self._gens)
# the orders must coincide
if self._order != other._order:
return CompositConstructionFunctor(other, self)
# the implementations must coincide
if self._imple != other._imple:
return CompositConstructionFunctor(other, self)
return InfinitePolynomialFunctor(OUTGENS, self._order, self._imple)
# Polynomial Constructor
# Idea: We merge into self, if the polynomial functor really provides a substructure,
# even respecting the order. Note that, if the pushout is computed, only *one* variable
# will occur in the polynomial constructor. Hence, any order is fine, which is exactly
# what we need in order to have coercion maps for different orderings.
if isinstance(other, MultiPolynomialFunctor) or isinstance(other, PolynomialFunctor):
if isinstance(other, MultiPolynomialFunctor):
othervars = other.vars
else:
othervars = [other.var]
OverlappingGens = [] ## Generator names of variable names of the MultiPolynomialFunctor
## that can be interpreted as variables in self
OverlappingVars = [] ## The variable names of the MultiPolynomialFunctor
## that can be interpreted as variables in self
RemainingVars = [x for x in othervars]
IsOverlap = False
BadOverlap = False
for x in othervars:
if x.count('_') == 1:
g,n = x.split('_')
if n.isdigit():
if g.isalnum(): # we can interprete x in any InfinitePolynomialRing
if g in self._gens: # we can interprete x in self, hence, we will not use it as a variable anymore.
RemainingVars.pop(RemainingVars.index(x))
IsOverlap = True # some variables of other can be interpreted in self.
if OverlappingVars:
# Is OverlappingVars in the right order?
g0,n0 = OverlappingVars[-1].split('_')
i = self._gens.index(g)
i0 = self._gens.index(g0)
if i<i0: # wrong order
BadOverlap = True
if i==i0 and int(n)>int(n0): # wrong order
BadOverlap = True
OverlappingVars.append(x)
else:
if IsOverlap: # The overlap must be on the right end of the variable list
BadOverlap = True
else:
if IsOverlap: # The overlap must be on the right end of the variable list
BadOverlap = True
else:
if IsOverlap: # The overlap must be on the right end of the variable list
BadOverlap = True
else:
if IsOverlap: # The overlap must be on the right end of the variable list
BadOverlap = True
if BadOverlap: # the overlapping variables appear in the wrong order
raise CoercionException, "Overlapping variables (%s,%s) are incompatible" % (self._gens, OverlappingVars)
if len(OverlappingVars)>1: # multivariate, hence, the term order matters
if other.term_order.name()!=self._order:
raise CoercionException, "Incompatible term orders %s, %s" % (self._order, other.term_order.name())
# ok, the overlap is fine, we will return something.
if RemainingVars: # we can only partially merge other into self
if len(RemainingVars)>1:
return CompositConstructionFunctor(MultiPolynomialFunctor(RemainingVars,term_order=other.term_order), self)
return CompositConstructionFunctor(PolynomialFunctor(RemainingVars[0]), self)
return self
return CompositConstructionFunctor(other, self)
def merge(self,other):
"""
Merge two construction functors of infinite polynomial rings, regardless of monomial order and implementation.
The purpose is to have a pushout (and thus, arithmetic) even in cases when the parents are isomorphic as
rings, but not as ordered rings.
EXAMPLES::
sage: X.<x,y> = InfinitePolynomialRing(QQ,implementation='sparse')
sage: Y.<x,y> = InfinitePolynomialRing(QQ,order='degrevlex')
sage: X.construction()
[InfPoly{[x,y], "lex", "sparse"}, Rational Field]
sage: Y.construction()
[InfPoly{[x,y], "degrevlex", "dense"}, Rational Field]
sage: Y.construction()[0].merge(Y.construction()[0])
InfPoly{[x,y], "degrevlex", "dense"}
sage: y[3] + X(x[2])
x_2 + y_3
sage: _.parent().construction()
[InfPoly{[x,y], "degrevlex", "dense"}, Rational Field]
"""
# Merging is only done if the ranks of self and other are the same.
# It may happen that other is a substructure of self up to the monomial order
# and the implementation. And this is when we want to merge, in order to
# provide multiplication for rings with different term orderings.
if not isinstance(other, InfinitePolynomialFunctor):
return None
if set(other._gens).issubset(self._gens):
return self
return None
try:
OUT = self*other
# The following happens if "other" has the same order type etc.
if not isinstance(OUT, CompositConstructionFunctor):
return OUT
except CoercionException:
pass
if isinstance(other,InfinitePolynomialFunctor):
# We don't require that the orders coincide. This is a difference to self*other
# We only merge if other's generators are an ordered subset of self's generators
for g in other._gens:
if g not in self._gens:
return None
# The sequence of variables is part of the ordering. It must coincide in both rings
Ind = [self._gens.index(g) for g in other._gens]
if sorted(Ind)!=Ind:
return None
# OK, other merges into self. Now, chose the default dense implementation,
# unless both functors refer to the sparse implementation
if self._imple != other._imple:
return InfinitePolynomialFunctor(self._gens, self._order, 'dense')
return self
## if isinstance(other, PolynomialFunctor) or isinstance(other, MultiPolynomialFunctor):
## # For merging, we don't care about the orders
## ## if isinstance(other, MultiPolynomialFunctor) and self._order!=other.term_order.name():
## ## return None
## # We only merge if other's variables can all be interpreted in self.
## if isinstance(other, PolynomialFunctor):
## if other.var.count('_')!=1:
## return None
## g,n = other.var.split('_')
## if not ((g in self._gens) and n.isdigit()):
## return None
## # other merges into self!
## return self
## # Now, other is MultiPolynomial
## for v in other.vars:
## if v.count('_')!=1:
## return None
## g,n = v.split('_')
## if not ((g in self._gens) and n.isdigit()):
## return None
## # other merges into self!
## return self
return None
def expand(self):
"""
Decompose the functor `F` into sub-functors, whose product returns `F`
EXAMPLES::
sage: F = InfinitePolynomialRing(QQ, ['x','y'],order='degrevlex').construction()[0]; F
InfPoly{[x,y], "degrevlex", "dense"}
sage: F.expand()
[InfPoly{[y], "degrevlex", "dense"}, InfPoly{[x], "degrevlex", "dense"}]
sage: F = InfinitePolynomialRing(QQ, ['x','y','z'],order='degrevlex').construction()[0]; F
InfPoly{[x,y,z], "degrevlex", "dense"}
sage: F.expand()
[InfPoly{[z], "degrevlex", "dense"},
InfPoly{[y], "degrevlex", "dense"},
InfPoly{[x], "degrevlex", "dense"}]
sage: prod(F.expand())==F
True
"""
if len(self._gens)==1:
return [self]
return [InfinitePolynomialFunctor((x,), self._order, self._imple) for x in reversed(self._gens)]
class SiegelModularFormsAlgebraFunctor(ConstructionFunctor):
# this is needed to make the coercion system happy
# DO NOT REMOVE
rank = 9
def __init__(self, group, weights, degree, default_prec):
r"""
Initialize the functor.
EXAMPLES::
sage: from sage.categories.pushout import SiegelModularFormsAlgebraFunctor
sage: F = SiegelModularFormsAlgebraFunctor('Sp(4,Z)', 'even', 2, 101)
sage: F.rank
9
"""
from sage.categories.all import Rings
Functor.__init__(self, Rings(), Rings())
self._group = group
self._weights = weights
self._degree = degree
self._default_prec = default_prec
def __call__(self, R):
r"""
Apply the functor ``self`` to the ring ``R``.
EXAMPLES::
sage: from sage.categories.pushout import SiegelModularFormsAlgebraFunctor
sage: F = SiegelModularFormsAlgebraFunctor('Sp(4,Z)', 'all', 2, 41)
sage: F(QQ)
Algebra of Siegel modular forms of degree 2 and all weights on Sp(4,Z) over Rational Field
TESTS::
sage: F(3)
Traceback (most recent call last):
...
TypeError: The coefficient ring must be a ring
"""
from sage.modular.siegel.all import SiegelModularFormsAlgebra
return SiegelModularFormsAlgebra(coeff_ring=R, group=self._group, weights=self._weights, degree=self._degree, default_prec=self._default_prec)
def __cmp__(self, other):
r"""
Compare the functor ``self`` and the object ``other``.
EXAMPLES::
sage: from sage.categories.pushout import SiegelModularFormsAlgebraFunctor
sage: F = SiegelModularFormsAlgebraFunctor('Sp(4,Z)', 'even', 2, 101)
sage: G = SiegelModularFormsAlgebraFunctor('Sp(4,Z)', 'even', 2, 101)
sage: F == G
True
sage: F == SiegelModularFormsAlgebraFunctor('Sp(4,Z)', 'all', 2, 41)
False
sage: F == SiegelModularFormsAlgebraFunctor('Sp(4,Z)', 'even', 2, 61)
True
"""
c = cmp(type(self), type(other))
if c == 0:
# default precision is an implementation detail, not a
# mathematical property, so it is ignored in comparison
c = cmp(self._group, other._group) or cmp(self._weights, other._weights) or cmp(self._degree, other._degree)
return c
def merge(self, other):
r"""
Merge the two functors ``self`` and ``other``.
EXAMPLES::
sage: from sage.categories.pushout import SiegelModularFormsAlgebraFunctor
sage: F = SiegelModularFormsAlgebraFunctor('Sp(4,Z)', 'even', 2, 101)
sage: G = SiegelModularFormsAlgebraFunctor('Gamma0(2)', 'all', 2, 61)
sage: F == G
False
sage: F.merge(G) is None
True
sage: G = SiegelModularFormsAlgebraFunctor('Sp(4,Z)', 'even', 2, 61)
sage: F.merge(G) is G
True
"""
if not isinstance(other, SiegelModularFormsAlgebraFunctor):
return None
if (self._group == other._group) and (self._weights == other._weights) and (self._degree == other._degree):
if self._default_prec <= other._default_prec:
return self
else: # self._default_prec > other._default_prec
return other
else:
return None
def __str__(self):
r"""
Return a string describing the functor ``self``.
EXAMPLES::
sage: from sage.categories.pushout import SiegelModularFormsAlgebraFunctor
sage: F = SiegelModularFormsAlgebraFunctor('Gamma0(4)', 'even', 2, 41)
sage: F
SMFAlg{"Gamma0(4)", "even", 2, 41}
"""
return 'SMFAlg{"%s", "%s", %s, %s}' %(self._group, self._weights, self._degree, self._default_prec)
class MatrixFunctor(ConstructionFunctor):
rank = 10
def __init__(self, nrows, ncols, is_sparse=False):
# if nrows == ncols:
# Functor.__init__(self, Rings(), RingModules()) # takes a base ring
# else:
# Functor.__init__(self, Rings(), MatrixAlgebras()) # takes a base ring
Functor.__init__(self, Rings(), Rings())
self.nrows = nrows
self.ncols = ncols
self.is_sparse = is_sparse
def __call__(self, R):
from sage.matrix.matrix_space import MatrixSpace
return MatrixSpace(R, self.nrows, self.ncols, sparse=self.is_sparse)
def __cmp__(self, other):
c = cmp(type(self), type(other))
if c == 0:
c = cmp((self.nrows, self.ncols), (other.nrows, other.ncols))
return c
def merge(self, other):
if self != other:
return None
else:
return MatrixFunctor(self.nrows, self.ncols, self.is_sparse and other.is_sparse)
class LaurentPolynomialFunctor(ConstructionFunctor):
rank = 9
def __init__(self, var, multi_variate=False):
Functor.__init__(self, Rings(), Rings())
self.var = var
self.multi_variate = multi_variate
def __call__(self, R):
from sage.rings.polynomial.laurent_polynomial_ring import LaurentPolynomialRing, is_LaurentPolynomialRing
if self.multi_variate and is_LaurentPolynomialRing(R):
return LaurentPolynomialRing(R.base_ring(), (list(R.variable_names()) + [self.var]))
else:
from sage.rings.polynomial.polynomial_ring_constructor import PolynomialRing
return PolynomialRing(R, self.var)
def __cmp__(self, other):
c = cmp(type(self), type(other))
if c == 0:
c = cmp(self.var, other.var)
return c
def merge(self, other):
if self == other or isinstance(other, PolynomialFunctor) and self.var == other.var:
return LaurentPolynomialFunctor(self.var, (self.multi_variate or other.multi_variate))
else:
return None
class VectorFunctor(ConstructionFunctor):
rank = 10 # ranking of functor, not rank of module
def __init__(self, n, is_sparse=False, inner_product_matrix=None):
# Functor.__init__(self, Rings(), FreeModules()) # takes a base ring
Functor.__init__(self, Objects(), Objects())
self.n = n
self.is_sparse = is_sparse
self.inner_product_matrix = inner_product_matrix
def __call__(self, R):
from sage.modules.free_module import FreeModule
return FreeModule(R, self.n, sparse=self.is_sparse, inner_product_matrix=self.inner_product_matrix)
def __cmp__(self, other):
c = cmp(type(self), type(other))
if c == 0:
c = cmp(self.n, other.n)
return c
def merge(self, other):
if self != other:
return None
else:
return VectorFunctor(self.n, self.is_sparse and other.is_sparse)
class SubspaceFunctor(ConstructionFunctor):
rank = 11 # ranking of functor, not rank of module
def __init__(self, basis):
# Functor.__init__(self, FreeModules(), FreeModules()) # takes a base ring
Functor.__init__(self, Objects(), Objects())
self.basis = basis
def __call__(self, ambient):
return ambient.span_of_basis(self.basis)
def __cmp__(self, other):
c = cmp(type(self), type(other))
if c == 0:
c = cmp(self.basis, other.basis)
return c
def merge(self, other):
if isinstance(other, SubspaceFunctor):
return SubspaceFunctor(self.basis + other.basis) # TODO: remove linear dependencies
else:
return None
class FractionField(ConstructionFunctor):
rank = 5
def __init__(self):
Functor.__init__(self, Rings(), Fields())
def __call__(self, R):
return R.fraction_field()
class LocalizationFunctor(ConstructionFunctor):
rank = 6
def __init__(self, t):
Functor.__init__(self, Rings(), Rings())
self.t = t
def __call__(self, R):
return R.localize(t)
def __cmp__(self, other):
c = cmp(type(self), type(other))
if c == 0:
c = cmp(self.t, other.t)
return c
class CompletionFunctor(ConstructionFunctor):
rank = 4
def __init__(self, p, prec, extras=None):
Functor.__init__(self, Rings(), Rings())
self.p = p
self.prec = prec
self.extras = extras
def __call__(self, R):
return R.completion(self.p, self.prec, self.extras)
def __cmp__(self, other):
c = cmp(type(self), type(other))
if c == 0:
c = cmp(self.p, other.p)
return c
def merge(self, other):
if self.p == other.p:
if self.prec == other.prec:
extras = self.extras.copy()
extras.update(other.extras)
return CompletionFunctor(self.p, self.prec, extras)
elif self.prec < other.prec:
return self
else: # self.prec > other.prec
return other
else:
return None
class QuotientFunctor(ConstructionFunctor):
rank = 7
def __init__(self, I, as_field=False):
Functor.__init__(self, Rings(), Rings()) # much more general...
self.I = I
self.as_field = as_field
def __call__(self, R):
I = self.I
if I.ring() != R:
I.base_extend(R)
Q = R.quo(I)
if self.as_field and hasattr(Q, 'field'):
Q = Q.field()
return Q
def __cmp__(self, other):
c = cmp(type(self), type(other))
if c == 0:
c = cmp(self.I, other.I)
return c
def merge(self, other):
if self == other:
return self
try:
gcd = self.I + other.I
except (TypeError, NotImplementedError):
return None
if gcd.is_trivial() and not gcd.is_zero():
# quotient by gcd would result in the trivial ring/group/...
# Rather than create the zero ring, we claim they can't be merged
# TODO: Perhaps this should be detected at a higher level...
raise TypeError, "Trivial quotient intersection."
return QuotientFunctor(gcd)
class AlgebraicExtensionFunctor(ConstructionFunctor):
rank = 3
def __init__(self, poly, name, elt=None, embedding=None):
Functor.__init__(self, Rings(), Rings())
self.poly = poly
self.name = name
self.elt = elt
self.embedding = embedding
def __call__(self, R):
return R.extension(self.poly, self.name, embedding=self.embedding)
def __cmp__(self, other):
c = cmp(type(self), type(other))
if c == 0:
c = cmp(self.poly, other.poly)
if c == 0:
c = cmp(self.embedding, other.embedding)
return c
class AlgebraicClosureFunctor(ConstructionFunctor):
rank = 3
def __init__(self):
Functor.__init__(self, Rings(), Rings())
def __call__(self, R):
return R.algebraic_closure()
def merge(self, other):
# Algebraic Closure subsumes Algebraic Extension
return self
class PermutationGroupFunctor(ConstructionFunctor):
rank = 10
def __init__(self, gens):
"""
EXAMPLES::
sage: from sage.categories.pushout import PermutationGroupFunctor
sage: PF = PermutationGroupFunctor([PermutationGroupElement([(1,2)])]); PF
PermutationGroupFunctor[(1,2)]
"""
Functor.__init__(self, Groups(), Groups())
self._gens = gens
def __repr__(self):
"""
EXAMPLES::
sage: P1 = PermutationGroup([[(1,2)]])
sage: PF, P = P1.construction()
sage: PF
PermutationGroupFunctor[(1,2)]
"""
return "PermutationGroupFunctor%s"%self.gens()
def __call__(self, R):
"""
EXAMPLES::
sage: P1 = PermutationGroup([[(1,2)]])
sage: PF, P = P1.construction()
sage: PF(P)
Permutation Group with generators [(1,2)]
"""
from sage.groups.perm_gps.permgroup import PermutationGroup
return PermutationGroup([g for g in (R.gens() + self.gens()) if not g.is_one()])
def gens(self):
"""
EXAMPLES::
sage: P1 = PermutationGroup([[(1,2)]])
sage: PF, P = P1.construction()
sage: PF.gens()
[(1,2)]
"""
return self._gens
def merge(self, other):
"""
EXAMPLES::
sage: P1 = PermutationGroup([[(1,2)]])
sage: PF1, P = P1.construction()
sage: P2 = PermutationGroup([[(1,3)]])
sage: PF2, P = P2.construction()
sage: PF1.merge(PF2)
PermutationGroupFunctor[(1,2), (1,3)]
"""
if self.__class__ != other.__class__:
return None
return PermutationGroupFunctor(self.gens() + other.gens())
def BlackBoxConstructionFunctor(ConstructionFunctor):
rank = 100
def __init__(self, box):
if not callable(box):
raise TypeError, "input must be callable"
self.box = box
def __call__(self, R):
return box(R)
def __cmp__(self, other):
return self.box == other.box
def pushout(R, S):
"""
Given a pair of Objects R and S, try and construct a
reasonable object $Y$ and return maps such that
canonically $R \leftarrow Y \rightarrow S$.
ALGORITHM:
This incorporates the idea of functors discussed Sage Days 4.
Every object $R$ can be viewed as an initial object and
a series of functors (e.g. polynomial, quotient, extension,
completion, vector/matrix, etc.). Call the series of
increasingly-simple rings (with the associated functors)
the "tower" of $R$. The \code{construction} method is used to
create the tower.
Given two objects $R$ and $S$, try and find a common initial
object $Z$. If the towers of $R$ and $S$ meet, let $Z$ be their
join. Otherwise, see if the top of one coerces naturally into
the other.
Now we have an initial object and two \emph{ordered} lists of
functors to apply. We wish to merge these in an unambiguous order,
popping elements off the top of one or the other tower as we
apply them to $Z$.
- If the functors are distinct types, there is an absolute ordering
given by the rank attribute. Use this.
- Otherwise:
- If the tops are equal, we (try to) merge them.
- If \emph{exactly} one occurs lower in the other tower
we may unambiguously apply the other (hoping for a later merge).
- If the tops commute, we can apply either first.
- Otherwise fail due to ambiguity.
EXAMPLES:
Here our "towers" are $R = Complete_7(Frac(\Z)$ and $Frac(Poly_x(\Z))$, which give us $Frac(Poly_x(Complete_7(Frac(\Z)))$
sage: from sage.categories.pushout import pushout
sage: pushout(Qp(7), Frac(ZZ['x']))
Fraction Field of Univariate Polynomial Ring in x over 7-adic Field with capped relative precision 20
Note we get the same thing with
sage: pushout(Zp(7), Frac(QQ['x']))
Fraction Field of Univariate Polynomial Ring in x over 7-adic Field with capped relative precision 20
sage: pushout(Zp(7)['x'], Frac(QQ['x']))
Fraction Field of Univariate Polynomial Ring in x over 7-adic Field with capped relative precision 20
Note that polynomial variable ordering must be unambiguously determined.
sage: pushout(ZZ['x,y,z'], QQ['w,z,t'])
Traceback (most recent call last):
...
CoercionException: ('Ambiguous Base Extension', Multivariate Polynomial Ring in x, y, z over Integer Ring, Multivariate Polynomial Ring in w, z, t over Rational Field)
sage: pushout(ZZ['x,y,z'], QQ['w,x,z,t'])
Multivariate Polynomial Ring in w, x, y, z, t over Rational Field
Some other examples
sage: pushout(Zp(7)['y'], Frac(QQ['t'])['x,y,z'])
Multivariate Polynomial Ring in x, y, z over Fraction Field of Univariate Polynomial Ring in t over 7-adic Field with capped relative precision 20
sage: pushout(ZZ['x,y,z'], Frac(ZZ['x'])['y'])
Multivariate Polynomial Ring in y, z over Fraction Field of Univariate Polynomial Ring in x over Integer Ring
sage: pushout(MatrixSpace(RDF, 2, 2), Frac(ZZ['x']))
Full MatrixSpace of 2 by 2 dense matrices over Fraction Field of Univariate Polynomial Ring in x over Real Double Field
sage: pushout(ZZ, MatrixSpace(ZZ[['x']], 3, 3))
Full MatrixSpace of 3 by 3 dense matrices over Power Series Ring in x over Integer Ring
sage: pushout(QQ['x,y'], ZZ[['x']])
Univariate Polynomial Ring in y over Power Series Ring in x over Rational Field
sage: pushout(Frac(ZZ['x']), QQ[['x']])
Laurent Series Ring in x over Rational Field
AUTHORS:
-- Robert Bradshaw
"""
if R is S or R == S:
return R
if isinstance(R, type):
R = type_to_parent(R)
if isinstance(S, type):
S = type_to_parent(S)
R_tower = construction_tower(R)
S_tower = construction_tower(S)
Rs = [c[1] for c in R_tower]
Ss = [c[1] for c in S_tower]
if R in Ss:
return S
elif S in Rs:
return R
if R_tower[-1][1] in Ss:
Rs, Ss = Ss, Rs
R_tower, S_tower = S_tower, R_tower
# look for join
if Ss[-1] in Rs:
if Rs[-1] == Ss[-1]:
while Rs and Ss and Rs[-1] == Ss[-1]:
Rs.pop()
Z = Ss.pop()
else:
Rs = Rs[:Rs.index(Ss[-1])]
Z = Ss.pop()
# look for topmost coercion
elif S.has_coerce_map_from(Rs[-1]):
while not Ss[-1].has_coerce_map_from(Rs[-1]):
Ss.pop()
while len(Rs) > 0 and Ss[-1].has_coerce_map_from(Rs[-1]):
Rs.pop()
Z = Ss.pop()
elif R.has_coerce_map_from(Ss[-1]):
while not Rs[-1].has_coerce_map_from(Ss[-1]):
Rs.pop()
while len(Ss) > 0 and Rs[-1].has_coerce_map_from(Ss[-1]):
Ss.pop()
Z = Rs.pop()
else:
raise CoercionException, "No common base"
# Rc is a list of functors from Z to R and Sc is a list of functors from Z to S
Rc = [c[0] for c in R_tower[1:len(Rs)+1]]
Sc = [c[0] for c in S_tower[1:len(Ss)+1]]
Rc = sum([c.expand() for c in Rc], [])
Sc = sum([c.expand() for c in Sc], [])
all = IdentityConstructionFunctor()
try:
while len(Rc) > 0 or len(Sc) > 0:
# print Z
# if we are out of functors in either tower, there is no ambiguity
if len(Sc) == 0:
all = Rc.pop() * all
elif len(Rc) == 0:
all = Sc.pop() * all
# if one of the functors has lower rank, do it first
elif Rc[-1].rank < Sc[-1].rank:
all = Rc.pop() * all
elif Sc[-1].rank < Rc[-1].rank:
all = Sc.pop() * all
else:
# the ranks are the same, so things are a bit subtler
if Rc[-1] == Sc[-1]:
# If they are indeed the same operation, we only do it once.
# The \code{merge} function here takes into account non-mathematical
# distinctions (e.g. single vs. multivariate polynomials).
cR = Rc.pop()
cS = Sc.pop()
c = cR.merge(cS) or cS.merge(cR)
if c:
all = c * all
else:
raise CoercionException, "Incompatible Base Extension %r, %r (on %r, %r)" % (R, S, cR, cS)
else:
# Now we look ahead to see if either top functor is
# applied later on in the other tower.
# If this is the case for exactly one of them, we unambiguously
# postpone that operation, but if both then we abort.
if Rc[-1] in Sc:
if Sc[-1] in Rc:
raise CoercionException, ("Ambiguous Base Extension", R, S)
else:
all = Sc.pop() * all
elif Sc[-1] in Rc:
all = Rc.pop() * all
# If, perchance, the two functors commute, then we may do them in any order.
elif Rc[-1].commutes(Sc[-1]):
all = Sc.pop() * Rc.pop() * all
else:
# try and merge (default merge is failure for unequal functors)
cR = Rc.pop()
cS = Sc.pop()
c = cR.merge(cS) or cS.merge(cR)
if c is not None:
all = c * all
else:
# Otherwise, we cannot proceed.
raise CoercionException, ("Ambiguous Base Extension", R, S)
return all(Z)
except CoercionException:
raise
except (TypeError, ValueError, AttributeError, NotImplementedError), ex:
# We do this because we may be trying all kinds of things that don't
# make sense, and in this case simply want to return that a pushout
# couldn't be found.
raise CoercionException(ex)
def pushout_lattice(R, S):
"""
Given a pair of Objects R and S, try and construct a
reasonable object $Y$ and return maps such that
canonically $R \leftarrow Y \rightarrow S$.
ALGORITHM:
This is based on the model that arose from much discussion at Sage Days 4.
Going up the tower of constructions of $R$ and $S$ (e.g. the reals
come from the rationals come from the integers) try and find a
common parent, and then try and fill in a lattice with these
two towers as sides with the top as the common ancestor and
the bottom will be the desired ring.
See the code for a specific worked-out example.
EXAMPLES:
sage: from sage.categories.pushout import pushout_lattice
sage: A, B = pushout_lattice(Qp(7), Frac(ZZ['x']))
sage: A.codomain()
Fraction Field of Univariate Polynomial Ring in x over 7-adic Field with capped relative precision 20
sage: A.codomain() is B.codomain()
True
sage: A, B = pushout_lattice(ZZ, MatrixSpace(ZZ[['x']], 3, 3))
sage: B
Identity endomorphism of Full MatrixSpace of 3 by 3 dense matrices over Power Series Ring in x over Integer Ring
AUTHOR:
-- Robert Bradshaw
"""
R_tower = construction_tower(R)
S_tower = construction_tower(S)
Rs = [c[1] for c in R_tower]
Ss = [c[1] for c in S_tower]
# look for common ancestor
start = None
for Z in Rs:
if Z in Ss:
start = Z
if start is None:
# Should I test for a map between the tops of the towers?
# Or, if they're both not ZZ, is it hopeless?
return None
# truncate at common ancestor
R_tower = list(reversed(R_tower[:Rs.index(start)+1]))
S_tower = list(reversed(S_tower[:Ss.index(start)+1]))
Rs = [c[1] for c in R_tower] # the list of objects
Ss = [c[1] for c in S_tower]
Rc = [c[0] for c in R_tower] # the list of functors
Sc = [c[0] for c in S_tower]
# Here we try and construct a 2-dimensional lattice as follows.
# Suppose our towers are Z -> Q -> Qp = R and Z -> Z[t] -> Frac(Z[t]) = S
lattice = {}
# First we fill in the sides
#
# Z
# / \
# Q Z[t]
# / \
# Qp Frac(Z[t])
#
for i in range(len(Rs)):
lattice[i,0] = Rs[i]
for j in range(len(Ss)):
lattice[0,j] = Ss[j]
# Now we attempt to fill in the center, one (diagonal) row at a time,
# one commuting square at a time.
#
# Z
# / \
# Q Z[t]
# / \ / \
# Qp Q[t] Frac(Z[t])
# \ /
# Qp[t]
#
# There is always exactly one "correct" path/order in which to apply operations
# from the top to the bottom. In our example, this is down the far left side.
# We keep track of which that is by clearing out Rc and Sc as we go along.
#
# Note that when applying the functors in the correct order, base extension
# is not needed (though it may occur in the resulting morphisms).
#
for i in range(len(Rc)-1):
for j in range(len(Sc)-1):
try:
if lattice[i,j+1] == lattice[i+1,j]:
# In this case we have R <- S -> R
# We don't want to perform the operation twice
# and all subsequent squares will come from objects
# where the operation was already performed (either
# to the left or right)
Rc[i] = Sc[j] = None # IdentityConstructionFunctor()
lattice[i+1,j+1] = lattice[i,j+1]
elif Rc[i] is None and Sc[j] is None:
lattice[i+1,j+1] = lattice[i,j+1]
elif Rc[i] is None:
lattice[i+1,j+1] = Sc[j](lattice[i+1,j])
elif Sc[j] is None:
lattice[i+1,j+1] = Rc[i](lattice[i,j+1])
else:
# For now, we just look at the rank.
# TODO: be more sophisticated and query the functors themselves
if Rc[i].rank < Sc[j].rank:
lattice[i+1,j+1] = Sc[j](lattice[i+1,j])
Rc[i] = None # force us to use pre-applied Rc[i]
else:
lattice[i+1,j+1] = Rc[i](lattice[i,j+1])
Sc[j] = None # force us to use pre-applied Sc[i]
except (AttributeError, NameError):
print i, j
pp(lattice)
raise CoercionException, "%s does not support %s" % (lattice[i,j], 'F')
# If we are successful, we should have something that looks like this.
#
# Z
# / \
# Q Z[t]
# / \ / \
# Qp Q[t] Frac(Z[t])
# \ / \ /
# Qp[t] Frac(Q[t])
# \ /
# Frac(Qp[t])
#
R_loc = len(Rs)-1
S_loc = len(Ss)-1
# Find the composition coercion morphisms along the bottom left...
if S_loc > 0:
R_map = lattice[R_loc,1].coerce_map_from(R)
for i in range(1, S_loc):
map = lattice[R_loc, i+1].coerce_map_from(lattice[R_loc, i]) # The functor used is implicit here, should it be?
R_map = map * R_map
else:
R_map = R.coerce_map_from(R) # id
# ... and bottom right
if R_loc > 0:
S_map = lattice[1, S_loc].coerce_map_from(S)
for i in range(1, R_loc):
map = lattice[i+1, S_loc].coerce_map_from(lattice[i, S_loc])
S_map = map * S_map
else:
S_map = S.coerce_map_from(S) # id
return R_map, S_map
def pp(lattice):
"""
Used in debugging to print the current lattice.
"""
for i in range(100):
for j in range(100):
try:
R = lattice[i,j]
print i, j, R
except KeyError:
break
def construction_tower(R):
tower = [(None, R)]
c = R.construction()
while c is not None:
f, R = c
if not isinstance(f, ConstructionFunctor):
f = BlackBoxConstructionFunctor(f)
tower.append((f,R))
c = R.construction()
return tower
def type_to_parent(P):
import sage.rings.all
if P in [int, long]:
return sage.rings.all.ZZ
elif P is float:
return sage.rings.all.RDF
elif P is complex:
return sage.rings.all.CDF
else:
raise TypeError, "Not a scalar type."
| Python |
from siegel_modular_form import SiegelModularForm, SiegelModularForm_class, SMF_DEFAULT_PREC
from sage.algebras.algebra import Algebra
from sage.misc.all import cached_method
from sage.rings.all import ZZ
from sage.structure.factory import UniqueFactory
class SiegelModularFormsAlgebraFactory(UniqueFactory):
"""
A factory for creating algebras of Siegel modular forms. It
handles making sure that they are unique as well as handling
pickling. For more details, see
:class:`~sage.structure.factory.UniqueFactory` and
:mod:`~sage.modular.siegel.siegel_modular_forms_algebra`.
EXAMPLES::
sage: S = SiegelModularFormsAlgebra()
sage: S.construction()
(SMFAlg{"Sp(4,Z)", "even", 2, 101}, Integer Ring)
sage: R.<a, b> = QQ[]
sage: S = SiegelModularFormsAlgebra(coeff_ring=R)
sage: S.construction()
(SMFAlg{"Sp(4,Z)", "even", 2, 101}, Multivariate Polynomial Ring in a, b over Rational Field)
sage: S is loads(dumps(S))
True
sage: TestSuite(S).run()
"""
def create_key(self, coeff_ring=ZZ, group='Sp(4,Z)', weights='even', degree=2, default_prec=SMF_DEFAULT_PREC):
"""
Create a key which uniquely defines this algebra of Siegel modular
forms.
TESTS::
sage: SiegelModularFormsAlgebra.create_key(coeff_ring=QQ, group='Gamma0(5)', weights='all', degree=2, default_prec=41)
(SMFAlg{"Gamma0(5)", "all", 2, 41}(FractionField(...)), Integer Ring)
"""
from sage.rings.ring import is_Ring
if not is_Ring(coeff_ring):
raise TypeError, 'The coefficient ring must be a ring'
if not (isinstance(group, str) or group is None):
raise TypeError, 'The group must be given by a string, or None'
if not weights in ('even', 'all'):
raise ValueError, "The argument weights must be 'even' or 'all'"
try:
degree = int(degree)
except TypeError:
raise TypeError, 'The degree must be a positive integer'
if degree < 1:
raise ValueError, 'The degree must be a positive integer'
if degree == 1:
raise ValueError, 'Use ModularForms if you want to work with Siegel modular forms of degree 1'
if degree > 2:
raise NotImplementedError, 'Siegel modular forms of degree > 2 are not yet implemented'
try:
default_prec = int(default_prec)
except TypeError:
raise TypeError, 'The default precision must be a positive integer'
from pushout import SiegelModularFormsAlgebraFunctor
F = SiegelModularFormsAlgebraFunctor(group=group, weights=weights, degree=degree, default_prec=default_prec)
while hasattr(coeff_ring, 'construction'):
C = coeff_ring.construction()
if C is None:
break
F = F * C[0]
coeff_ring = C[1]
return (F, coeff_ring)
def create_object(self, version, key):
"""
Return the algebra of Siegel modular forms corresponding to the
key ``key``.
TESTS::
sage: key = SiegelModularFormsAlgebra.create_key(coeff_ring=QQ, group='Gamma0(5)', weights='all', degree=2, default_prec=41)
sage: SiegelModularFormsAlgebra.create_object('1.0', key)
Algebra of Siegel modular forms of degree 2 and all weights on Gamma0(5) over Rational Field
"""
C, R = key
from pushout import CompositConstructionFunctor, SiegelModularFormsAlgebraFunctor
if isinstance(C, CompositConstructionFunctor):
F = C.all[-1]
if len(C.all) > 1:
R = CompositConstructionFunctor(*C.all[:-1])(R)
else:
F = C
if not isinstance(F, SiegelModularFormsAlgebraFunctor):
raise TypeError, "We expected a SiegelModularFormsAlgebraFunctor, not %s"%type(F)
return SiegelModularFormsAlgebra_class(coeff_ring=R, group=F._group, weights=F._weights, degree=F._degree, default_prec=F._default_prec)
SiegelModularFormsAlgebra = SiegelModularFormsAlgebraFactory('SiegelModularFormsAlgebra')
class SiegelModularFormsAlgebra_class(Algebra):
def __init__(self, coeff_ring=ZZ, group='Sp(4,Z)', weights='even', degree=2, default_prec=SMF_DEFAULT_PREC):
r"""
Initialize an algebra of Siegel modular forms of degree ``degree``
with coefficients in ``coeff_ring``, on the group ``group``.
If ``weights`` is 'even', then only forms of even weights are
considered; if ``weights`` is 'all', then all forms are
considered.
EXAMPLES::
sage: A = SiegelModularFormsAlgebra(QQ)
sage: B = SiegelModularFormsAlgebra(ZZ)
sage: A._coerce_map_from_(B)
True
sage: B._coerce_map_from_(A)
False
sage: A._coerce_map_from_(ZZ)
True
"""
self.__coeff_ring = coeff_ring
self.__group = group
self.__weights = weights
self.__degree = degree
self.__default_prec = default_prec
R = coeff_ring
from sage.algebras.all import GroupAlgebra
if isinstance(R, GroupAlgebra):
R = R.base_ring()
from sage.rings.polynomial.polynomial_ring import is_PolynomialRing
if is_PolynomialRing(R):
self.__base_ring = R.base_ring()
else:
self.__base_ring = R
from sage.categories.all import Algebras
Algebra.__init__(self, base=self.__base_ring, category=Algebras(self.__base_ring))
@cached_method
def gens(self, prec=None):
"""
Return the ring generators of this algebra.
EXAMPLES::
sage: S = SiegelModularFormsAlgebra()
sage: S.gens()
[Igusa_4, Igusa_6, Igusa_10, Igusa_12]
TESTS::
sage: S = SiegelModularFormsAlgebra(group='Gamma0(2)')
sage: S.gens()
Traceback (most recent call last):
...
NotImplementedError: Not yet implemented
"""
if prec is None:
prec = self.default_prec()
return _siegel_modular_forms_generators(self, prec=prec)
def is_commutative(self):
r"""
Return True since all our algebras are commutative.
EXAMPLES::
sage: S = SiegelModularFormsAlgebra(coeff_ring=QQ)
sage: S.is_commutative()
True
"""
return True
@cached_method
def ngens(self):
r"""
Return the number of generators of this algebra of Siegel modular
forms.
EXAMPLES::
sage: S = SiegelModularFormsAlgebra(coeff_ring=QQ)
sage: S.ngens()
4
"""
return len(self.gens())
@cached_method
def gen(self, i, prec=None):
r"""
Return the `i`-th generator of this algebra.
EXAMPLES::
sage: S = SiegelModularFormsAlgebra(coeff_ring=QQ)
sage: S.ngens()
4
sage: S.gen(2)
Igusa_10
"""
return self.gens(prec=prec)[i]
def coeff_ring(self):
r"""
Return the ring of coefficients of this algebra.
EXAMPLES::
sage: S = SiegelModularFormsAlgebra(coeff_ring=QQ)
sage: S.coeff_ring()
Rational Field
"""
return self.__coeff_ring
def group(self):
"""
Return the modular group of this algebra.
EXAMPLES::
sage: S = SiegelModularFormsAlgebra(group='Gamma0(7)')
sage: S.group()
'Gamma0(7)'
"""
return self.__group
def weights(self):
"""
Return 'even' or 'all' depending on whether this algebra
contains only even weight forms, or forms of all weights.
EXAMPLES::
sage: S = SiegelModularFormsAlgebra(weights='even')
sage: S.weights()
'even'
sage: S = SiegelModularFormsAlgebra(weights='all')
sage: S.weights()
'all'
"""
return self.__weights
def degree(self):
"""
Return the degree of the modular forms in this algebra.
EXAMPLES::
sage: S = SiegelModularFormsAlgebra()
sage: S.degree()
2
"""
return self.__degree
def default_prec(self):
"""
Return the default precision for the Fourier expansions of
modular forms in this algebra.
EXAMPLES::
sage: S = SiegelModularFormsAlgebra(default_prec=41)
sage: S.default_prec()
41
"""
return self.__default_prec
def _repr_(self):
r"""
Return the plain text representation of this algebra.
EXAMPLES::
sage: S = SiegelModularFormsAlgebra(coeff_ring=QQ)
sage: S._repr_()
'Algebra of Siegel modular forms of degree 2 and even weights on Sp(4,Z) over Rational Field'
"""
return 'Algebra of Siegel modular forms of degree %s and %s weights on %s over %s'%(self.__degree, self.__weights, self.__group, self.__coeff_ring)
def _latex_(self):
r"""
Return the latex representation of this algebra.
EXAMPLES::
sage: S = SiegelModularFormsAlgebra(coeff_ring=QQ)
sage: S._latex_()
'\\texttt{Algebra of Siegel modular forms of degree }2\\texttt{ and even weights on Sp(4,Z) over }\\Bold{Q}'
"""
from sage.misc.all import latex
return r'\texttt{Algebra of Siegel modular forms of degree }%s\texttt{ and %s weights on %s over }%s' %(latex(self.__degree), self.__weights, self.__group, latex(self.__coeff_ring))
def _coerce_map_from_(self, other):
r"""
Return True if it is possible to coerce from ``other`` into the
algebra of Siegel modular forms ``self``.
EXAMPLES::
sage: S = SiegelModularFormsAlgebra(coeff_ring=QQ)
sage: R = SiegelModularFormsAlgebra(coeff_ring=ZZ)
sage: S._coerce_map_from_(R)
True
sage: R._coerce_map_from_(S)
False
sage: S._coerce_map_from_(ZZ)
True
"""
if self.base_ring().has_coerce_map_from(other):
return True
if isinstance(other, SiegelModularFormsAlgebra_class):
if (self.group() == other.group()) or (other.group() == 'Sp(4,Z)'):
if self.coeff_ring().has_coerce_map_from(other.coeff_ring()):
if self.degree() == other.degree():
return True
return False
def _element_constructor_(self, x):
r"""
Return the element of the algebra ``self`` corresponding to ``x``.
EXAMPLES::
sage: S = SiegelModularFormsAlgebra(coeff_ring=QQ)
sage: B = SiegelModularFormsAlgebra(coeff_ring=ZZ).1
sage: S(B)
Igusa_6
sage: S(1/5)
1/5
sage: S(1/5).parent() is S
True
sage: S._element_constructor_(2.67)
Traceback (most recent call last):
...
TypeError: Unable to construct an element of Algebra of Siegel modular forms of degree 2 and even weights on Sp(4,Z) over Rational Field corresponding to 2.67000000000000
sage: S.base_extend(RR)._element_constructor_(2.67)
2.67000000000000
"""
if isinstance(x, (int, long)):
x = ZZ(x)
if isinstance(x, float):
from sage.rings.all import RR
x = RR(x)
if isinstance(x, complex):
from sage.rings.all import CC
x = CC(x)
if isinstance(x.parent(), SiegelModularFormsAlgebra_class):
d = dict((f, self.coeff_ring()(x[f])) for f in x.coeffs())
return self.element_class(parent=self, weight=x.weight(), coeffs=d, prec=x.prec(), name=x.name())
R = self.base_ring()
if R.has_coerce_map_from(x.parent()):
d = {(0, 0, 0): R(x)}
from sage.rings.all import infinity
return self.element_class(parent=self, weight=0, coeffs=d, prec=infinity, name=str(x))
else:
raise TypeError, "Unable to construct an element of %s corresponding to %s" %(self, x)
Element = SiegelModularForm_class
def _an_element_(self):
r"""
Return an element of the algebra ``self``.
EXAMPLES::
sage: S = SiegelModularFormsAlgebra(coeff_ring=QQ)
sage: z = S._an_element_()
sage: z in S
True
"""
return self(0)
def base_extend(self, R):
r"""
Extends the base ring of the algebra ``self`` to ``R``.
EXAMPLES::
sage: S = SiegelModularFormsAlgebra(coeff_ring=QQ)
sage: S.base_extend(RR)
Algebra of Siegel modular forms of degree 2 and even weights on Sp(4,Z) over Real Field with 53 bits of precision
"""
#B = self.base_ring()
S = self.coeff_ring()
from sage.rings.polynomial.polynomial_ring import is_PolynomialRing
if is_PolynomialRing(S):
xS = S.base_extend(R)
elif R.has_coerce_map_from(S):
xS = R
else:
raise TypeError, "cannot extend to %s" %R
return SiegelModularFormsAlgebra(coeff_ring=xS, group=self.group(), weights=self.weights(), degree=self.degree(), default_prec=self.default_prec())
def construction(self):
r"""
Return the construction of the algebra ``self``.
EXAMPLES::
sage: S = SiegelModularFormsAlgebra(coeff_ring=QQ)
sage: S.construction()
(SMFAlg{"Sp(4,Z)", "even", 2, 101}, Rational Field)
"""
from pushout import SiegelModularFormsAlgebraFunctor
return SiegelModularFormsAlgebraFunctor(self.group(), self.weights(), self.degree(), self.default_prec()), self.coeff_ring()
def _siegel_modular_forms_generators(parent, prec=None, degree=0):
r"""
Compute the four Igusa generators of the ring of Siegel modular forms
of degree 2 and level 1 and even weight (this happens if weights='even').
If weights = 'all' you get the Siegel modular forms of degree 2, level 1
and even and odd weight.
EXAMPLES::
sage: A, B, C, D = SiegelModularFormsAlgebra().gens()
sage: C[(2, 0, 9)]
-390420
sage: D[(4, 2, 5)]
17689760
sage: A2, B2, C2, D2 = SiegelModularFormsAlgebra().gens(prec=50)
sage: A[(1, 0, 1)] == A2[(1, 0, 1)]
True
sage: A3, B3, C3, D3 = SiegelModularFormsAlgebra().gens(prec=500)
sage: B2[(2, 1, 3)] == B3[(2, 1, 3)]
True
TESTS::
sage: from sage.modular.siegel.siegel_modular_forms_algebra import _siegel_modular_forms_generators
sage: S = SiegelModularFormsAlgebra()
sage: S.gens() == _siegel_modular_forms_generators(S)
True
"""
group = parent.group()
weights = parent.weights()
if prec is None:
prec = parent.default_prec()
if group == 'Sp(4,Z)' and 0 == degree:
from sage.modular.all import ModularForms
E4 = ModularForms(1, 4).gen(0)
M6 = ModularForms(1, 6)
E6 = ModularForms(1, 6).gen(0)
M8 = ModularForms(1, 8)
M10 = ModularForms(1, 10)
Delta = ModularForms(1, 12).cuspidal_subspace().gen(0)
M14 = ModularForms(1, 14)
A = SiegelModularForm(60*E4, M6(0), prec=prec, name='Igusa_4')
B = SiegelModularForm(-84*E6, M8(0), prec=prec, name='Igusa_6')
C = SiegelModularForm(M10(0), -Delta, prec=prec, name='Igusa_10')
D = SiegelModularForm(Delta, M14(0), prec=prec, name='Igusa_12')
# TODO: the base_ring of A, B, ... should be ZZ
# Here a hack for now:
a = [A, B, C, D]
b = []
from sage.rings.all import ZZ
for F in a:
c = F.coeffs()
for f in c.iterkeys():
c[f] = ZZ(c[f])
F = parent.element_class(parent=parent, weight=F.weight(), coeffs=c, prec=prec, name=F.name())
b.append(F)
if weights == 'even': return b
if weights == 'all':
from fastmult import chi35
coeffs35 = chi35(prec, b[0], b[1], b[2], b[3])
from sage.groups.all import KleinFourGroup
G = KleinFourGroup()
from sage.algebras.all import GroupAlgebra
R = GroupAlgebra(G)
det = R(G.gen(0))
E = parent.element_class(parent=parent, weight=35, coeffs=coeffs35, prec=prec, name='Delta_35')
E = E*det
b.append(E)
return b
raise ValueError, "weights = '%s': should be 'all' or 'even'" %weights
if group == 'Sp(4,Z)' and weights == 'even' and 2 == degree:
b = _siegel_modular_forms_generators(parent=parent)
c = []
for F in b:
i = b.index(F)
for G in b[(i+1):]:
c.append(F.satoh_bracket(G))
return c
raise NotImplementedError, "Not yet implemented"
| Python |
"""
Precision for Fourier expansions of Siegel modular forms
"""
from copy import deepcopy
import operator
from sage.rings.integer import Integer
from sage.rings.integer_ring import ZZ
from sage.functions.other import floor
from sage.functions.other import ceil
from sage.misc.functional import isqrt
from sage.structure.sage_object import SageObject
from sage.structure.element import RingElement
from sage.rings.all import infinity
import sage.structure.element
from sage.misc.latex import latex
#from copy import deepcopy
#import operator
#from sage.rings.integer import Integer
#from sage.functions.other import (floor, ceil)
#from sage.misc.functional import isqrt
#from sage.structure.sage_object import SageObject
#from sage.rings.all import infinity
#from fastmult import reduce_GL
#load 'fastmult.spyx'
#from fastmult import reduce_GL
class SiegelModularFormPrecision (SageObject):
r"""
Stores information on the precision of the Fourier expansion of a Siegel
modular form and provides checking.
"""
def __init__(self, prec):
r"""
INPUT
prec -- an integer or infinity or a triple (aprec, bprec, cprec) of integers.
or an instance of class SiegelModularFormPrecision
NOTE
We distinguish two types of precision bounds:
'disc' or 'box'. prec indicates that all terms q^(a,b,c)
with GL(2,Z)-reduced (a,b,c) are available such that
either 4ac-b^2 < prec ('disc'-precision) or else
one has componentwise
(a,b,c) < ( aprec, bprec, cprec)
('box'-precision).
EXAMPLES::
sage: from sage.modular.siegel.siegel_modular_form_prec import SiegelModularFormPrecision
sage: prec = SiegelModularFormPrecision(101)
sage: prec2 = SiegelModularFormPrecision(prec)
sage: prec
Discriminant precision for Siegel modular form with bound 101
sage: prec2
Discriminant precision for Siegel modular form with bound 101
sage: prec == prec2
True
sage: prec3 = SiegelModularFormPrecision((5,5,5))
sage: prec3
Box precision for Siegel modular form with bound (5, 5, 5)
sage: prec4 = SiegelModularFormPrecision(infinity)
sage: prec4
Infinity precision for Siegel modular form with bound +Infinity
sage: prec5 = SiegelModularFormPrecision((5,0,5))
sage: prec5.prec()
(0, 0, 0)
TESTS::
sage: prec = SiegelModularFormPrecision(101)
sage: TestSuite(prec).run()
"""
## copy constructor
if isinstance(prec, SiegelModularFormPrecision):
self.__type = deepcopy(prec.type())
self.__prec = deepcopy(prec.prec())
elif prec is infinity:
self.__type = 'infinity'
self.__prec = infinity
elif isinstance(prec, (int, Integer)):
self.__type = 'disc'
prec = max( 0, prec)
Dmod = prec % 4
if Dmod >= 2:
self.__prec = Integer(prec - Dmod + 1)
else:
self.__prec = Integer(prec)
elif isinstance(prec, tuple) and len(prec) == 3 and all([isinstance(e, (int, Integer)) for e in list(prec)]):
self.__type = 'box'
a,b,c = prec
a = min( a, c)
b = min( b, a)
if b <= 0:
self.__prec = ( 0,0,0 )
else:
self.__prec = ( Integer(a), Integer(b), Integer(c))
else:
raise TypeError, "incorrect type %s for prec" % type(prec)
def _repr_(self):
r"""
Returns the repr of self
EXAMPLES::
sage: from sage.modular.siegel.siegel_modular_form_prec import SiegelModularFormPrecision
sage: prec = SiegelModularFormPrecision(101)
sage: prec._repr_()
'Discriminant precision for Siegel modular form with bound 101'
"""
if self.type() == 'infinity':
n = "Infinity"
elif self.type() == 'disc':
n = "Discriminant"
elif self.type() == 'box':
n = "Box"
else:
raise RuntimeError, "Unexpected value of self.__type"
return "%s precision for Siegel modular form with bound %s" % \
(n, repr(self.__prec))
def _latex_(self):
r"""
Returns the latex of self
EXAMPLES::
sage: from sage.modular.siegel.siegel_modular_form_prec import SiegelModularFormPrecision
sage: prec = SiegelModularFormPrecision(101)
sage: prec._latex_()
'Discriminant precision for Siegel modular form with bound $101$'
"""
if self.__type == 'infinity':
n = "Infinity"
elif self.__type == 'disc':
n = "Discriminant"
elif self.__type == 'box':
n = "Box"
else:
raise ValueError, "Unexpected value of self.__type"
return "%s precision for Siegel modular form with bound $%s$" %(str(n),str(latex(self.__prec)))
def type(self):
r"""
Returns the type of self: box, disc or infinity
EXAMPLES::
sage: from sage.modular.siegel.siegel_modular_form_prec import SiegelModularFormPrecision
sage: prec = SiegelModularFormPrecision((2,2,2))
sage: prec = SiegelModularFormPrecision(infinity)
sage: prec.type()
'infinity'
sage: prec = SiegelModularFormPrecision(101)
sage: prec.type()
'disc'
"""
return self.__type
def prec(self):
r"""
Returns the tuple of the maximal box, the integer for the maximal discriminant
and infinity otherwise. If self is of type disc then it will return the
largest fundamental discriminant just below.
EXAMPLES::
sage: from sage.modular.siegel.siegel_modular_form_prec import SiegelModularFormPrecision
sage: prec = SiegelModularFormPrecision(11)
sage: prec.prec()
9
sage: prec = SiegelModularFormPrecision(8)
sage: prec.prec()
8
"""
return self.__prec
def is_in_bound(self, t):
r"""
Return True or False accordingly as the GL(2,Z)-reduction of
the tuple (a,b,c)=t is within the bounds of this precision.
EXAMPLES::
sage: from sage.modular.siegel.siegel_modular_form_prec import SiegelModularFormPrecision
sage: prec = SiegelModularFormPrecision(101)
sage: prec.is_in_bound((1,0,1))
True
sage: prec.is_in_bound((0,0,25))
True
sage: prec.is_in_bound((0,0,26))
False
sage: prec.is_in_bound((6,0,6))
False
sage: prec = SiegelModularFormPrecision((2,2,2))
sage: prec.is_in_bound((1,0,1))
True
sage: prec.is_in_bound((2,2,2))
False
TODO
fix this
NOTE
It is assumed that (a,b,c) is semi positive definite
"""
(a, b, c) = t
from fastmult import reduce_GL
if self.__type == 'infinity':
return True
elif self.__type == 'disc':
(a,b,c) = reduce_GL(a, b, c)
if a == 0 and b == 0:
return c < self.get_contents_bound_for_semi_definite_forms()
D = 4*a*c-b**2
if D < 0:
return False
if D > 0:
return D < self.__prec
elif self.__type == 'box':
(a, b, c) = reduce_GL(a, b, c)
return a < self.__prec[0] and b < self.__prec[1] and c < self.__prec[2]
else:
raise RuntimeError, "Unexpected value of self.__type"
def get_contents_bound_for_semi_definite_forms(self):
r"""
Return the bound for the contents of a semi positive definite
form falling within this precision.
EXAMPLES::
sage: from sage.modular.siegel.siegel_modular_form_prec import SiegelModularFormPrecision
sage: prec = SiegelModularFormPrecision(7)
sage: prec.get_contents_bound_for_semi_definite_forms()
2
sage: prec = SiegelModularFormPrecision(101)
sage: prec.get_contents_bound_for_semi_definite_forms()
26
NOTE
If (a,b,c) is semi positive definite, then it is GL(2,Z)-equivalent
to a the form (0,0,g) where g is the contents (gcd) of a,b,c.
I don't know what this does. It seems to only do it for singular forms-- NR
"""
if self.__type == 'infinity':
return infinity
elif self.__type == 'disc':
return ceil((self.__prec+1)/4)
elif self.__type == 'box':
return self.__prec[2]
else:
raise RuntimeError, "Unexpected value of self.__type"
def __lt__(self, other):
r"""
Return True if the set of GL(2,Z)-reduced forms within the precision self
is contained in but not equal to the coresponding set of forms within the
precision other.
EXAMPLES::
sage: from sage.modular.siegel.siegel_modular_form_prec import SiegelModularFormPrecision
sage: prec1 = SiegelModularFormPrecision(101)
sage: prec2 = SiegelModularFormPrecision(100)
sage: prec3 = SiegelModularFormPrecision(201)
sage: prec1
Discriminant precision for Siegel modular form with bound 101
sage: prec2
Discriminant precision for Siegel modular form with bound 100
sage: prec2 < prec1
True
sage: prec3 < prec1
False
sage: prec1.__lt__(prec3)
True
"""
if not isinstance(other, SiegelModularFormPrecision):
raise NotImplementedError, "can only compare with elements of the same class"
## TODO: implement comparison of precisions of different types
if self.__type != other.__type:
return False
if self.__type == 'box':
a,b,c = self.__prec
ao,bo,co = other.__prec
return a <= ao and b <= bo and c <= co \
and any([a < ao, b < bo, c < co])
elif self.__type == 'disc':
return self.__prec < other.__prec
else:
raise RuntimeError, "Unexpected value of self.__type"
def __le__(self, other):
r"""
Returns whether self <= other
EXAMPLES::
sage: from sage.modular.siegel.siegel_modular_form_prec import SiegelModularFormPrecision
sage: prec1 = SiegelModularFormPrecision(101)
sage: prec2 = SiegelModularFormPrecision(100)
sage: prec3 = SiegelModularFormPrecision(101)
sage: prec1 <= prec3
True
sage: prec1 <= prec2
False
sage: prec1 <= prec1
True
sage: prec4 = SiegelModularFormPrecision(infinity)
sage: prec5 = SiegelModularFormPrecision((5,5,5))
sage: prec5.__le__(prec4)
False
TO DO:
It seems eevrything should be <= infinity
"""
return self.__lt__(other) or self.__eq__(other)
def __eq__(self, other):
r"""
Returns self == other as defined by having the same prec and type
EXAMPLES::
sage: from sage.modular.siegel.siegel_modular_form_prec import SiegelModularFormPrecision
sage: prec1 = SiegelModularFormPrecision(101)
sage: prec2 = SiegelModularFormPrecision(100)
sage: prec3 = SiegelModularFormPrecision(101)
sage: prec4 = SiegelModularFormPrecision(infinity)
sage: prec5 = SiegelModularFormPrecision((5,5,5))
sage: prec1 == prec2
False
sage: prec1 == prec3
True
sage: prec4 == prec2
False
sage: prec4 == prec4
True
sage: prec5.__eq__(prec5)
True
"""
if not isinstance(other, SiegelModularFormPrecision):
raise NotImplementedError, "can only compare with elements of the same class"
return ( self.__type == other.type() and self.__prec == other.prec())
def __ne__(self, other):
r"""
Returns self != other
EXAMPLES::
sage: from sage.modular.siegel.siegel_modular_form_prec import SiegelModularFormPrecision
sage: prec1 = SiegelModularFormPrecision(101)
sage: prec2 = SiegelModularFormPrecision(100)
sage: prec3 = SiegelModularFormPrecision(101)
sage: prec1.__ne__(prec1)
False
sage: prec1 != prec2
True
sage: prec1 != prec3
False
"""
return not self.__eq__(other)
def __gt__(self, other):
r"""
Returns self > other
EXAMPLES::
sage: from sage.modular.siegel.siegel_modular_form_prec import SiegelModularFormPrecision
sage: prec = SiegelModularFormPrecision(101)
sage: prec2 = SiegelModularFormPrecision(100)
sage: prec > prec2
True
sage: prec2.__gt__(prec)
False
"""
return other.__lt__(self)
def __ge__(self, other):
r"""
Returns self >= other
EXAMPLES::
sage: from sage.modular.siegel.siegel_modular_form_prec import SiegelModularFormPrecision
sage: prec = SiegelModularFormPrecision(101)
sage: prec2 = SiegelModularFormPrecision(100)
sage: prec >= prec2
True
sage: prec.__ge__(prec)
True
"""
return self.__eq__(other) or other.__lt__(self)
def __iter__(self):
r"""
Iterate over all GL(2,Z)-reduced semi positive forms
which are within the bounds of this precision.
EXAMPLES::
sage: from sage.modular.siegel.siegel_modular_form_prec import SiegelModularFormPrecision
sage: prec = SiegelModularFormPrecision(11)
sage: for k in prec.__iter__(): print k
(0, 0, 0)
(0, 0, 1)
(0, 0, 2)
(1, 0, 1)
(1, 0, 2)
(1, 1, 1)
(1, 1, 2)
NOTE
The forms are enumerated in lexicographic order.
"""
if self.__type == 'disc':
bound = self.get_contents_bound_for_semi_definite_forms()
for c in xrange(0, bound):
yield (0,0,c)
atop = isqrt(self.__prec // 3)
if 3*atop*atop == self.__prec: atop -= 1
for a in xrange(1,atop + 1):
for b in xrange(a+1):
for c in xrange(a, ceil((b**2 + self.__prec)/(4*a))):
yield (a,b,c)
elif 'box' == self.__type:
(am, bm, cm) = self.__prec
for a in xrange(am):
for b in xrange( min(bm,a+1)):
for c in xrange(a, cm):
yield (a,b,c)
else:
raise RuntimeError, "Unexpected value of self.__type"
raise StopIteration
def positive_forms(self):
r"""
Iterate over all GL(2,Z)-reduced strictly positive forms
which are within the bounds of this precision.
EXAMPLES::
sage: from sage.modular.siegel.siegel_modular_form_prec import SiegelModularFormPrecision
sage: prec = SiegelModularFormPrecision(11)
sage: for k in prec.positive_forms(): print k
(1, 0, 1)
(1, 0, 2)
(1, 1, 1)
(1, 1, 2)
NOTE
The forms are enumerated in lexicographic order.
"""
if self.__type == 'disc':
atop = isqrt(self.__prec // 3)
if 3*atop*atop == self.__prec: atop -= 1
for a in xrange(1,atop + 1):
for b in xrange(a+1):
for c in xrange(a, ceil((b**2 + self.__prec)/(4*a))):
yield (a,b,c)
elif 'box' == self.__type:
(am, bm, cm) = self.__prec
for a in xrange(am):
for b in xrange( min(bm,a+1)):
for c in xrange(a, cm):
yield (a,b,c)
else:
raise RuntimeError, "Unexpected value of self.__type"
raise StopIteration
| Python |
from siegel_modular_form import SiegelModularForm
from siegel_modular_forms_algebra import SiegelModularFormsAlgebra
| Python |
"""
The implementation of a type of modular forms, that implements all potential features.
It is meant to be used in doctests.
AUTHOR :
- Martin Raum (2010 - 09 - 26) Initial version.
"""
#===============================================================================
#
# Copyright (C) 2010 Martin Raum
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 3
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, see <http://www.gnu.org/licenses/>.
#
#===============================================================================
from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
from psage.modform.fourier_expansion_framework.modularforms.modularform_ambient import ModularFormsRing_generic,\
ModularFormsModule_generic
from psage.modform.fourier_expansion_framework.modularforms.modularform_types import ModularFormType_abstract
from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import NNMonoid, \
NNFilter, TrivialCharacterMonoid, TrivialRepresentation
from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import EquivariantMonoidPowerSeries
from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_module import EquivariantMonoidPowerSeriesModule
from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import EquivariantMonoidPowerSeriesRing
from operator import xor
from sage.misc.cachefunc import cached_method
from sage.modules.all import FreeModule
from sage.rings.all import Integer
from sage.rings.all import ZZ, PolynomialRing
from sage.structure.all import Sequence, SageObject
#===============================================================================
# ModularFormTestType_scalar
#===============================================================================
class ModularFormTestType_scalar ( ModularFormType_abstract ) :
nmb_gens = 5
def __init__(self) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_testtype import *
sage: t = ModularFormTestType_scalar()
"""
ModularFormType_abstract.__init__(self)
def _ambient_construction_function(self) :
"""
Return a function which will can be called by :function:~`fourier_expansion_framework.modularforms.modularform_ambient.ModularFormsAmbient`.
OUTPUT:
A function.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_testtype import *
sage: t = ModularFormTestType_scalar()
sage: h = t._ambient_construction_function()(QQ, t, NNFilter(4))
"""
return lambda A, type, precision, **kwds : \
ModularFormsRing_generic(A, type,
NNFilter(precision) if isinstance(precision, (int, Integer)) else precision, **kwds)
def group(self) :
"""
Return the modular group this type. Here it will act trivially
OUTPUT:
A string.
TESTS::
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_testtype import *
sage: t = ModularFormTestType_scalar()
sage: t.group()
'1'
"""
return "1"
@cached_method
def _g(self, i, precision) :
"""
Return the Fourier expansion of the i-th generator.
INPUT:
- ``precision`` -- An instance of :class:~`fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids.NNFilter`.
OUTPUT:
An element of :class:`~fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring.EquivariantMonoidPowerSeriesRing`.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_testtype import *
sage: t = ModularFormTestType_scalar()
sage: t._g(2, NNFilter(3)).coefficients()
{2: 1}
"""
ea = TestExpansionAmbient(ZZ)
return EquivariantMonoidPowerSeries(ea , {ea.characters().one_element(): {i: 1}}, NNFilter(precision) )
def generators(self, K, precision) :
"""
The generators for modular forms with coefficients in `K`.
INPUT:
- `K` -- A ring.
- ``precision`` -- An instance of :class:~`fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids.NNFilter`.
OUTPUT:
A sequence of elements of :class:`~fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring.EquivariantMonoidPowerSeriesRing`.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_testtype import *
sage: t = ModularFormTestType_scalar()
sage: t.generators(QQ, NNFilter(4))
[Equivariant monoid power series in Ring of equivariant monoid power series over NN, Equivariant monoid power series in Ring of equivariant monoid power series over NN, Equivariant monoid power series in Ring of equivariant monoid power series over NN, Equivariant monoid power series in Ring of equivariant monoid power series over NN, Equivariant monoid power series in Ring of equivariant monoid power series over NN]
"""
if K.has_coerce_map_from(ZZ) :
return Sequence( [ self._g(i, precision) for i in range(self.nmb_gens) ],
universe = TestExpansionAmbient(K) )
raise NotImplementedError
def grading(self, K) :
"""
The weight grading of the underlying ring of modular form with
coefficients in `K`.
INPUT:
- `K` -- A ring.
OUTPUT:
An instance of :class:`~fourier_expansion_framework.gradedexpansions.gradedexpansion_grading.Grading_abstract`.
TESTS::
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_testtype import *
sage: t = ModularFormTestType_scalar()
sage: t.grading(QQ)
Degree grading (1, 2, 3, 4, 5)
"""
if K.has_coerce_map_from(ZZ) :
return DegreeGrading(range(1, self.nmb_gens + 1))
raise NotImplementedError
def _generator_names(self, K) :
"""
The generators' names for modular forms with coefficients in `K`.
INPUT:
- `K` -- A ring.
OUTPUT:
A list of strings.
TESTS::
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_testtype import *
sage: t = ModularFormTestType_scalar()
sage: t._generator_names(QQ)
['g1', 'g2', 'g3', 'g4', 'g5']
"""
return ["g%s" % (i,) for i in range(1, self.nmb_gens + 1)]
def _generator_by_name(self, K, name) :
"""
Given a name return the associated generator of modular forms with
coefficients in `K` in the underlying polynomial algebra.
INPUT:
- `K` -- A ring.
- ``name`` -- A string. The generator's name.
OUTPUT:
An element of a polynomial ring.
TESTS::
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_testtype import *
sage: t = ModularFormTestType_scalar()
sage: t._generator_by_name(QQ, 'g3')
g3
"""
if K.has_coerce_map_from(ZZ) :
R = self.generator_relations(K).ring()
try :
return R.gens()[self._generator_names(K).index(name)]
except ValueError :
raise ValueError( "Generator name %s doesn't exist for %s" % (name, K))
raise NotImplementedError
@cached_method
def generator_relations(self, K) :
"""
An ideal `I` in a polynomial ring `R` over `K`, such that the
associated ring is `R / I` surjects onto the ring of modular forms
with coefficients in `K`.
INPUT:
- `K` -- A ring.
OUTPUT:
An ideal in a polynomial ring.
TESTS::
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_testtype import *
sage: t = ModularFormTestType_scalar()
sage: t.generator_relations(QQ)
Ideal (g1^2 - g2, g1^3 - g3, g1^4 - g4, g1^5 - g5) of Multivariate Polynomial Ring in g1, g2, g3, g4, g5 over Rational Field
"""
if K.has_coerce_map_from(ZZ) :
R = PolynomialRing(K, self._generator_names(K))
g1 = R.gen(0)
return R.ideal([g1**i - g for (i,g) in list(enumerate([None] + list(R.gens())))[2:]])
raise NotImplementedError
def weights(self, K) :
"""
The weights of the generators of the ring of modular forms
with coefficients in `K`.
INPUT:
- `K` -- A ring.
OUTPUT:
A tuple of weights.
TESTS::
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_testtype import *
sage: t = ModularFormTestType_scalar()
sage: t.weights(QQ)
(1, 2, 3, 4, 5)
"""
return self.grading(K).gens()
def non_vector_valued(self) :
"""
Return the non vector values version of this type.
OUTPUT:
An instance of :class:`~fourier_expansion_framework.modularforms.modularform_types.ModularFormType_abstract`.
TESTS::
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_testtype import *
sage: t = ModularFormTestType_scalar()
sage: t.non_vector_valued() is t
True
"""
return self
def vector_valued(self) :
"""
Return the vector values version of this type.
OUTPUT:
An instance of :class:`~fourier_expansion_framework.modularforms.modularform_types.ModularFormType_abstract`.
TESTS::
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_testtype import *
sage: t = ModularFormTestType_scalar()
sage: t.vector_valued()
Test type of vector valued modular forms of rank 3
"""
return ModularFormTestType_vectorvalued()
def graded_submodules_are_free(self, K = None) :
"""
Return True if all submodules of forms of fixed grading according to
the grading given by :meth:~`.grading` are free.
OUTPUT:
A boolean.
TESTS::
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_testtype import *
sage: t = ModularFormTestType_scalar()
sage: t.graded_submodules_are_free()
True
"""
return True
def __cmp__(self, other) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_testtype import *
sage: t = ModularFormTestType_scalar()
sage: t == ModularFormTestType_scalar()
True
sage: t == ModularFormTestType_vectorvalued()
False
"""
return cmp(type(self), type(other))
def __hash__(self) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_testtype import *
sage: hash( ModularFormTestType_scalar() )
?? # 32-bit
-4492425810583750348 # 64-bit
"""
return reduce(xor, map(hash, [self.nmb_gens, self._repr_()] ) )
def _repr_(self) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_testtype import *
sage: ModularFormTestType_scalar()
Test type of modular forms with 5 generators
"""
return "Test type of modular forms with %s generators" % (self.nmb_gens,)
class ModularFormTestType_vectorvalued ( ModularFormType_abstract ) :
rank = 3
def __init__(self) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_testtype import *
sage: t = ModularFormTestType_vectorvalued()
"""
ModularFormType_abstract.__init__(self)
def _ambient_construction_function(self) :
"""
Return a function which will can be called by :function:~`fourier_expansion_framework.modularforms.modularform_ambient.ModularFormsAmbient`.
OUTPUT:
A function.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_testtype import *
sage: t = ModularFormTestType_vectorvalued()
sage: h = t._ambient_construction_function()(QQ, t, NNFilter(4, False))
"""
return lambda A, type, precision, **kwds : \
ModularFormsModule_generic(A, type,
NNFilter(precision) if isinstance(precision, (int, Integer)) else precision, **kwds)
def group(self) :
"""
Return the modular group this type. Here it will act trivially
OUTPUT:
A string.
TESTS::
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_testtype import *
sage: t = ModularFormTestType_vectorvalued()
sage: t.group()
'1'
"""
return "1"
@cached_method
def _g(self, i, precision) :
"""
Return the Fourier expansion of the i-th generator.
INPUT:
- ``precision`` -- An instance of :class:~`fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids.NNFilter`.
OUTPUT:
An element of :class:`~fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring.EquivariantMonoidPowerSeriesModule`.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_testtype import *
sage: t = ModularFormTestType_vectorvalued()
sage: t._g(2, NNFilter(3)).coefficients()
{1: (0, 0, 1)}
"""
if i < self.rank :
ea = TestExpansionAmbient_vv(ZZ)
cd = ea.coefficient_domain()
v = [0 for _ in range(self.rank)]
v[i] = 1
return EquivariantMonoidPowerSeries(ea , {ea.characters().one_element(): {1: cd(v)}}, NNFilter(precision) )
else :
raise ValueError( "%s-th generator is not definied" % (i,) )
def base_ring_generators(self, K, precision) :
"""
If the ring of modular forms can be interpreted as an algebra
over a ring of modular forms with much simpler Fourier coefficient
domains, it is a good idea to implement this here.
Return the Fourier expansions.
The parent of these expansions is expected to admit coercion
into the ring of the generators.
INPUT:
- `K` -- A ring.
- ``precision`` -- A precision instance.
OUTPUT:
``None`` or a sequence of equivariant monoid power series.
TESTS::
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_types import ModularFormType_abstract
sage: ModularFormType_abstract().base_ring_generators(QQ, None) is None
True
"""
return self.non_vector_valued().generators(K, precision)
def generators(self, K, precision) :
"""
The generators for modular forms with coefficients in `K`.
INPUT:
- `K` -- A ring.
- ``precision`` -- An instance of :class:~`fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids.NNFilter`.
OUTPUT:
A sequence of elements of :class:`~fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring.EquivariantMonoidPowerSeriesModule`.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_testtype import *
sage: t = ModularFormTestType_vectorvalued()
sage: t.generators(QQ, NNFilter(4))
[Equivariant monoid power series in Module of equivariant monoid power series over NN, Equivariant monoid power series in Module of equivariant monoid power series over NN, Equivariant monoid power series in Module of equivariant monoid power series over NN]
"""
if K.has_coerce_map_from(ZZ) :
return Sequence( [ self._g(i, precision) for i in range(self.rank) ],
universe = TestExpansionAmbient_vv(K) )
raise NotImplementedError
def grading(self, K) :
"""
The weight grading of the underlying ring of modular form with
coefficients in `K`.
INPUT:
K - A ring.
OUTPUT:
An instance of :class:`~fourier_expansion_framework.gradedexpansions.gradedexpansion_grading.Grading_abstract`.
TESTS::
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_testtype import *
sage: t = ModularFormTestType_vectorvalued()
sage: t.grading(QQ)
Degree grading (1, 2, 3, 4, 5, 3, 6, 9)
"""
if K.has_coerce_map_from(ZZ) :
return DegreeGrading(list(self.non_vector_valued().weights(K)) + range(3, 3 * self.rank + 1, 3))
raise NotImplementedError
def _generator_names(self, K) :
"""
The generators' names for modular forms with coefficients in `K`.
INPUT:
- `K` -- A ring.
OUTPUT:
A list of strings.
TESTS::
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_testtype import *
sage: t = ModularFormTestType_vectorvalued()
sage: t._generator_names(QQ)
['v1', 'v2', 'v3']
"""
return ["v%s" % (i,) for i in range(1, self.rank + 1)]
def _generator_by_name(self, K, name) :
"""
Given a name return the associated generator of modular forms with
coefficients in `K` in the underlying polynomial algebra.
INPUT:
- `K` -- A ring.
- ``name`` -- A string. The generator's name.
OUTPUT:
An element of a polynomial ring.
TESTS::
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_testtype import *
sage: t = ModularFormTestType_vectorvalued()
sage: t._generator_by_name(QQ, 'v3')
v3
"""
if K.has_coerce_map_from(ZZ) :
R = self.generator_relations(K).ring()
try :
return R.gens()[len(self.non_vector_valued()._generator_names(K)) + self._generator_names(K).index(name)]
except ValueError :
raise ValueError( "Generator name %s doesn't exist for %s" % (name, K))
raise NotImplementedError
@cached_method
def generator_relations(self, K) :
"""
An ideal `I` in a polynomial ring `R` over `K`, such that the
associated ring is `R / I` surjects onto the ring of modular forms
with coefficients in `K`.
INPUT:
- `K` -- A ring.
OUTPUT:
An ideal in a polynomial ring.
TESTS::
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_testtype import *
sage: t = ModularFormTestType_vectorvalued()
sage: t.generator_relations(QQ)
Ideal (g1^2 - g2, g1^3 - g3, g1^4 - g4, g1^5 - g5) of Multivariate Polynomial Ring in g1, g2, g3, g4, g5, v1, v2, v3 over Rational Field
"""
if K.has_coerce_map_from(ZZ) :
R = PolynomialRing(K, self.non_vector_valued()._generator_names(K) + self._generator_names(K))
return R.ideal().parent()(self.non_vector_valued().generator_relations(K))
raise NotImplementedError
def weights(self, K) :
"""
The weights of the generators of the ring of modular forms
with coefficients in `K`.
INPUT:
- `K` -- A ring.
OUTPUT:
A tuple of weights.
TESTS::
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_testtype import *
sage: t = ModularFormTestType_vectorvalued()
sage: t.weights(QQ)
(1, 2, 3, 4, 5, 3, 6, 9)
"""
return self.grading(K).gens()
def is_vector_valued(self) :
"""
``True`` if this is the vector valued version of a scalar valued type of modular forms.
OUTPUT:
A boolean.
TESTS::
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_testtype import *
sage: t = ModularFormTestType_vectorvalued()
sage: t.is_vector_valued()
True
"""
return True
def non_vector_valued(self) :
"""
Return the non vector values version of this type.
OUTPUT:
An instance of :class:`~fourier_expansion_framework.modularforms.modularform_types.ModularFormType_abstract`.
TESTS::
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_testtype import *
sage: t = ModularFormTestType_scalar()
sage: t.non_vector_valued()
Test type of modular forms with 5 generators
"""
return ModularFormTestType_scalar()
def vector_valued(self) :
"""
Return the vector values version of this type.
OUTPUT:
An instance of :class:`~fourier_expansion_framework.modularforms.modularform_types.ModularFormType_abstract`.
TESTS::
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_testtype import *
sage: t = ModularFormTestType_vectorvalued()
sage: t.vector_valued() is t
True
"""
return self
def graded_submodules_are_free(self, K = None) :
"""
Return True if all submodules of forms of fixed grading according to
the grading given by :meth:~`.grading` are free.
OUTPUT:
A boolean.
TESTS::
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_testtype import *
sage: t = ModularFormTestType_vectorvalued()
sage: t.graded_submodules_are_free()
True
"""
return True
def has_hecke_action(self) :
"""
Whether the associated modular forms are equipped with a Hecke action.
OUTPUT:
A boolean.
TESTS::
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_testtype import *
sage: t = ModularFormTestType_vectorvalued()
sage: t.has_hecke_action()
True
"""
return True
def _hecke_operator_class(self) :
"""
A class that implements the Hecke operation.
OUTPUT:
An class or function that constructs an instance.
TESTS::
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_testtype import *
sage: t = ModularFormTestType_vectorvalued()
sage: t._hecke_operator_class()(3)
Test Hecke operator with modulus 3
"""
return HeckeOperatorNN_test
def __cmp__(self, other) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_testtype import *
sage: t = ModularFormTestType_vectorvalued()
sage: t == ModularFormTestType_vectorvalued()
True
sage: t == ModularFormTestType_scalar()
False
"""
return cmp(type(self), type(other))
def __hash__(self) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_testtype import *
sage: hash( ModularFormTestType_vectorvalued() )
?? # 32-bit
-3841460515652797985 # 64-bit
"""
return reduce(xor, map(hash, [self.rank, self._repr_()] ) )
def _repr_(self) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_testtype import *
sage: ModularFormTestType_vectorvalued()
Test type of vector valued modular forms of rank 3
"""
return "Test type of vector valued modular forms of rank %s" % (self.rank,)
def TestExpansionAmbient(A) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_testtype import *
sage: ea = TestExpansionAmbient(QQ)
"""
return EquivariantMonoidPowerSeriesRing( NNMonoid(), TrivialCharacterMonoid("1", ZZ), TrivialRepresentation("1", A) )
def TestExpansionAmbient_vv(A) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_testtype import *
sage: ea = TestExpansionAmbient_vv(QQ)
"""
return EquivariantMonoidPowerSeriesModule( NNMonoid(), TrivialCharacterMonoid("1", ZZ), TrivialRepresentation("1", FreeModule(A, ModularFormTestType_vectorvalued.rank)) )
class HeckeOperatorNN_test ( SageObject ) :
def __init__(self, l) :
"""
INPUT:
- `l` -- An integer.
TESTS::
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_testtype import *
sage: h = HeckeOperatorNN_test(2)
"""
self.__l = l
def eval(self, expansion, weight = None) :
"""
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_testtype import *
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_ambient import *
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_testtype import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: h = HeckeOperatorNN_test(2)
sage: ma = ModularFormsModule_withheckeaction( QQ, ModularFormTestType_vectorvalued(), NNFilter(5) )
sage: h.eval(ma.0.fourier_expansion()).coefficients()
{1: {1: (1, 0, 0), 3: (1, 0, 0)}}
"""
precision = expansion.precision()
if precision.is_infinite() :
precision = expansion._bounding_precision()
characters = expansion.non_zero_components()
hecke_expansion = dict()
for ch in characters :
res = dict()
for (n, v) in expansion.coefficients(True)[ch].iteritems() :
for m in range(n, precision.index(), self.__l) :
try :
res[m] += v
except KeyError :
res[m] = v
hecke_expansion[ch] = res
result = expansion.parent()._element_constructor_(hecke_expansion)
result._set_precision(expansion.precision())
return result
def _repr_(self) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_testtype import *
sage: HeckeOperatorNN_test(2)
Test Hecke operator with modulus 2
"""
return "Test Hecke operator with modulus %s" % (self.__l,)
| Python |
r"""
Rings of orthogonal modular forms.
AUTHOR :
-- Martin Raum (2009 - 07 - 30) Initial version
"""
#===============================================================================
#
# Copyright (C) 2009 Martin Raum
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 3
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, see <http://www.gnu.org/licenses/>.
#
#===============================================================================
from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_module import GradedExpansionModule_class
from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import GradedExpansionRing_class
from psage.modform.fourier_expansion_framework.modularforms.modularform_element import ModularForm_generic
from psage.modform.fourier_expansion_framework.modularforms.modularform_functor import ModularFormsFunctor
from psage.modform.fourier_expansion_framework.modularforms.modularform_interfaces import ModularFormsAmbientWithHeckeAction_abstract
from psage.modform.fourier_expansion_framework.modularforms.modularform_submodule import ModularFormsWeightSubmodule
from sage.rings.integer import Integer
from sage.rings.integer_ring import ZZ
from sage.structure.element import Element
#===============================================================================
# ModularFormsAmbient
#===============================================================================
def ModularFormsAmbient( A, type, precision, *args, **kwds) :
"""
Create a ring or module of modular forms of given type. The underlying Fourier
expansions are calculated up to ``precision``.
INPUT:
- `A` -- A ring; The base ring for the modular forms.
- ``type`` -- An inystance of :class:~`fourier_expansion_framework.modularforms.modularform_types.ModularFormType_abstract`.
- ``precision`` -- A precision class.
- ``*arg`` -- Will be forwarded to the type's construction function.
- ``**kwds`` -- Will be forwarded to the type's construction function.
OUTPUT:
An instance of :class:~`ModularFormsAmbient_abstract`.
TESTS::
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_ambient import *
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_testtype import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: ma = ModularFormsAmbient( QQ, ModularFormTestType_scalar(), NNFilter(5) )
sage: ma = ModularFormsAmbient( QQ, ModularFormTestType_vectorvalued(), NNFilter(5), reduce_before_evaluating = False )
"""
if not 'reduce_before_evaluating' in kwds :
kwds['reduce_before_evaluating'] = type.reduce_before_evaluating(A)
return type._ambient_construction_function()(A, type, precision, *args, **kwds)
#===============================================================================
# ModularFormsAmbient_abstract
#===============================================================================
class ModularFormsAmbient_abstract :
"""
An abstract implementation of a graded expansion ambient, that deduced its structure from
data stored by a type of modular forms.
"""
def __init__(self, type, precision) :
"""
INPUT:
- ``type`` -- An inystance of :class:~`fourier_expansion_framework.modularforms.modularform_types.ModularFormType_abstract`.
- ``precision`` -- A precision class.
NOTE:
- The attribute ``_extended_base_ring`` must be set before calling the constructor or
will be ignored.
- The attribute ``_submodule_classes`` will be overwritten and has to be populated after calling the
constructor. See :meth:~`._submodule` for its description.
- The attribute ``_element_class`` may not be set if it has to be adopted from the type.
TESTS::
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_ambient import *
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_testtype import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: ma = ModularFormsAmbient_abstract( ModularFormTestType_scalar(), NNFilter(5) )
"""
self.__type = type
self.__precision = precision
if not hasattr(self, '_element_class') :
try :
self._element_class = type._ambient_element_class()
except NotImplementedError :
self._element_class = ModularForm_generic
single_weight_pred = lambda basis, **kwds: "grading_indices" in kwds and len(kwds["grading_indices"]) == 1
def single_weight_function(basis, **kwds) :
try :
return self.__type._weight_submodule_class()(self, basis, kwds["grading_indices"][0], **kwds)
except NotImplementedError :
return ModularFormsWeightSubmodule(self, basis, kwds["grading_indices"][0])
self._submodule_classes = [( single_weight_pred, single_weight_function ),
( lambda _, **kwds : True,
lambda basis, **kwds : self._graded_ambient_class._submodule(self, basis, **kwds) ) ]
# This couldn't be refactored completely and will most likely cause problems in the
# the concrete implementations. A complete replacement has taken place and this is
# probably no issue.
# def precision(self) :
def fourier_expansion_precision(self) :
"""
The common precision of the underlying Fourier expansions.
OUTPUT:
A filter for the Fourier expansion ambient's monoid or action.
TESTS::
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_ambient import *
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_testtype import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: ma = ModularFormsAmbient_abstract( ModularFormTestType_scalar(), NNFilter(5) )
sage: ma.fourier_expansion_precision()
Filtered NN with action up to 5
"""
return self.__precision
def type(self) :
"""
The type of modular forms this ambient contains.
OUTPUT:
An instance of :class:~`fourier_expansion_framework.modularforms.modularform_types.ModularFormType_abstract`.
TESTS::
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_ambient import *
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_testtype import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: ma = ModularFormsAmbient_abstract( ModularFormTestType_scalar(), NNFilter(5) )
sage: ma.type()
Test type of modular forms with 5 generators
"""
return self.__type
def group(self) :
"""
The modular group the modular forms in this ambient are attached to.
OUTPUT:
An arbitrary type.
TESTS::
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_ambient import *
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_testtype import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: ma = ModularFormsAmbient_abstract( ModularFormTestType_scalar(), NNFilter(5) )
sage: ma.group()
'1'
"""
return self.__type.group()
def weights(self) :
"""
The generators' weights.
OUTPUT:
A tuple of (generalized) weights.
TESTS::
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_ambient import *
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_testtype import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: ma = ModularFormsAmbient( QQ, ModularFormTestType_scalar(), NNFilter(5) )
sage: ma.weights()
(1, 2, 3, 4, 5)
"""
return self.__type.weights(self.relations().base_ring())
def graded_submodules_are_free(self) :
"""
Whether the modules of elements of fixed grading are free.
OUTPUT:
A boolean.
TESTS::
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_ambient import *
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_testtype import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: ma = ModularFormsAmbient( QQ, ModularFormTestType_scalar(), NNFilter(5) )
sage: ma.graded_submodules_are_free()
True
"""
return self.__type.graded_submodules_are_free(self.relations().base_ring())
def _submodule(self, basis, **kwds) :
"""
A submodule with given basis.
INPUT:
- ``basis`` -- A list of elements of ``self``.
- ``**kwds`` -- Will be forwarded to the submodule construction function.
OUTPUT:
A submodule of graded expansions.
TESTS::
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_ambient import *
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_testtype import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: ma = ModularFormsAmbient( QQ, ModularFormTestType_scalar(), NNFilter(5) )
sage: sm = ma._submodule([ma.0], grading_indices = [1])
"""
for pred, fcn in self._submodule_classes :
if pred(basis, **kwds) : return fcn(basis, **kwds)
raise RuntimeError, "submodule classes do not match %s, %s" % (basis, kwds)
def construction(self) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_ambient import *
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_testtype import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: ma = ModularFormsAmbient( QQ, ModularFormTestType_scalar(), NNFilter(5) )
sage: (F, A) = ma.construction()
sage: F(A) == ma
True
"""
return ModularFormsFunctor(self.__type, self.__precision), self.relations().base_ring()
def _coerce_map_from_(self, other) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_ambient import *
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_testtype import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: ma = ModularFormsAmbient( QQ, ModularFormTestType_scalar(), NNFilter(5) )
sage: ma2 = ModularFormsAmbient( ZZ, ModularFormTestType_scalar(), NNFilter(5) )
sage: ma._coerce_map_from_(ma2)
Conversion via _element_constructor_ map:
From: Graded expansion ring with generators g1, g2, g3, g4, g5
To: Graded expansion ring with generators g1, g2, g3, g4, g5
"""
from sage.structure.coerce_maps import CallableConvertMap
if isinstance(other, ModularFormsAmbient_abstract) and \
self.relations().base_ring().has_coerce_map_from(other.relations().base_ring()) and \
self.type() == other.type() :
return CallableConvertMap(other, self, self._element_constructor_)
return self._graded_ambient_class._coerce_map_from_(self, other)
def _element_constructor_(self, x) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_ambient import *
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_testtype import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: ma = ModularFormsAmbient( QQ, ModularFormTestType_scalar(), NNFilter(5) )
sage: ma2 = ModularFormsAmbient( ZZ, ModularFormTestType_scalar(), NNFilter(5) )
sage: ma(ma2.0)
Graded expansion g1
"""
if isinstance(x, (int, Integer)) and x == 0 :
return self._element_class(self, self.relations().ring().zero())
if isinstance(x, Element) :
P = x.parent()
if isinstance(P, ModularFormsAmbient_abstract) :
if P.type() == self.type() and \
self.relations().base_ring().has_coerce_map_from(P.relations().base_ring()) :
return self._element_class( self,
self.relations().ring()( x.polynomial(). \
subs(self.type()._hom_base_extension(P.relations().base_ring(), self.relations().base_ring())) )
)
return self._graded_ambient_class._element_constructor_(self, x)
def __cmp__(self, other) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_ambient import *
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_testtype import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: ma = ModularFormsAmbient( QQ, ModularFormTestType_scalar(), NNFilter(5) )
sage: ma == ModularFormsAmbient( QQ, ModularFormTestType_scalar(), NNFilter(5) )
True
sage: ma == ModularFormsAmbient( ZZ, ModularFormTestType_scalar(), NNFilter(5) )
False
sage: ma == ModularFormsAmbient( QQ, ModularFormTestType_vectorvalued(), NNFilter(5) )
False
"""
c = cmp(type(self), type(other))
if c == 0 :
c = cmp(self.type(), other.type())
if c == 0 :
c = cmp(self.relations().base_ring(), other.relations().base_ring())
return c
#===============================================================================
# ModularFormsRing_generic
#===============================================================================
class ModularFormsRing_generic ( ModularFormsAmbient_abstract, GradedExpansionRing_class ) :
def __init__(self, K, type, precision, **kwds) :
"""
INPUT:
- `K` -- A ring.
- ``type`` -- An inystance of :class:~`fourier_expansion_framework.modularforms.modularform_types.ModularFormType_abstract`.
- ``precision`` -- A precision class.
- ``**kwds`` -- Will be forwardd to :class:~`fourier_expansion_framework.gradedexpansions.gradedexpansion_ring.GradedExpansionRing_class`.
NOTE:
- The attribute ``_extended_base_ring`` must be set before calling the constructor or
will be ignored.
- The attribute ``_graded_ambient_class`` may not be set.
- The attribute ``_submodule_classes`` will be overwritten and has to be populated after calling the
constructor. See :meth:~`fourier_expansion_framework.modularforms.modularform_ambient._submodule` for its description.
- The attribute ``_element_class`` may not be set if it has to be adopted from the type.
TESTS::
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_ambient import *
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_testtype import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: ma = ModularFormsRing_generic( QQ, ModularFormTestType_scalar(), NNFilter(5) )
sage: ma.has_coerce_map_from(QQ)
True
"""
if not hasattr(self, '_extended_base_ring') :
try :
if type.is_vector_valued() :
nvv_type = type.non_vector_valued()
self._extended_base_ring = ModularFormsAmbient(K, nvv_type, precision)
except NotImplementedError :
del self._extended_base_ring
if not hasattr(self, '_graded_ambient_class') :
self._graded_ambient_class = GradedExpansionRing_class
if not 'all_relations' in kwds :
kwds['all_relations'] = True
ModularFormsAmbient_abstract.__init__(self, type, precision)
GradedExpansionRing_class.__init__(self, type.base_ring_generators(K, precision),
type.generators(K, precision), type.generator_relations(K), type.grading(K), **kwds)
#=======================================================================
# self._populate_coercion_lists_(
# coerce_list = [GradedExpansionBaseringInjection(self.base_ring(), self)],
# convert_list = [self.relations().ring()],
# convert_method_name = "_graded_expansion_submodule_to_graded_ambient_" )
#=======================================================================
def _coerce_map_from_(self, other):
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_ambient import *
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_testtype import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: ma = ModularFormsAmbient( QQ, ModularFormTestType_scalar(), NNFilter(5) )
sage: ma._coerce_map_from_(ma)
Conversion via _element_constructor_ map:
From: Graded expansion ring with generators g1, g2, g3, g4, g5
To: Graded expansion ring with generators g1, g2, g3, g4, g5
"""
from sage.structure.coerce_maps import CallableConvertMap
if isinstance(other, ModularFormsRing_generic) and \
self.base_ring().has_coerce_map_from(other.base_ring()) and \
self.type().is_vector_valued() and \
self.type().non_vector_valued() == other.type() :
return CallableConvertMap(other, self, self._element_constructor_)
return ModularFormsAmbient_abstract._coerce_map_from_(self, other)
def _element_constructor_(self, x) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_ambient import *
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_testtype import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: ma = ModularFormsAmbient( QQ, ModularFormTestType_scalar(), NNFilter(5) )
sage: ma2 = ModularFormsAmbient( ZZ, ModularFormTestType_scalar(), NNFilter(5) )
sage: ma(ma2.0)
Graded expansion g1
"""
if isinstance(x, Element) :
P = x.parent()
if isinstance(P, ModularFormsRing_generic) :
try :
if self.type().is_vector_valued() and \
self.type().non_vector_values() == P.type() and \
self.base_ring().has_coerce_map_from(P.base_ring()) :
if self.base_ring() != P.base_ring() :
from sage.categories.pushout import pushout
x = pushout(P, self.base_ring())(x)
return self._element_class( self,
self.relations().ring()( x.polynomial(). \
subs(self.type()._hom_to_vector_valued(self.base_ring())) )
)
except NotImplementedError :
pass
return ModularFormsAmbient_abstract._element_constructor_(self, x)
#===============================================================================
# ModularFormsModule_generic
#===============================================================================
class ModularFormsModule_generic ( ModularFormsAmbient_abstract, GradedExpansionModule_class ) :
def __init__(self, K, type, precision, **kwds) :
"""
INPUT:
- `K` -- A ring.
- ``type`` -- An inystance of :class:~`fourier_expansion_framework.modularforms.modularform_types.ModularFormType_abstract`.
- ``precision`` -- A precision class.
- ``**kwds`` -- Will be forwardd to :class:~`fourier_expansion_framework.gradedexpansions.gradedexpansion_ring.GradedExpansionRing_class`.
NOTE:
- The attribute ``_extended_base_ring`` must be set before calling the constructor or
will be ignored.
- The attribute ``_graded_ambient_class`` may not be set.
- The attribute ``_submodule_classes`` will be overwritten and has to be populated after calling the
constructor. See :meth:~`fourier_expansion_framework.modularforms.modularform_ambient._submodule` for its description.
- The attribute ``_element_class`` may not be set if it has to be adopted from the type.
TESTS::
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_ambient import *
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_testtype import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: ma = ModularFormsModule_generic( QQ, ModularFormTestType_vectorvalued(), NNFilter(5) )
"""
if not hasattr(self, '_extended_base_ring') :
try :
if type.is_vector_valued() :
nvv_type = type.non_vector_valued()
self._extended_base_ring = ModularFormsAmbient(K, nvv_type, precision)
except NotImplementedError :
del self._extended_base_ring
if not hasattr(self, '_graded_ambient_class') :
self._graded_ambient_class = GradedExpansionModule_class
if not 'all_relations' in kwds :
kwds['all_relations'] = True
ModularFormsAmbient_abstract.__init__(self, type, precision)
GradedExpansionModule_class.__init__(self, type.base_ring_generators(K, precision),
type.generators(K, precision), type.generator_relations(K), type.grading(K), **kwds)
#=======================================================================
# self._populate_coercion_lists_(
# convert_list = [self.relations().ring()],
# convert_method_name = "_graded_expansion_submodule_to_graded_ambient_" )
#=======================================================================
#===============================================================================
# ModularFormsRing_withheckeaction
#===============================================================================
class ModularFormsRing_withheckeaction(ModularFormsAmbientWithHeckeAction_abstract, ModularFormsRing_generic ) :
def __init__(self, K, type, precision, **kwds) :
"""
INPUT:
- `K` -- A ring.
- ``type`` -- An inystance of :class:~`fourier_expansion_framework.modularforms.modularform_types.ModularFormType_abstract`.
- ``precision`` -- A precision class.
- ``**kwds`` -- Will be forwardd to :class:~`fourier_expansion_framework.gradedexpansions.gradedexpansion_ring.GradedExpansionRing_class`.
NOTE:
- The attribute ``_extended_base_ring`` must be set before calling the constructor or
will be ignored.
- The attribute ``_graded_ambient_class`` may not be set.
- The attribute ``_submodule_classes`` will be overwritten and has to be populated after calling the
constructor. See :meth:~`fourier_expansion_framework.modularforms.modularform_ambient._submodule` for its description.
- The attribute ``_element_class`` may not be set if it has to be adopted from the type.
TESTS::
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_ambient import *
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_testtype import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: ma = ModularFormsRing_generic( QQ, ModularFormTestType_scalar(), NNFilter(5) )
"""
ModularFormsRing_generic.__init__(self, K, type, precision, **kwds)
ModularFormsAmbientWithHeckeAction_abstract.__init__(self, type)
#===============================================================================
# ModularFormsModule_withheckeaction
#===============================================================================
class ModularFormsModule_withheckeaction(ModularFormsAmbientWithHeckeAction_abstract, ModularFormsModule_generic ) :
def __init__(self, K, type, precision, **kwds) :
"""
INPUT:
- `K` -- A ring.
- ``type`` -- An inystance of :class:~`fourier_expansion_framework.modularforms.modularform_types.ModularFormType_abstract`.
- ``precision`` -- A precision class.
- ``**kwds`` -- Will be forwardd to :class:~`fourier_expansion_framework.gradedexpansions.gradedexpansion_ring.GradedExpansionRing_class`.
NOTE:
- The attribute ``_extended_base_ring`` must be set before calling the constructor or
will be ignored.
- The attribute ``_graded_ambient_class`` may not be set.
- The attribute ``_submodule_classes`` will be overwritten and has to be populated after calling the
constructor. See :meth:~`fourier_expansion_framework.modularforms.modularform_ambient._submodule` for its description.
- The attribute ``_element_class`` may not be set if it has to be adopted from the type.
TESTS::
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_ambient import *
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_testtype import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: ma = ModularFormsModule_withheckeaction( QQ, ModularFormTestType_vectorvalued(), NNFilter(5) )
"""
ModularFormsModule_generic.__init__(self, K, type, precision, **kwds)
ModularFormsAmbientWithHeckeAction_abstract.__init__(self, type)
| Python |
r"""
An abstract class for modular form types.
AUTHOR :
-- Martin Raum (2009 - 07 - 30) Initial version
"""
#===============================================================================
#
# Copyright (C) 2009 Martin Raum
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 3
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, see <http://www.gnu.org/licenses/>.
#
#===============================================================================
from sage.structure.sage_object import SageObject
#===============================================================================
# ModularFormType_abstract
#===============================================================================
class ModularFormType_abstract ( SageObject ) :
r"""
Types should be globally unique.
"""
def _ambient_construction_function(self) :
"""
Return a function that will construct the ambient ring or module
of modular forms.
OUTPUT:
A function with INPUT:
- `A` -- A ring or module; The Fourier coefficients' domain.
- ``type`` -- A type of modular forms.
- ``precision`` -- A precision class; The Fourier expansion's precision.
and OUTPUT:
A ring or module of modular forms.
TESTS::
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_types import ModularFormType_abstract
sage: ModularFormType_abstract()._ambient_construction_function()
Traceback (most recent call last):
...
NotImplementedError: Subclass has to implement this function.
"""
raise NotImplementedError( "Subclass has to implement this function." )
def _ambient_element_class(self) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_types import ModularFormType_abstract
sage: ModularFormType_abstract()._ambient_element_class()
Traceback (most recent call last):
...
NotImplementedError: Subclass has to implement this function.
"""
raise NotImplementedError( "Subclass has to implement this function." )
def _space_element_class(self) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_types import ModularFormType_abstract
sage: ModularFormType_abstract()._space_element_class()
Traceback (most recent call last):
...
NotImplementedError: Subclass has to implement this function.
"""
raise NotImplementedError( "Subclass has to implement this function." )
def _weight_submodule_class(self) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_types import ModularFormType_abstract
sage: ModularFormType_abstract()._weight_submodule_class()
Traceback (most recent call last):
...
NotImplementedError: Subclass has to implement this function.
"""
raise NotImplementedError( "Subclass has to implement this function." )
def _submodule_heckeinvariant_class(self) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_types import ModularFormType_abstract
sage: ModularFormType_abstract()._submodule_heckeinvariant_class()
Traceback (most recent call last):
...
NotImplementedError: Subclass has to implement this function.
"""
raise NotImplementedError( "Subclass has to implement this function." )
def group(self) :
"""
The modular group which ``self`` is associated with.
OUTPUT:
An arbitrary type.
NOTE:
The framwork might change later such that this function has
to return a group.
TESTS::
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_types import ModularFormType_abstract
sage: ModularFormType_abstract().group()
Traceback (most recent call last):
...
NotImplementedError: Subclass has to implement this function.
"""
raise NotImplementedError( "Subclass has to implement this function." )
def base_ring_generators(self, K, precision) :
"""
If the ring of modular forms can be interpreted as an algebra
over a ring of modular forms with much simpler Fourier coefficient
domains, it is a good idea to implement this here.
Return the Fourier expansions.
The parent of these expansions is expected to admit coercion
into the ring of the generators.
INPUT:
- `K` -- A ring.
- ``precision`` -- A precision instance.
OUTPUT:
``None`` or a sequence of equivariant monoid power series.
TESTS::
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_types import ModularFormType_abstract
sage: ModularFormType_abstract().base_ring_generators(QQ, None) is None
True
"""
return None
def generators(self, K, precision) :
"""
A list of Fourier expansions of forms that generate the ring
or module of modular forms.
INPUT:
- `K` -- A ring or module; The ring of Fourier coefficients.
- ``precision`` -- A precision class; The precision of the Fourier
expansions.
OUTPUT:
A sequence of equivariant monoid power series.
TESTS::
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_types import ModularFormType_abstract
sage: ModularFormType_abstract().generators(QQ, None)
Traceback (most recent call last):
...
NotImplementedError: Subclass has to implement this function.
"""
raise NotImplementedError( "Subclass has to implement this function." )
def grading(self, K) :
"""
A grading for the ring or module of modular forms.
INPUT:
- `K` -- A ring or module; The domain of Fourier coefficients.
OUTPUT:
A grading class.
NOTE:
This will usually coincide with the weight grading.
TESTS::
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_types import ModularFormType_abstract
sage: ModularFormType_abstract().grading(QQ)
Traceback (most recent call last):
...
NotImplementedError: Subclass has to implement this function.
"""
raise NotImplementedError( "Subclass has to implement this function." )
def _generator_names(self, K) :
"""
Names of the generators returned by :meth:~`.generators` within the
attached polynomial ring.
INPUT:
- `K` -- A ring.
OUTPUT:
A list of strings.
TESTS::
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_types import ModularFormType_abstract
sage: ModularFormType_abstract()._generator_names(QQ)
Traceback (most recent call last):
...
NotImplementedError: Subclass has to implement this function.
"""
raise NotImplementedError( "Subclass has to implement this function." )
def _generator_by_name(self, K, name) :
"""
Return the generator ``name`` as an element of the attached
polynomial ring.
INPUT:
- `K` -- A ring or module; The ring of Fourier coefficients.
- ``name`` -- A string; The generator's name.
OUTPUT:
An element of a polynomial ring.
TESTS::
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_types import ModularFormType_abstract
sage: ModularFormType_abstract()._generator_names(QQ)
Traceback (most recent call last):
...
NotImplementedError: Subclass has to implement this function.
"""
raise NotImplementedError( "Subclass has to implement this function." )
def generator_relations(self, K) :
"""
An ideal `I` in the attach polynomial ring `R`, such that the ring or module of
modular forms is a subquotient of `R / I`. This ideal must be unique for `K`.
INPUT:
- `K` -- A ring or module; The ring of Fourier coefficients.
OUTPUT:
An ideal in a polynomial ring.
TESTS::
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_types import ModularFormType_abstract
sage: ModularFormType_abstract().generator_relations(QQ)
Traceback (most recent call last):
...
NotImplementedError: Subclass has to implement this function.
"""
raise NotImplementedError( "Subclass has to implement this function." )
def reduce_before_evaluating(self, K) :
"""
Determine whether polynomials in the generators should first be
Groebner reduced, before they are evaluated.
INPUT:
- `K` -- A ring.
OUTPUT:
A boolean.
TESTS::
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_types import ModularFormType_abstract
sage: ModularFormType_abstract().reduce_before_evaluating(QQ)
True
"""
return True
def weights(self, K) :
"""
The weights of the generators returned by :meth:~`.generators`.
INPUT:
- `K` -- A ring or module; The ring of Fourier coefficients.
OUTPUT:
A list of integers.
TESTS::
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_types import ModularFormType_abstract
sage: ModularFormType_abstract().weights(QQ)
Traceback (most recent call last):
...
NotImplementedError: Subclass has to implement this function.
"""
raise NotImplementedError( "Subclass has to implement this function." )
def is_vector_valued(self) :
"""
``True`` if this is the vector valued version of a scalar valued type of modular forms.
OUTPUT:
A boolean.
TESTS::
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_types import ModularFormType_abstract
sage: ModularFormType_abstract().is_vector_valued()
False
"""
return False
def _hom_base_extension(self, K, L) :
"""
Images of generators over `K` in terms of those over `L`.
INPUT:
- `K` -- A ring.
- `L- -- A ring.
OUTPUT:
A dictionary with keys the generators over `K` and values in the set of generators
over `L`.
TESTS::
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_testtype import ModularFormTestType_scalar
sage: ModularFormTestType_scalar()._hom_base_extension(ZZ, QQ)
{g4: g4, g5: g5, g2: g2, g3: g3, g1: g1}
"""
return dict( (self._generator_by_name(K, g), self._generator_by_name(L, g))
for g in self._generator_names(K) )
def non_vector_valued(self) :
"""
Return the non vector values version of this type.
OUTPUT:
A type of modular forms.
TESTS::
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_types import ModularFormType_abstract
sage: ModularFormType_abstract().weights(QQ)
Traceback (most recent call last):
...
NotImplementedError: Subclass has to implement this function.
"""
raise NotImplementedError
def _hom_to_vector_valued(self, K) :
"""
This should be a homomorphism of the underlying polynomial rings.
INPUT:
- `K` -- A ring.
OUTPUT:
A dictionary with keys the non vector valued generators over `K` and values in the
set of generators of the vector valued type.
TESTS::
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_testtype import ModularFormTestType_scalar
sage: ModularFormTestType_scalar()._hom_to_vector_valued(QQ)
{g4: g4, g5: g5, g2: g2, g3: g3, g1: g1}
"""
if self.is_vector_valued() :
raise ValueError( "This type is already vector valued." )
nvvtype = self.non_vector_valued()
return dict( (nvvtype._generator_by_name(K, g), self._generator_by_name(K, g))
for g in self._generator_names(K) )
def graded_submodules_are_free(self, K = None) :
"""
Whether the modules of elements of fixed grading are free over
their base ring `K' or over all base rings, respectively.
INPUT:
- `K` -- A ring or module or None (default: None)
OUTPUT:
A boolean.
TESTS::
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_types import ModularFormType_abstract
sage: ModularFormType_abstract().graded_submodules_are_free()
Traceback (most recent call last):
...
NotImplementedError: Subclass has to implement this function.
"""
raise NotImplementedError( "Subclass has to implement this function." )
def has_hecke_action(self) :
"""
Whether the associated modular forms are equipped with a Hecke action.
OUTPUT:
A boolean.
TESTS::
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_types import ModularFormType_abstract
sage: ModularFormType_abstract().has_hecke_action()
False
"""
return False
def _hecke_operator_class(self) :
"""
A class that implements the Hecke operation.
OUTPUT:
An class or function that constructs an instance.
TESTS::
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_types import ModularFormType_abstract
sage: ModularFormType_abstract()._hecke_operator_class()
Traceback (most recent call last):
...
NotImplementedError
"""
raise NotImplementedError
| Python |
r"""
A functor creating rings of orthogonal modular forms.
AUTHOR :
-- Martin Raum (2009 - 07 - 30) Initial version
"""
#===============================================================================
#
# Copyright (C) 2009 Martin Raum
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 3
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, see <http://www.gnu.org/licenses/>.
#
#===============================================================================
from sage.categories.rings import Rings
from sage.categories.pushout import ConstructionFunctor
class ModularFormsFunctor ( ConstructionFunctor ) :
rank = 10
def __init__(self, type, precision) :
"""
A functor constructing a ring or module of modular forms.
INPUT:
- ``type`` -- A type of modular forms.
- ``precision`` -- A precision.
NOTE:
This does not respect keyword and has to be extended as soon as subclasses of
ModularFormsAmbient_abstract demand for it.
TESTS::
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_functor import *
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_testtype import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: F = ModularFormsFunctor( ModularFormTestType_scalar(), NNFilter(5) )
"""
self.__type = type
self.__precision = precision
ConstructionFunctor.__init__(self, Rings(), Rings())
def __call__(self, A) :
"""
INPUT:
- `A` -- A ring.
TESTS::
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_functor import *
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_testtype import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: F = ModularFormsFunctor( ModularFormTestType_scalar(), NNFilter(5) )
sage: F(QQ)
Graded expansion ring with generators g1, g2, g3, g4, g5
"""
from modularform_ambient import ModularFormsAmbient
return ModularFormsAmbient(A, self.__type, self.__precision)
def merge(self, other) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_functor import *
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_testtype import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: F = ModularFormsFunctor( ModularFormTestType_scalar(), NNFilter(5) )
sage: G = ModularFormsFunctor( ModularFormTestType_vectorvalued(), NNFilter(5) )
sage: F.merge(F) is F
True
sage: F.merge(G) is None
True
sage: G.merge(F) is G
True
"""
if type(other) != type(self) :
return None
if self.__type == other.__type and \
self.__precision == other.__precision :
return self
else :
try :
if other.__type.vector_valued() == self.__type and \
self.__precision == other.__precision :
return self
except AttributeError, NotImplementedError :
return None
return None
| Python |
r"""
Submodules of rings of orthogonal modular forms.
AUTHOR :
-- Martin Raum (2009 - 07 - 30) Initial version
"""
#===============================================================================
#
# Copyright (C) 2009 Martin Raum
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 3
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, see <http://www.gnu.org/licenses/>.
#
#===============================================================================
from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ambient import GradedExpansionAmbient_abstract
from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_submodule import GradedExpansionSubmodule_ambient_pid, \
GradedExpansionSubmodule_submodule_pid, \
GradedExpansionSubmodule_abstract, \
GradedExpansionSubmoduleVector_generic
from sage.misc.cachefunc import cached_method
from sage.structure.sequence import Sequence
import operator
#===============================================================================
# HeckeInvariantSubmodule_abstract
#===============================================================================
class HeckeInvariantSubmodule_abstract :
@cached_method
def _hecke_action(self, n) :
"""
Calculate the action of `T(n)` on the basis.
INPUT:
- `n` -- A Hecke modulus. Probably an integer.
OUTPUT:
A sequence of elements of self.
TESTS::
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_ambient import *
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_testtype import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_submodule import *
sage: ma = ModularFormsModule_withheckeaction( QQ, ModularFormTestType_vectorvalued(), NNFilter(5) )
sage: sm = ma.graded_submodule(3)
sage: sm._hecke_action(7)
[(1)]
"""
T = self.graded_ambient().type()._hecke_operator_class()(n)
return Sequence( [ self( T.eval(b.fourier_expansion(), self.graded_ambient()(b).weight()) )
for b in self.basis() ],
universe = self )
@cached_method
def hecke_homomorphism(self, n) :
"""
Calculate the matrix corresponding to the action of `T(n)` on the basis.
INPUT:
- `n` -- A Hecke modulus. Probably an integer.
OUTPUT:
A homomorphism from ``self`` to ``self``.
TESTS::
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_ambient import *
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_testtype import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_submodule import *
sage: ma = ModularFormsModule_withheckeaction( QQ, ModularFormTestType_vectorvalued(), NNFilter(5) )
sage: sm = ma.graded_submodule(3)
sage: sm.hecke_homomorphism(7)
Free module morphism defined by the matrix
[1]
Domain: Submodule of Graded expansion module with generators v1, v2, ...
Codomain: Submodule of Graded expansion module with generators v1, v2, ...
"""
return self.hom(self._hecke_action(n))
@cached_method
def hecke_eigenforms(self, n ) :
"""
Return a basis of eigenforms with respect to the Hecke operator `T(n)`.
INPUT:
- `n` -- A Hecke modulus. Probably an integer.
OUTPUT:
A list of elements in the graded ambient.
TESTS::
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_ambient import *
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_testtype import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_submodule import *
sage: ma = ModularFormsModule_withheckeaction( QQ, ModularFormTestType_vectorvalued(), NNFilter(5) )
sage: sm = ma.graded_submodule(3)
sage: sm.hecke_eigenforms(7)
[Graded expansion v1]
"""
hm = self.hecke_homomorphism(n).matrix().transpose()
hes = hm.eigenspaces_right()
efs = []
for e in hes :
ring_elements = Sequence( [sum(map(operator.mul, self._basis_in_graded_ambient(), b.list()))
for b in e[1].basis() ] )
efs += list(ring_elements)
return efs
#===============================================================================
# ModularFormsSubmoduleHeckeInvariant
#===============================================================================
def ModularFormsSubmoduleHeckeInvariant(arg1, arg2) :
"""
INPUT:
- ``arg1`` -- A graded ambient or an ambient module.
- ``arg2`` -- A list of elements in ``arg1``. The basis.
OUTPUT:
An submodule of modular forms.
TESTS::
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_ambient import *
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_testtype import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_submodule import *
sage: ma = ModularFormsModule_withheckeaction( QQ, ModularFormTestType_vectorvalued(), NNFilter(5) )
sage: sm = ma.graded_submodule(6)
sage: ssm = ModularFormsSubmoduleHeckeInvariant(sm, [sm.0])
"""
if isinstance(arg1, GradedExpansionAmbient_abstract) :
return ModularFormsSubmodule_heckeinvariant_ambient(arg1, arg2)
elif isinstance(arg1, GradedExpansionSubmodule_abstract) :
return ModularFormsSubmodule_heckeinvariant_submodule(arg1, arg2)
else :
raise ValueError( "Cannot construct subspace in %s with basis %s." % (arg1, arg2) )
return ModularFormsSubmodule_heckeinvariant_ambient
#===============================================================================
# ModularFormsSubmodule_heckeinvariant_ambient
#===============================================================================
class ModularFormsSubmodule_heckeinvariant_ambient (
GradedExpansionSubmodule_ambient_pid,
HeckeInvariantSubmodule_abstract ) :
def __init__(self, graded_ambient, basis, **kwds) :
"""
INPUT:
- ``graded_ambient`` -- A graded ambient.
- ``basis`` -- A list of elements in the graded ambient.
TESTS::
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_ambient import *
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_testtype import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_submodule import *
sage: ma = ModularFormsModule_withheckeaction( QQ, ModularFormTestType_vectorvalued(), NNFilter(5) )
sage: sm = ModularFormsSubmodule_heckeinvariant_ambient(ma, [ma.0])
"""
if not hasattr(self, '_element_class') :
try :
_element_class = graded_ambient.type()._space_element_class()
except NotImplementedError :
_element_class = GradedExpansionSubmoduleVector_generic
GradedExpansionSubmodule_ambient_pid.__init__(self, graded_ambient, basis,
**kwds)
#===============================================================================
# ModularFormsSubmodule_heckeinvariant_submodule
#===============================================================================
class ModularFormsSubmodule_heckeinvariant_submodule (
GradedExpansionSubmodule_submodule_pid,
HeckeInvariantSubmodule_abstract ) :
def __init__(self, ambient, basis, **kwds) :
"""
INPUT:
- ``ambient`` -- A submodule of modular forms.
- ``basis`` -- A list of elements in the ambient.
TESTS::
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_ambient import *
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_testtype import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_submodule import *
sage: ma = ModularFormsModule_withheckeaction( QQ, ModularFormTestType_vectorvalued(), NNFilter(5) )
sage: sm = ModularFormsSubmodule_heckeinvariant_ambient(ma, [ma.0, ma.1])
sage: ssm = ModularFormsSubmodule_heckeinvariant_submodule(sm, [sm.1])
"""
if not hasattr(self, '_element_class') :
try :
_element_class = ambient.graded_ambient().type()._space_element_class()
except NotImplementedError :
_element_class = GradedExpansionSubmoduleVector_generic
self.__integral_basis = None
GradedExpansionSubmodule_submodule_pid.__init__(self, ambient, basis,
**kwds)
def _set_integral_basis(self, basis) :
"""
An additional basis, that will not be echelonized.
INPUT:
- ``basis`` -- A list of elements of ``self``. A basis for ``self``.
OUTPUT:
``None``.
TESTS::
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_ambient import *
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_testtype import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_submodule import *
sage: ma = ModularFormsModule_withheckeaction( QQ, ModularFormTestType_vectorvalued(), NNFilter(5) )
sage: sm = ModularFormsSubmodule_heckeinvariant_ambient(ma, [ma.0, ma.1])
sage: ssm = ModularFormsSubmodule_heckeinvariant_submodule(sm, [sm.1])
sage: ssm._set_integral_basis([2 * sm.1])
sage: ssm._integral_basis()
[(0, 2)]
"""
self.__integral_basis = basis
def _integral_basis(self) :
"""
An additional basis, that will not be echelonized.
OUTPUT:
A list of elements of ``self``.
TESTS::
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_ambient import *
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_testtype import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_submodule import *
sage: ma = ModularFormsModule_withheckeaction( QQ, ModularFormTestType_vectorvalued(), NNFilter(5) )
sage: sm = ModularFormsSubmodule_heckeinvariant_ambient(ma, [ma.0, ma.1])
sage: ssm = ModularFormsSubmodule_heckeinvariant_submodule(sm, [sm.1])
sage: ssm._integral_basis()
Traceback (most recent call last):
...
RuntimeError: Integral basis is not set.
"""
if self.__integral_basis is None :
raise RuntimeError( "Integral basis is not set." )
return self.__integral_basis
#===============================================================================
# ModularFormsWeightSubmodule
#===============================================================================
def ModularFormsWeightSubmodule(graded_ambient, basis, weight) :
"""
A submodule of modular forms, that have the same weights.
INPUT:
- ``graded_ambient`` -- A graded ambient.
- ``basis`` -- A list of elements in the graded ambient.
- ``weight`` -- A grading index. The commen weight of all basis elements.
OUTPUT:
An instance of :class:~`.ModularFormsSubmodule_singleweight_ambient_pid`.
TESTS::
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_ambient import *
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_testtype import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_submodule import *
sage: ma = ModularFormsModule_withheckeaction( QQ, ModularFormTestType_vectorvalued(), NNFilter(5) )
sage: sm = ModularFormsWeightSubmodule(ma, [ma.0], 3)
"""
return ModularFormsSubmodule_singleweight_ambient_pid(graded_ambient, basis, weight)
#===============================================================================
# ModularFormSubmodule_singleweight
#===============================================================================
class ModularFormsSubmodule_singleweight_ambient_pid (
GradedExpansionSubmodule_ambient_pid,
HeckeInvariantSubmodule_abstract ) :
def __init__(self, graded_ambient, basis, weight, **kwds) :
"""
INPUT:
- ``graded_ambient`` -- A graded ambient.
- ``basis`` -- A list of elements in the graded ambient.
- ``weight`` -- A grading index. The commen weight of all basis elements.
- ``kwds`` -- Will be forwarded to :class:~`fourier_expansion_framework.gradedexpansions.gradedexpansion_submodule.GradedExpansionSubmodule_ambient_pid`.
TESTS::
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_ambient import *
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_testtype import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_submodule import *
sage: ma = ModularFormsModule_withheckeaction( QQ, ModularFormTestType_vectorvalued(), NNFilter(5) )
sage: sm = ModularFormsSubmodule_singleweight_ambient_pid(ma, [ma.0], 3)
"""
self.__weight = weight
if not hasattr(self, '_element_class') :
try :
_element_class = graded_ambient.type()._space_element_class()
except NotImplementedError :
_element_class = GradedExpansionSubmoduleVector_generic
GradedExpansionSubmodule_ambient_pid.__init__(self, graded_ambient, basis,
**kwds)
def weight(self) :
return self.__weight
## TODO: Provide standard implementation of is_cusp_form for vectors
## TODO: Provide implementation of homogeneous weight vectors and
## make Hecke operators work for this
| Python |
from modularform_ambient import ModularFormsAmbient | Python |
from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ambient import GradedExpansionAmbient_abstract
r"""
A orthogonal modular form, namely a graded expansion providing additional features.
AUTHOR :
-- Martin Raum (2009 - 07 - 30) Initial version
"""
#===============================================================================
#
# Copyright (C) 2009 Martin Raum
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 3
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, see <http://www.gnu.org/licenses/>.
#
#===============================================================================
from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_element import GradedExpansion_class, \
GradedExpansionVector_class, GradedExpansion_abstract
class ModularForm_abstract (object) :
"""
NOTE:
We assume that the deriving classes also derive (indirectly)
from GradedExpansion_abstract.
"""
def is_cusp_form(self) :
"""
Whether ``self`` is a cusp form or not.
OUTPUT:
A boolean.
TESTS::
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_ambient import *
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_testtype import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: ma = ModularFormsAmbient( QQ, ModularFormTestType_scalar(), NNFilter(5) )
sage: ma.0.is_cusp_form()
Traceback (most recent call last):
...
NotImplementedError
"""
raise NotImplementedError
def is_eisenstein_series(self) :
"""
Whether ``self`` is an Eisenstein series or not.
OUTPUT:
A boolean.
TESTS::
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_ambient import *
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_testtype import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: ma = ModularFormsAmbient( QQ, ModularFormTestType_scalar(), NNFilter(5) )
sage: ma.0.is_eisenstein_series()
Traceback (most recent call last):
...
NotImplementedError
"""
raise NotImplementedError
def _lmul_(self, c) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_ambient import *
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_testtype import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: ma = ModularFormsAmbient( QQ, ModularFormTestType_scalar(), NNFilter(5) )
sage: mavv = ModularFormsAmbient( QQ, ModularFormTestType_vectorvalued(), NNFilter(5) )
sage: (mavv.0 * ma.0).polynomial()
g1*v1
sage: (ma.0 * 5).polynomial()
5*g1
"""
## For vector valued forms we use an extended base ring, which
## needs conversion before we can multiply
if self.parent().type().is_vector_valued() :
return self.parent()._element_class( self.parent(),
c.polynomial().subs(c.parent().type()._hom_to_vector_valued(self.parent().relations().base_ring())) \
* self.polynomial() )
else :
return super(ModularForm_abstract, self)._lmul_(c)
def _rmul_(self, c) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_ambient import *
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_testtype import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: ma = ModularFormsAmbient( QQ, ModularFormTestType_scalar(), NNFilter(5) )
sage: mavv = ModularFormsAmbient( QQ, ModularFormTestType_vectorvalued(), NNFilter(5) )
sage: (ma.0 * mavv.0).polynomial()
g1*v1
sage: (5 * ma.0).polynomial()
5*g1
"""
## For vector valued forms we use an extended base ring, which
## needs conversion before we can multiply
if self.parent().type().is_vector_valued() :
return self.parent()._element_class( self.parent(),
c.polynomial().subs(c.parent().type()._hom_to_vector_valued(self.parent().relations().base_ring())) \
* self.polynomial() )
else :
return super(ModularForm_abstract, self)._rmul_(c)
class ModularForm_generic ( ModularForm_abstract, GradedExpansion_class ) :
weight = GradedExpansion_class.grading_index
class ModularFormVector_generic ( ModularForm_abstract, GradedExpansionVector_class ) :
weight = GradedExpansionVector_class.grading_index
| Python |
"""
Interfaces for modular forms which admit Hecke actions or ring which have
Maass lifts.
AUTHOR :
-- Martin Raum (2009 - 07 - 30) Initial version
"""
#===============================================================================
#
# Copyright (C) 2009 Martin Raum
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 3
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, see <http://www.gnu.org/licenses/>.
#
#===============================================================================
from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_element import GradedExpansion_abstract
from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import MonoidPowerSeries_abstract, \
EquivariantMonoidPowerSeries_abstract
from psage.modform.fourier_expansion_framework.modularforms.modularform_submodule import ModularFormsSubmoduleHeckeInvariant
from psage.modform.fourier_expansion_framework.gradedexpansions.fourierexpansionwrapper import FourierExpansionWrapper
#===============================================================================
# ModularFormsAmbientWithHeckeAction_abstract
#===============================================================================
class ModularFormsAmbientWithHeckeAction_abstract :
"""
The standard implementation assumes that the action only depends on the
modulus and the weight.
The deriving class must override self._hecke_operator_class or it will
be derived from the type.
"""
def __init__(self, type) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_ambient import *
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_testtype import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: ma = ModularFormsModule_withheckeaction( QQ, ModularFormTestType_vectorvalued(), NNFilter(5) )
sage: sm = ma.graded_submodule(3)
sage: sm._hecke_action(7)
[(1)]
sage: ma = ModularFormsRing_withheckeaction( QQ, ModularFormTestType_scalar(), NNFilter(5) )
Traceback (most recent call last):
...
ValueError: Type for modular forms ambients with Hecke action must support Hecke operators.
"""
if not hasattr(self, '_hecke_operator_class') :
if not type.has_hecke_action() :
raise ValueError( "Type for modular forms ambients with Hecke action must support Hecke operators." )
self._hecke_operator_class = type._hecke_operator_class()
hecke_invariant_pred = lambda basis, **kwds : "is_hecke_invariant" in kwds and kwds["is_hecke_invariant"]
def hecke_invariant_fcn(basis, **kwds) :
try :
return self.type()._submodule_heckeinvariant_class(self, basis, **kwds)
except NotImplementedError :
return ModularFormsSubmoduleHeckeInvariant(self, basis, **kwds)
self._submodule_classes.insert(-2, (hecke_invariant_pred, hecke_invariant_fcn))
def _hecke_action(self, n, form) :
"""
The image of ``form`` under the `n`-th Hecke operator.
INPUT:
- `n` -- A Hecke modulus. Probably an integer.
- ``form`` -- An element whose parent supports conversion from
Fourier expansions.
OUTPUT:
An element in the parent of ``form``.
TESTS::
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_ambient import *
sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_testtype import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: ma = ModularFormsModule_withheckeaction( QQ, ModularFormTestType_vectorvalued(), NNFilter(5) )
sage: sm = ma.graded_submodule(3)
sage: ma._hecke_action(2, sm.0)
Equivariant monoid power series in Module of equivariant monoid power series over NN
sage: ma._hecke_action(7, sm.0)
(1)
sage: ma._hecke_action(2, 2)
Traceback (most recent call last):
...
TypeError: Form must be a Fourier expansion or wrap one.
"""
T = self._hecke_operator_class(n)
if isinstance(form, FourierExpansionWrapper) :
expansion = form.fourier_expansion()
try :
weight = form.weight()
except AttributeError :
weight = None
elif isinstance(form, (MonoidPowerSeries_abstract, EquivariantMonoidPowerSeries_abstract)) :
expansion = form
weight = None
else :
raise TypeError( "Form must be a Fourier expansion or wrap one." )
hecke_expansion = T.eval(expansion, weight)
if isinstance(form, FourierExpansionWrapper) :
try :
return form.parent()(hecke_expansion)
except (ValueError, ArithmeticError) :
pass
return hecke_expansion
| Python |
"""
Rings of monoid power series and rings of equivariant monoid power series.
AUTHOR :
-- Martin Raum (2009 - 07 - 25) Initial version
"""
#===============================================================================
#
# Copyright (C) 2009 Martin Raum
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 3
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, see <http://www.gnu.org/licenses/>.
#
#===============================================================================
from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ambient import MonoidPowerSeriesAmbient_abstract, \
EquivariantMonoidPowerSeriesAmbient_abstract
from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_functor import MonoidPowerSeriesBaseRingInjection,\
EquivariantMonoidPowerSeriesFunctor, MonoidPowerSeriesFunctor
from sage.algebras.algebra import Algebra
from sage.rings.all import Integer
from sage.structure.element import Element
from sage.structure.parent import Parent
#===============================================================================
# MonoidPowerSeriesRing
#===============================================================================
_monoidpowerseries_ring_cache = dict()
def MonoidPowerSeriesRing(A, S) :
"""
Return the globally unique monoid power series ring with indices
over the filtered monoid `S` and coefficients in `A`.
INPUT:
- `A` -- A ring.
- `S` -- A monoid as implemented in :class:~`fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids.NNMonoid`.
OUTPUT:
An instance of :class:~`.MonoidPowerSeriesRing_generic`.
EXAMPLES::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import MonoidPowerSeriesRing
sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
sage: mps is MonoidPowerSeriesRing(QQ, NNMonoid(False))
True
"""
global _monoidpowerseries_ring_cache
key = (A, S)
try :
return _monoidpowerseries_ring_cache[key]
except KeyError :
P = MonoidPowerSeriesRing_generic(A, S)
_monoidpowerseries_ring_cache[key] = P
return P
#===============================================================================
# MonoidPowerSeriesRing_generic
#===============================================================================
class MonoidPowerSeriesRing_generic ( MonoidPowerSeriesAmbient_abstract, Algebra ) :
"""
Given some `K` algebra `A` and a monoid `S` filtered over
a net `\Lambda` construct a ring of monoid power series.
Set `R = B[S]`. Then the projective limit of `R / R_\lambda` for
`\lambda \in \Lambda \rightarrow \infty` considered as a
`K` algebra is implemented by this class.
"""
def __init__(self, A, S) :
"""
INPUT:
- `A` -- A ring.
- `S` -- A monoid as implemented in :class:~`fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids.NNMonoid`.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import MonoidPowerSeriesRing_generic
sage: mps = MonoidPowerSeriesRing_generic(QQ, NNMonoid(False))
"""
Algebra.__init__(self, A)
MonoidPowerSeriesAmbient_abstract.__init__(self, A, S)
self.__monoid_gens = \
[ self._element_class(self, dict([(s, A.one_element())]),
self.monoid().filter_all() )
for s in S.gens() ]
self._populate_coercion_lists_(
coerce_list = [MonoidPowerSeriesBaseRingInjection(self.base_ring(), self)] + \
([S] if isinstance(S, Parent) else []) )
def ngens(self) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import MonoidPowerSeriesRing_generic
sage: mps = MonoidPowerSeriesRing_generic(QQ, NNMonoid(False))
sage: mps.ngens()
1
"""
return len(self.__monoid_gens)
def gen(self, i = 0) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import MonoidPowerSeriesRing_generic
sage: mps = MonoidPowerSeriesRing_generic(QQ, NNMonoid(False))
sage: mps.gen().coefficients()
{1: 1}
"""
return self.gens()[i]
def gens(self) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import MonoidPowerSeriesRing_generic
sage: mps = MonoidPowerSeriesRing_generic(QQ, NNMonoid(False))
sage: mps.gens()
[Monoid power series in Ring of monoid power series over NN]
"""
return self.__monoid_gens
def construction(self) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import MonoidPowerSeriesRing_generic
sage: mps = MonoidPowerSeriesRing_generic(QQ, NNMonoid(False))
sage: (f, a) = mps.construction()
sage: (f, a)
(MonoidPowerSeriesFunctor, Rational Field)
sage: f(a) == mps
True
"""
return MonoidPowerSeriesFunctor(self.monoid()), self.coefficient_domain()
def _element_constructor_(self, x) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import MonoidPowerSeriesRing_generic
sage: mps = MonoidPowerSeriesRing_generic(QQ, NNMonoid(False))
sage: h = mps(1) # indirect doctest
sage: h = mps(mps.monoid().zero_element())
sage: h = mps.zero_element()
sage: K.<rho> = CyclotomicField(6)
sage: mps = MonoidPowerSeriesRing_generic(K, NNMonoid(False))
sage: h = mps(rho)
sage: h = mps(1)
"""
if isinstance(x, int) :
x = Integer(x)
if isinstance(x, Element) :
P = x.parent()
if P is self.coefficient_domain() :
return self._element_class( self, {self.monoid().zero_element(): x},
self.monoid().filter_all() )
elif self.coefficient_domain().has_coerce_map_from(P) :
return self._element_class( self, {self.monoid().zero_element(): self.coefficient_domain()(x)},
self.monoid().filter_all() )
elif P is self.monoid() :
return self._element_class( self, {x: self.base_ring().one_element},
self.monoid().filter_all() )
return MonoidPowerSeriesAmbient_abstract._element_constructor_(self, x)
def _repr_(self) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import MonoidPowerSeriesRing_generic
sage: MonoidPowerSeriesRing_generic(QQ, NNMonoid(False))
Ring of monoid power series over NN
"""
return "Ring of monoid power series over " + self.monoid()._repr_()
def _latex_(self) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import MonoidPowerSeriesRing_generic
sage: latex(MonoidPowerSeriesRing_generic(QQ, NNMonoid(False)))
Ring of monoid power series over $\NN$
"""
return "Ring of monoid power series over " + self.monoid()._latex_()
###############################################################################
###############################################################################
###############################################################################
#===============================================================================
# EquivariantMonoidPowerSeriesRing
#===============================================================================
_equivariantmonoidpowerseries_ring_cache = dict()
def EquivariantMonoidPowerSeriesRing(O, C, R) :
"""
Return the globally unique ring of equivariant monoid power
over the monoid with action `O` with coefficients in the codomain `R`
with a representation and a set of virtual characters `C`.
INPUT:
- `O` -- A monoid with an action of a group; As implemented in
:class:~`fourier_expansion_framework.monoidpowerseries.NNMonoid`.
- `C` -- A monoid of characters; As implemented in ::class:~`fourier_expansion_framework.monoidpowerseries.CharacterMonoid_class`.
- `R` -- A representation on an algebra; As implemented
in :class:~`fourier_expansion_framework.monoidpowerseries.TrivialRepresentation`.
EXAMPLES::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import EquivariantMonoidPowerSeriesRing
sage: emps = EquivariantMonoidPowerSeriesRing(NNMonoid(True), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", QQ))
sage: emps is EquivariantMonoidPowerSeriesRing(NNMonoid(True), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", QQ))
True
"""
## TODO: Implement optional checking of the relations of the characters
if O.group() != C.group() :
raise ValueError, "The action on S and the characters must have the same group"
if R.base_ring() != C.codomain() :
if C.codomain().has_coerce_map_from(R.base_ring()) :
K = C.codomain()
R = R.base_extend(K)
elif R.base_ring().has_coerce_map_from(C.codomain()) :
K = R.base_ring()
else :
from sage.categories.pushout import pushout
try :
K = pushout(C.codomain(), R.base_ring())
R = R.base_extend(K)
except :
raise ValueError, "character codomain and representation base ring have no common extension"
global _equivariantmonoidpowerseries_ring_cache
key = (O, C, R)
try :
return _equivariantmonoidpowerseries_ring_cache[key]
except KeyError :
P = EquivariantMonoidPowerSeriesRing_generic(O, C, R)
_equivariantmonoidpowerseries_ring_cache[key] = P
return P
#===============================================================================
# EquivariantMonoidPowerSeriesRing_generic
#===============================================================================
class EquivariantMonoidPowerSeriesRing_generic ( EquivariantMonoidPowerSeriesAmbient_abstract, Algebra ) :
"""
Given some ring `A`, a monoid `S` filtered over some originated
net `\Lambda` such that all induced submonoids are finite, a group `G`, a
semigroup `C` with a map `c \rightarrow \mathrm{Hom}(G, Aut_K(A))`, a
homomorphism `\phi : G -> Aut(S)` and a homomorphism `\eta : G -> C`, where
`K` is the base ring of `A`.
Suppose for every `c, c'` in `C`, and `g` in `G`, and `a, a'` in `A` we have
`(c c') (g) (a a') = c(g)(a) c'(g)(a')`.
Set `R = B[C][S]`. Then the projective limit of
`R / R_\lambda` for `\lambda \in \Lambda \rightarrow \infinity` is a
`K`-algebra.
The set of generators is the set of generators of the underlying
monoidal power series ring and does not take into account the
group action
"""
def __init__(self, O, C, R) :
"""
INPUT:
- `O` -- A monoid with an action of a group; As implemented in
:class:~`fourier_expansion_framework.monoidpowerseries.NNMonoid`.
- `C` -- A monoid of characters; As implemented in ::class:~`fourier_expansion_framework.monoidpowerseries.CharacterMonoid_class`.
- `R` -- A representation on an algebra; As implemented
in :class:~`fourier_expansion_framework.monoidpowerseries.TrivialRepresentation`.
EXAMPLES::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import EquivariantMonoidPowerSeriesRing_generic
sage: emps = EquivariantMonoidPowerSeriesRing_generic(NNMonoid(True), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", QQ)) # indirect doctest
"""
Algebra.__init__(self, R.base_ring())
EquivariantMonoidPowerSeriesAmbient_abstract.__init__(self, O, C, R)
self.__monoid_gens = \
[self._element_class(self,
dict([( C.one_element(), dict([(s, self.coefficient_domain().one_element())]) )]),
self.monoid().filter_all() )
for s in self.action().gens()]
self.__character_gens = \
[self._element_class(self,
dict([( c, dict([(self.monoid().zero_element(), self.coefficient_domain().one_element())]) )]),
self.monoid().filter_all() )
for c in C.gens()]
self.__coefficient_gens = \
[self._element_class(self,
dict([( C.one_element(), dict([(self.monoid().zero_element(), g)]))]),
self.monoid().filter_all() )
for g in self.coefficient_domain().gens()]
self._populate_coercion_lists_(
coerce_list = [MonoidPowerSeriesBaseRingInjection(R.codomain(), self)] ,
convert_list = ([O.monoid()] if isinstance(O.monoid(), Parent) else []) )
def ngens(self) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import EquivariantMonoidPowerSeriesRing_generic
sage: emps = EquivariantMonoidPowerSeriesRing_generic(NNMonoid(True), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", QQ))
sage: emps.ngens()
3
"""
return len(self.__monoid_gens) + len(self.__character_gens) + len(self.__coefficient_gens)
def gen(self, i = 0) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import EquivariantMonoidPowerSeriesRing_generic
sage: emps = EquivariantMonoidPowerSeriesRing_generic(NNMonoid(True), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", QQ))
sage: emps.gen()
Equivariant monoid power series in Ring of equivariant monoid power series over NN
"""
return self.gens()[i]
def gens(self) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import EquivariantMonoidPowerSeriesRing_generic
sage: emps = EquivariantMonoidPowerSeriesRing_generic(NNMonoid(True), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", QQ))
sage: emps.gens()
[Equivariant monoid power series in Ring of equivariant monoid power series over NN, Equivariant monoid power series in Ring of equivariant monoid power series over NN, Equivariant monoid power series in Ring of equivariant monoid power series over NN]
"""
return self.__monoid_gens + self.__character_gens + self.__coefficient_gens
def construction(self) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import EquivariantMonoidPowerSeriesRing_generic
sage: emps = EquivariantMonoidPowerSeriesRing_generic(NNMonoid(True), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", QQ))
sage: (f, a) = emps.construction()
sage: (f, a)
(EquivariantMonoidPowerSeriesFunctor, Rational Field)
sage: f(a) == emps
True
"""
return EquivariantMonoidPowerSeriesFunctor(self.action(), self.characters(), self.representation()), \
self.coefficient_domain()
def _element_constructor_(self, x) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import EquivariantMonoidPowerSeriesRing_generic
sage: emps = EquivariantMonoidPowerSeriesRing_generic(NNMonoid(True), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", QQ))
sage: h = emps(1)
sage: h = emps(emps.monoid().zero_element())
sage: h = emps.zero_element()
sage: K.<rho> = CyclotomicField(6)
sage: emps = EquivariantMonoidPowerSeriesRing_generic(NNMonoid(True), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", K))
sage: h = emps(rho)
sage: h = emps(1)
"""
if isinstance(x, int) :
x = Integer(x)
if isinstance(x, Element) :
P = x.parent()
if P is self.coefficient_domain() :
return self._element_class( self,
{self.characters().one_element():
{self.monoid().zero_element(): x}},
self.action().filter_all() )
elif self.coefficient_domain().has_coerce_map_from(P) :
return self._element_class( self,
{self.characters().one_element():
{self.monoid().zero_element(): self.coefficient_domain()(x)}},
self.action().filter_all() )
elif P is self.monoid() :
return self._element_class( self,
{self.characters().one_element():
{x: self.base_ring().one_element()}},
self.action().filter_all(),
symmetrise = True )
return EquivariantMonoidPowerSeriesAmbient_abstract._element_constructor_(self, x)
def _cmp_(self, other) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import MonoidPowerSeriesRing
sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
sage: mps2 = MonoidPowerSeriesRing(ZZ, NNMonoid(False))
sage: mps == MonoidPowerSeriesRing(QQ, NNMonoid(False))
True
sage: mps == mps2
False
"""
c = cmp(type(self), type(other))
if c == 0 :
c = cmp(self.base_ring(), other.base_ring())
if c == 0 :
c = cmp(self.monoid(), other.monoid())
return c
def _repr_(self) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import EquivariantMonoidPowerSeriesRing_generic
sage: EquivariantMonoidPowerSeriesRing_generic(NNMonoid(True), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", QQ))
Ring of equivariant monoid power series over NN
"""
return "Ring of equivariant monoid power series over " + self.monoid()._repr_()
def _latex_(self) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import EquivariantMonoidPowerSeriesRing_generic
sage: latex(EquivariantMonoidPowerSeriesRing_generic(NNMonoid(True), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", QQ)))
Ring of equivariant monoid power series over $\NN$
"""
return "Ring of equivariant monoid power series over " + self.monoid()._latex_()
| Python |
"""
Functor creating rings or modules of (equivariant) monoid power series.
AUTHOR :
-- Martin Raum (2009 - 07 - 25) Initial version
"""
#===============================================================================
#
# Copyright (C) 2009 Martin Raum
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 3
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, see <http://www.gnu.org/licenses/>.
#
#===============================================================================
from sage.categories.rings import Rings
from sage.categories.morphism import Morphism
from sage.categories.pushout import ConstructionFunctor
from sage.rings.ring import Ring
#===============================================================================
# MonoidPowerSeriesFunctor
#===============================================================================
class MonoidPowerSeriesFunctor ( ConstructionFunctor ) :
"""
Functor mapping a coefficient ring to a monoid power series ring
over a given monoid.
"""
rank = 9
def __init__(self, S) :
"""
INPUT:
- `S` -- A monoid as in :class:`~from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids.NNMonoid`
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_functor import MonoidPowerSeriesFunctor
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import NNMonoid
sage: F = MonoidPowerSeriesFunctor(NNMonoid(False))
"""
self.__S = S
ConstructionFunctor.__init__(self, Rings(), Rings())
def monoid(self) :
"""
Return the monoid associated to this functor.
OUTPUT:
A monoid as in :class:`~from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids.NNMonoid`.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_functor import MonoidPowerSeriesFunctor
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import NNMonoid
sage: F = MonoidPowerSeriesFunctor(NNMonoid(False))
sage: F.monoid()
NN
"""
return self.__S
def __call__(self, A) :
"""
Apply a ``self`` to a coefficient domain `A`.
INPUT:
- `A` -- A ring or module. The domain of coefficients for
a ring or module of monoid power series.
OUTPUT:
An instance of :class:`~from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ambient.MonoidPowerSeriesAmbient_abstract`.
A ring if `A` is a ring, a module if `A` is a module.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_functor import MonoidPowerSeriesFunctor
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import NNMonoid
sage: F = MonoidPowerSeriesFunctor(NNMonoid(False))
sage: mps = F(ZZ)
sage: mps.monoid() == NNMonoid(False)
True
sage: mps.coefficient_domain()
Integer Ring
sage: F(FreeModule(QQ, 3)).coefficient_domain()
Vector space of dimension 3 over Rational Field
"""
if isinstance(A, Ring) :
from monoidpowerseries_ring import MonoidPowerSeriesRing
return MonoidPowerSeriesRing(A, self.__S)
else :
from monoidpowerseries_module import MonoidPowerSeriesModule
return MonoidPowerSeriesModule(A, self.__S)
def __cmp__(self, other) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_functor import MonoidPowerSeriesFunctor
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import NNMonoid
sage: F = MonoidPowerSeriesFunctor(NNMonoid(False))
sage: F == MonoidPowerSeriesFunctor(NNMonoid(False))
True
"""
c = cmp(type(self), type(other))
if c == 0 :
c = cmp(self.__S, other.__S)
return c
#===============================================================================
# EquivariantMonoidPowerSeriesFunctor
#===============================================================================
class EquivariantMonoidPowerSeriesFunctor ( ConstructionFunctor ) :
"""
Functor mapping a coefficient domain to a equivariant monoid power series
ring or module over a given monoid action with character and representation.
The representation will be extended by scalars if the coefficient domain's
base ring is to big.
"""
rank = 9
def __init__(self, O, C, R) :
"""
INPUT:
- `O` -- An action of a group `G` on a monoid as implemented in :class:`~fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basismonoids.NNMonoid`.
- `C` -- A monoid of charcters `G -> K` for a ring `K`. As implemented in :class:`~fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basismonoids.CharacterMonoid_class`.
- `R` -- A representation of `G` on some `K`-algebra or module `A`.
As implemented in :class:`~fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basismonoids.TrivialRepresentation`.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_functor import EquivariantMonoidPowerSeriesFunctor
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import NNMonoid, TrivialRepresentation, TrivialCharacterMonoid
sage: F = EquivariantMonoidPowerSeriesFunctor(NNMonoid(), TrivialCharacterMonoid("1", ZZ), TrivialRepresentation("1", ZZ))
"""
if O.group() != C.group() :
raise ValueError( "The action on S and the characters must have the same group" )
if R.base_ring() != C.codomain() :
if C.codomain().has_coerce_map_from(R.base_ring()) :
pass
elif R.base_ring().has_coerce_map_from(C.codomain()) :
pass
else :
raise ValueError( "character codomain and representation base ring must be coercible" )
self.__O = O
self.__C = C
self.__R = R
## TODO: replace Rings by an suitable category
ConstructionFunctor.__init__(self, Rings(), Rings())
def __call__(self, K) :
"""
Apply a ``self`` to a coefficient domain `A`.
INPUT:
- `A` -- A ring or module. The domain of coefficients for
a ring or module of equivariant monoid power series.
OUTPUT:
An instance of :class:`~from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ambient.EquivariantMonoidPowerSeriesAmbient_abstract`.
A ring if the representation's extension by `A` is a ring, a module if this extension is a module.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_functor import EquivariantMonoidPowerSeriesFunctor
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import NNMonoid, TrivialRepresentation, TrivialCharacterMonoid
sage: F = EquivariantMonoidPowerSeriesFunctor(NNMonoid(), TrivialCharacterMonoid("1", ZZ), TrivialRepresentation("1", ZZ))
sage: emps = F(QQ)
sage: emps.action() == NNMonoid()
True
sage: emps.characters()
Character monoid over Trivial monoid
sage: F = EquivariantMonoidPowerSeriesFunctor(NNMonoid(), TrivialCharacterMonoid("1", ZZ), TrivialRepresentation("1", FreeModule(ZZ, 3)))
sage: emps = F(QQ)
sage: emps.coefficient_domain()
Vector space of dimension 3 over Rational Field
"""
R = self.__R.base_extend(K)
if self.__O.is_monoid_action() and isinstance(R.codomain(), Ring) :
from monoidpowerseries_ring import EquivariantMonoidPowerSeriesRing
return EquivariantMonoidPowerSeriesRing( self.__O, self.__C, R )
else :
from monoidpowerseries_module import EquivariantMonoidPowerSeriesModule
return EquivariantMonoidPowerSeriesModule( self.__O, self.__C, R )
def __cmp__(self, other) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_functor import EquivariantMonoidPowerSeriesFunctor
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import NNMonoid, TrivialRepresentation, TrivialCharacterMonoid
sage: F = EquivariantMonoidPowerSeriesFunctor(NNMonoid(), TrivialCharacterMonoid("1", ZZ), TrivialRepresentation("1", ZZ))
sage: F == EquivariantMonoidPowerSeriesFunctor(NNMonoid(), TrivialCharacterMonoid("1", ZZ), TrivialRepresentation("1", ZZ))
True
sage: F == EquivariantMonoidPowerSeriesFunctor(NNMonoid(), TrivialCharacterMonoid("1", ZZ), TrivialRepresentation("1", FreeModule(QQ, 3)))
False
"""
c = cmp(type(self), type(other))
if c == 0 :
c = cmp(self.__R, other.__R)
if c == 0 :
c = cmp(self.__O, other.__O)
if c == 0 :
c = cmp(self.__C, other.__C)
return c
def expand(self) :
"""
An equivariant monoid power series can be constructed by first
constructing a monoid power series and then symmetrising it with
respect to the group action.
OUTPUT:
A list of functors.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_functor import EquivariantMonoidPowerSeriesFunctor
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import NNMonoid, TrivialRepresentation, TrivialCharacterMonoid
sage: F = EquivariantMonoidPowerSeriesFunctor(NNMonoid(), TrivialCharacterMonoid("1", ZZ), TrivialRepresentation("1", ZZ))
sage: F.expand()
[MonoidPowerSeriesSymmetrisationFunctor, MonoidPowerSeriesFunctor]
"""
return [ MonoidPowerSeriesSymmetrisationFunctor(self.__O, self.__C, self.__R),
MonoidPowerSeriesFunctor(self.__O.monoid()) ]
def merge(self, other) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_functor import EquivariantMonoidPowerSeriesFunctor
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import NNMonoid, TrivialRepresentation, TrivialCharacterMonoid
sage: F = EquivariantMonoidPowerSeriesFunctor(NNMonoid(), TrivialCharacterMonoid("1", ZZ), TrivialRepresentation("1", ZZ))
sage: G = EquivariantMonoidPowerSeriesFunctor(NNMonoid(), TrivialCharacterMonoid("1", ZZ), TrivialRepresentation("1", QQ))
sage: F.merge(G) == G
True
sage: G = EquivariantMonoidPowerSeriesFunctor(NNMonoid(), TrivialCharacterMonoid("1", ZZ), TrivialRepresentation("1", FreeModule(ZZ, 3)))
sage: F.merge(G) is None
True
"""
if self == other :
return self
elif type(self) == type(other) and \
self.__O == self.__O and \
self.__C == self.__C :
try :
if self.__R.extends(other.__R) :
return self
elif other.__R.extends(self.__R) :
return other
except AttributeError :
return None
return None
#===============================================================================
# MonoidPowerSeriesSymmetrisationFunctor
#===============================================================================
class MonoidPowerSeriesSymmetrisationFunctor ( ConstructionFunctor) :
"""
A functor mapping rings or modules of monoid power series
to a the an equivariant power series via symmetrisation.
"""
rank = 9
def __init__(self, O, C, R) :
"""
INPUT:
- `O` -- An action of a group `G` on a monoid as implemented in :class:`~fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basismonoids.NNMonoid`.
- `C` -- A monoid of charcters `G -> K` for a ring `K`. As implemented in :class:`~fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basismonoids.CharacterMonoid_class`.
- `R` -- A representation of `G` on some `K`-algebra or module `A`.
As implemented in :class:`~fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basismonoids.TrivialRepresentation`.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_functor import MonoidPowerSeriesSymmetrisationFunctor
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import NNMonoid, TrivialRepresentation, TrivialCharacterMonoid
sage: F = MonoidPowerSeriesSymmetrisationFunctor(NNMonoid(), TrivialCharacterMonoid("1", ZZ), TrivialRepresentation("1", ZZ))
"""
if O.group() != C.group() :
raise ValueError, "The action on S and the characters must have the same group"
if R.base_ring() != C.codomain() :
if C.codomain().has_coerce_map_from(R.base_ring()) :
pass
elif R.base_ring().has_coerce_map_from(C.codomain()) :
pass
else :
raise ValueError, "character codomain and representation base ring must be coercible"
self.__O = O
self.__C = C
self.__R = R
## TODO: replace Rings by an suitable category
ConstructionFunctor.__init__(self, Rings(), Rings())
def __call__(self, P) :
"""
Map a monoid power series to a symmetrisation extending the associated representation.
INPUT:
- `P` -- An instance of :class:`~from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ambient.MonoidPowerSeriesAmbient_abstract`.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_functor import MonoidPowerSeriesSymmetrisationFunctor, MonoidPowerSeriesFunctor
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import NNMonoid, TrivialRepresentation, TrivialCharacterMonoid
sage: mps = MonoidPowerSeriesFunctor(NNMonoid(False))(QQ)
sage: F = MonoidPowerSeriesSymmetrisationFunctor(NNMonoid(), TrivialCharacterMonoid("1", ZZ), TrivialRepresentation("1", ZZ))
sage: emps = F(mps)
sage: emps.representation() == TrivialRepresentation("1", QQ)
True
sage: mps = MonoidPowerSeriesFunctor(NNMonoid(False))(ZZ)
sage: F = MonoidPowerSeriesSymmetrisationFunctor(NNMonoid(), TrivialCharacterMonoid("1", ZZ), TrivialRepresentation("1", QQ))
sage: emps = F(mps)
sage: emps.representation() == TrivialRepresentation("1", QQ)
True
sage: mps = MonoidPowerSeriesFunctor(NNMonoid(False))(FreeModule(ZZ, 3))
sage: F(mps)
Traceback (most recent call last):
...
TypeError: no base extension defined
"""
if self.__O.monoid() != P.monoid() :
raise ValueError( "Action has to be defined on the monoid associated to P." )
if not self.__R.base_ring().has_coerce_map_from(P.base_ring()) :
R = self.__R.base_extend(P.base_ring())
else :
R = self.__R
if self.__O.is_monoid_action() and isinstance(R.codomain(), Ring) :
from monoidpowerseries_ring import EquivariantMonoidPowerSeriesRing
return EquivariantMonoidPowerSeriesRing( self.__O, self.__C, R )
else :
from monoidpowerseries_module import EquivariantMonoidPowerSeriesModule
return EquivariantMonoidPowerSeriesModule( self.__O, self.__C, R )
def __cmp__(self, other) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_functor import MonoidPowerSeriesSymmetrisationFunctor
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import NNMonoid, TrivialRepresentation, TrivialCharacterMonoid
sage: F = MonoidPowerSeriesSymmetrisationFunctor(NNMonoid(), TrivialCharacterMonoid("1", ZZ), TrivialRepresentation("1", ZZ))
sage: F == MonoidPowerSeriesSymmetrisationFunctor(NNMonoid(), TrivialCharacterMonoid("1", ZZ), TrivialRepresentation("1", ZZ))
True
sage: F == MonoidPowerSeriesSymmetrisationFunctor(NNMonoid(), TrivialCharacterMonoid("1", ZZ), TrivialRepresentation("1", QQ))
False
"""
c = cmp(type(self), type(other))
if c == 0 :
c = cmp(self.__R, other.__R)
if c == 0 :
c = cmp(self.__O, other.__O)
if c == 0 :
c = cmp(self.__C, other.__C)
return c
def merge(self, other) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_functor import MonoidPowerSeriesSymmetrisationFunctor
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import NNMonoid, TrivialRepresentation, TrivialCharacterMonoid
sage: F = MonoidPowerSeriesSymmetrisationFunctor(NNMonoid(), TrivialCharacterMonoid("1", ZZ), TrivialRepresentation("1", ZZ))
sage: G = MonoidPowerSeriesSymmetrisationFunctor(NNMonoid(), TrivialCharacterMonoid("1", ZZ), TrivialRepresentation("1", QQ))
sage: F.merge(G) == G
True
sage: G = MonoidPowerSeriesSymmetrisationFunctor(NNMonoid(), TrivialCharacterMonoid("1", ZZ), TrivialRepresentation("1", FreeModule(QQ, 3)))
sage: F.merge(G) is None
True
"""
if self == other :
return self
elif type(self) == type(other) and \
self.__O == self.__O :
try :
if self.__C.extends(other.__C) and self.__R.extends(other.__R) :
return self
elif other.__C.extends(self.__C) and other.__R.extends(self.__R) :
return other
except AttributeError :
return None
return None
#===============================================================================
# MonoidPowerSeriesBaseRingInjection
#===============================================================================
class MonoidPowerSeriesBaseRingInjection ( Morphism ) :
"""
The injection of the base ring into a (equivariant) monoid power
series ring.
"""
def __init__(self, domain, codomain) :
"""
INPUT:
- ``domain`` -- A ring; The base ring.
- ``codomain`` -- A ring; The ring of monoid power series.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_functor import MonoidPowerSeriesFunctor, MonoidPowerSeriesBaseRingInjection
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import NNMonoid
sage: mps = MonoidPowerSeriesFunctor(NNMonoid(False))(ZZ)
sage: binj = MonoidPowerSeriesBaseRingInjection(ZZ, mps)
"""
Morphism.__init__(self, domain, codomain)
self._repr_type_str = "MonoidPowerSeries base injection"
def _call_(self, x) :
"""
Coerce an element into the ring of monoid power series.
INPUT:
- `x` -- An element of a ring; An element of the base ring.
OUTPUT:
An element of a ring.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_functor import MonoidPowerSeriesFunctor, MonoidPowerSeriesBaseRingInjection
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import NNMonoid
sage: mps = MonoidPowerSeriesFunctor(NNMonoid(False))(ZZ)
sage: binj = MonoidPowerSeriesBaseRingInjection(ZZ, mps)
sage: binj(1)
Monoid power series in Ring of monoid power series over NN
"""
return self.codomain()._element_constructor_(x)
def _call_with_args(self, x, *args, **kwds):
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_functor import MonoidPowerSeriesFunctor, MonoidPowerSeriesBaseRingInjection
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import NNMonoid
sage: mps = MonoidPowerSeriesFunctor(NNMonoid(False))(ZZ)
sage: binj = MonoidPowerSeriesBaseRingInjection(ZZ, mps)
sage: binj._call_with_args(1)
Monoid power series in Ring of monoid power series over NN
"""
return self.codomain()._element_constructor_(x, *args, **kwds)
| Python |
r"""
An equivariant monoid power series with lazy evaluation.
AUTHOR :
-- Martin Raum (2009 - 08 - 05) Initial version
"""
#===============================================================================
#
# Copyright (C) 2009 Martin Raum
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 3
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, see <http://www.gnu.org/licenses/>.
#
#===============================================================================
from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ambient import EquivariantMonoidPowerSeriesAmbient_abstract
from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import EquivariantMonoidPowerSeries_abstract
from sage.algebras.algebra_element import AlgebraElement
from sage.misc.misc import union
from sage.modules.module import Module
from sage.modules.module_element import ModuleElement
from sage.rings.ring import Ring
#===============================================================================
# EquivariantMonoidPowerSeries_lazy
#===============================================================================
def EquivariantMonoidPowerSeries_lazy(parent, precision, coefficient_function, components = None, bounding_precision = None) :
"""
Construct a equivariant monoid power series, which calculates its coefficients
on demand.
INPUT:
- ``parent`` -- An instance of :class:~`fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ambient.MonoidPowerSeriesAmbient_abstract`.
- ``precision`` -- A filter for the parent's action.
- ``coefficient_function`` -- A function returning for each pair of characters and
monoid element a Fourier coefficients.
- ``components`` -- ``None`` or a list of characters (default: ``None``). A list of components
that do not vanish. If ``None`` no component is assumed to be zero.
- ``bounding_precision`` -- ``None`` or a filter for the parent's action. If not ``None``
coefficients will be assumed to vanish outside the filter.
OUTPUT:
An instance of :class:~`EquivariantMonoidPowerSeries_abstract_lazy`.
EXAMPLES::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_lazyelement import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_module import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: emps = EquivariantMonoidPowerSeriesRing( NNMonoid(), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", QQ) )
sage: h = EquivariantMonoidPowerSeries_lazy(emps, emps.action().filter(3), lambda (ch, k) : 1)
sage: m = FreeModule(QQ, 3)
sage: emps = EquivariantMonoidPowerSeriesModule( NNMonoid(), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", m) )
sage: h = EquivariantMonoidPowerSeries_lazy(emps, emps.action().filter(3), lambda (ch, k) : m([1,2,3]))
sage: h = EquivariantMonoidPowerSeries_lazy(emps, emps.action().filter_all(), lambda (ch, k) : m([1,2,3]), bounding_precision = emps.action().filter(2))
sage: h = EquivariantMonoidPowerSeries_lazy(emps, emps.action().filter_all(), lambda (ch, k) : m([1,2,3]))
Traceback (most recent call last):
...
ValueError: Lazy equivariant monoid power series cannot have infinite precision.
"""
if (bounding_precision is None or bounding_precision.is_infinite()) and \
precision.is_infinite() and not (isinstance(components, list) and len(components) == 0) :
raise ValueError( "Lazy equivariant monoid power series cannot have infinite precision." )
if isinstance(parent, Module) :
return EquivariantMonoidPowerSeries_moduleelement_lazy(parent, precision, coefficient_function, components, bounding_precision)
if isinstance(parent, Ring) :
return EquivariantMonoidPowerSeries_algebraelement_lazy(parent, precision, coefficient_function, components, bounding_precision)
#===============================================================================
# EquivariantMonoidPowerSeries_abstract_lazy
#===============================================================================
class EquivariantMonoidPowerSeries_abstract_lazy (EquivariantMonoidPowerSeries_abstract) :
"""
This class implements an equivariant monoid power series which calculates the
coefficients on demand.
"""
def __init__(self, parent, precision, coefficient_function, components, bounding_precision = None ) :
"""
INPUT:
- ``parent`` -- An instance of :class:~`fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ambient.MonoidPowerSeriesAmbient_abstract`.
- ``precision`` -- A filter for the parent's action.
- ``coefficient_function`` -- A function returning for each pair of characters and
monoid element a Fourier coefficients.
- ``components`` -- ``None`` or a list of characters. A list of components that do not
vanish. If ``None`` no component is assumed to be zero.
- ``bounding_precision`` -- ``None`` or a filter for the parent's action. If not ``None``
coefficients will be assumed to vanish outside the filter.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_lazyelement import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: emps = EquivariantMonoidPowerSeriesRing( NNMonoid(), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", QQ) )
sage: h = EquivariantMonoidPowerSeries_abstract_lazy(emps, emps.action().filter(3), lambda (ch, k) : 1, None)
sage: h = EquivariantMonoidPowerSeries_abstract_lazy(emps, emps.action().filter(3), lambda (ch, k) : 1, [])
sage: h = EquivariantMonoidPowerSeries_abstract_lazy(emps, emps.action().filter_all(), lambda (ch, k) : 1, [], emps.action().filter(4))
"""
EquivariantMonoidPowerSeries_abstract.__init__(self, parent, precision)
self.__bounding_precision = bounding_precision
self.__coefficient_function = coefficient_function
self.__coefficients = dict()
self.__coefficients_complete = False
self.__components = components
def non_zero_components(self) :
"""
Return all those characters which are not guaranteed to have only
vanishing coefficients associated with.
OUTPUT:
A list of elements of the character monoid.
NOTE:
This will only return the list passed during the construction
of self or a list of all characters.
EXAMPLES::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_lazyelement import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: emps = EquivariantMonoidPowerSeriesRing( NNMonoid(), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", QQ) )
sage: e = EquivariantMonoidPowerSeries(emps, {emps.characters().one_element() : { 1 : 1}}, emps.action().filter_all())
sage: EquivariantMonoidPowerSeries_LazyMultiplication(e, e).non_zero_components()
[1]
sage: EquivariantMonoidPowerSeries_abstract_lazy(emps, emps.action().filter(3), lambda (ch, k) : 1, []).non_zero_components()
[]
"""
if self.__components is None :
self.__components = [c for c in self.parent().characters()]
return self.__components
def _bounding_precision(self) :
"""
If a filter for the vanishing of coefficients is given return this. Otherwise,
return the precision, which is then guaranteed to be finite.
OUTPUT:
A filter for the parent's action.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_lazyelement import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: emps = EquivariantMonoidPowerSeriesRing( NNMonoid(), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", QQ) )
sage: e = EquivariantMonoidPowerSeries(emps, {}, emps.action().filter_all())
sage: EquivariantMonoidPowerSeries_LazyMultiplication(e, e)._bounding_precision()
Filtered NN with action up to 0
sage: EquivariantMonoidPowerSeries_abstract_lazy(emps, emps.action().filter(3), lambda (ch, k) : 1, [emps.characters().one_element()])._bounding_precision()
Filtered NN with action up to 3
sage: h = EquivariantMonoidPowerSeries_abstract_lazy(emps, emps.action().filter_all(), lambda (ch, k) : 1, [])._bounding_precision() ## This would call the parent
Traceback (most recent call last):
...
AttributeError: EquivariantMonoidPowerSeries_abstract_lazy instance has no attribute 'parent'
sage: h = EquivariantMonoidPowerSeries_abstract_lazy(emps, emps.action().filter_all(), lambda (ch, k) : 1, [], emps.action().filter(4))._bounding_precision() ## This would call the parent
Traceback (most recent call last):
...
AttributeError: EquivariantMonoidPowerSeries_abstract_lazy instance has no attribute 'parent'
sage: EquivariantMonoidPowerSeries_abstract_lazy(emps, emps.action().filter_all(), lambda (ch, k) : 1, [emps.characters().one_element()], emps.action().filter(4))._bounding_precision()
Filtered NN with action up to 4
sage: EquivariantMonoidPowerSeries_abstract_lazy(emps, emps.action().filter_all(), lambda (ch, k) : 1, [emps.characters().one_element()])._bounding_precision()
Traceback (most recent call last):
...
ValueError: No bounding precision for ...
"""
if len(self.non_zero_components()) == 0 :
return self.parent().action().zero_filter()
elif not self.__bounding_precision is None :
return min(self.__bounding_precision, self.precision())
elif self.precision().is_infinite() :
raise ValueError( "No bounding precision for %s." % (self,) )
return self.precision()
def coefficients(self, force_characters = False) :
"""
Evaluate all coefficients within the precision bounds and return a
dictionary which saves all coefficients of this element.
INPUT:
- ``force_characters`` -- A boolean (default: ``False``); If ``True`` the
the dictionary returned will have characters as keys
in any cases.
OUTPUT:
Either of the following two:
- A dictionary with keys the elements of the parent's monoid and values in the
parent's coefficient domain.
- A dictionary with keys the parent's characters and values the a dictionary as follows. This
dictionary has keys the elements of the parent's monoid and values in the parent's
coefficient domain.
EXAMPLES::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_lazyelement import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: emps = EquivariantMonoidPowerSeriesRing( NNMonoid(), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", QQ) )
sage: e = EquivariantMonoidPowerSeries_abstract_lazy(emps, emps.action().filter(3), lambda (ch, k) : 1, [emps.characters().one_element()])
sage: e.coefficients()
{0: 1, 1: 1, 2: 1}
sage: e.coefficients(True)
{1: {0: 1, 1: 1, 2: 1}}
"""
if not self.__coefficients_complete :
self.__coefficients_complete = True
coefficient_function = self.__coefficient_function
for ch in self.non_zero_components() :
if not ch in self.__coefficients :
coeffs = dict()
self.__coefficients[ch] = coeffs
for k in self._bounding_precision() :
coeffs[k] = coefficient_function((ch, k))
else :
coeffs = self.__coefficients[ch]
for k in self._bounding_precision() :
if not k in coeffs :
coeffs[k] = coefficient_function((ch, k))
if len(self.__coefficients) == 0 and not force_characters :
return dict()
elif len(self.__coefficients) == 1 and not force_characters :
return self.__coefficients.values()[0]
else :
return self.__coefficients
def _truncate_in_place(self, precision) :
"""
Truncate ``self`` modifying also the coefficient cache.
INPUT:
- ``precision`` -- A filter for the parent's action or a an object that can be converted
to a filter.
OUTPUT:
``None``
EXAMPLE:
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_lazyelement import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: emps = EquivariantMonoidPowerSeriesRing( NNMonoid(), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", QQ) )
sage: h = EquivariantMonoidPowerSeries_abstract_lazy(emps, emps.action().filter(3), lambda (ch, k) : 1, None)
sage: e = EquivariantMonoidPowerSeries(emps, {emps.characters().one_element() : { 1 : 1}}, emps.action().filter_all())
sage: e = EquivariantMonoidPowerSeries_LazyMultiplication(e, e)
sage: e._truncate_in_place(emps.monoid().filter(2))
sage: e.coefficients()
{0: 0, 1: 0}
"""
precision = self.parent().action().filter(precision)
nprec = min(self.precision(), precision)
if nprec != self.precision() :
for c in self.__coefficients :
d = self.__coefficients[c]
for k in d.keys() :
if not k in nprec :
del d[k]
self._set_precision(nprec)
def __getitem__(self, k) :
"""
Evaluate and return the `k`-th coefficient if it below the series' precision. If no character is contained
in the key ``self`` must have only one nonvanishing component.
INPUT:
- `k` -- A pair of an element of the parent's character monoid and
and element of the parent's monoid or an element of the parent's monoid.
OUTPUT:
An element of the parent's coefficient domain.
EXAMPLES::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_lazyelement import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: emps = EquivariantMonoidPowerSeriesRing( NNMonoid(), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", QQ) )
sage: e = EquivariantMonoidPowerSeries(emps, {emps.characters().one_element() : { 1 : 1, 2 : 4}}, emps.action().filter(3))
sage: e = EquivariantMonoidPowerSeries_LazyMultiplication(e, e)
sage: e[(emps.characters().one_element(),2)]
1
sage: e[1], e[2]
(0, 1)
"""
try :
(ch, s) = k
except TypeError :
ch = None
try :
if not ch.parent() == self.parent().characters() :
ch = None
except AttributeError :
ch = None
if ch is None :
ns = self.non_zero_components()
if len(ns) == 0 :
return 0
elif len(ns) == 1 :
ch = ns[0]
else :
raise ValueError, "you must specify a character"
s = k
if not s in self.precision() :
raise ValueError, "%s out of bound" % s
try :
return self.__coefficients[ch][s]
except KeyError :
(rs, g) = self.parent()._reduction_function()(s)
try :
return self.parent()._character_eval_function()(g, ch) \
* self.parent()._apply_function()(g, self.__coefficients[ch][rs])
except KeyError :
e = self.__coefficient_function((ch, rs))
try :
self.__coefficients[ch][rs] = e
except KeyError :
self.__coefficients[ch] = dict()
self.__coefficients[ch][rs] = e
return e
#===============================================================================
# EquivariantMonoidPowerSeries_modulelement_lazy
#===============================================================================
class EquivariantMonoidPowerSeries_moduleelement_lazy (EquivariantMonoidPowerSeries_abstract_lazy, ModuleElement) :
"""
A lazy element of a module of equivariant monoid power series.
"""
def __init__(self, parent, precision, coefficient_function, components, bounding_precision ) :
"""
INPUT:
- ``parent`` -- An instance of :class:~`fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ambient.MonoidPowerSeriesAmbient_abstract`.
- ``precision`` -- A filter for the parent's action.
- ``coefficient_function`` -- A function returning for each pair of characters and
monoid element a Fourier coefficients.
- ``components`` -- ``None`` or a list of characters. A list of components that do not
vanish. If ``None`` no component is assumed to be zero.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_lazyelement import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_module import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: m = FreeModule(QQ, 3)
sage: emps = EquivariantMonoidPowerSeriesModule( NNMonoid(), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", m) )
sage: h = EquivariantMonoidPowerSeries_moduleelement_lazy(emps, emps.action().filter(3), lambda (ch, k) : m([1,2,3]), None, None)
"""
ModuleElement.__init__(self, parent)
EquivariantMonoidPowerSeries_abstract_lazy.__init__(self, parent, precision,
coefficient_function, components, bounding_precision)
#===============================================================================
# EquivariantMonoidPowerSeries_algebraelement_lazy
#===============================================================================
class EquivariantMonoidPowerSeries_algebraelement_lazy (EquivariantMonoidPowerSeries_abstract_lazy, AlgebraElement) :
"""
A lazy element of an algebra of equivariant monoid power series.
"""
def __init__(self, parent, precision, coefficient_function, components, bounding_precision ) :
"""
INPUT:
- ``parent`` -- An instance of :class:~`fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ambient.MonoidPowerSeriesAmbient_abstract`.
- ``precision`` -- A filter for the parent's action.
- ``coefficient_function`` -- A function returning for each pair of characters and
monoid element a Fourier coefficients.
- ``components`` -- ``None`` or a list of characters. A list of components that do not
vanish. If ``None`` no component is assumed to be zero.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_lazyelement import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: emps = EquivariantMonoidPowerSeriesRing( NNMonoid(), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", QQ) )
sage: h = EquivariantMonoidPowerSeries_algebraelement_lazy(emps, emps.action().filter(3), lambda (ch, k) : 1, None, None)
"""
AlgebraElement.__init__(self, parent)
EquivariantMonoidPowerSeries_abstract_lazy.__init__(self, parent, precision,
coefficient_function, components, bounding_precision)
#===============================================================================
# EquivariantMonoidPowerseries_MultiplicationDelayedFactory
#===============================================================================
class EquivariantMonoidPowerseries_MultiplicationDelayedFactory :
"""
A helper class for lazy multplication of equivariant monoid power series.
"""
def __init__( self, left, right ) :
"""
INPUT:
- ``left`` -- An instance of :class:~`fourier_expansion_framework.monoidpowerseries.EquivariantMonoidPowerSeries_abstract`.
- ``right`` -- An instance of :class:~`fourier_expansion_framework.monoidpowerseries.EquivariantMonoidPowerSeries_abstract`.
NOTE:
``left`` and ``right`` must have the same parents.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_lazyelement import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: emps = EquivariantMonoidPowerSeriesRing( NNMonoid(), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", QQ) )
sage: e = EquivariantMonoidPowerSeries(emps, {emps.characters().one_element() : { 1 : 1}}, emps.action().filter_all())
sage: EquivariantMonoidPowerSeries_LazyMultiplication(e, e).coefficients() # indirect doctest
{0: 0, 1: 0, 2: 1}
"""
assert left.parent() == right.parent()
self.__left = left
self.__right = right
self.__mul_fc = left.parent()._multiply_function()
self.__coefficient_ring = left.parent().coefficient_domain()
self.__left_coefficients = None
self.__right_coefficients = None
def getcoeff(self, (ch, k)) :
"""
Return the `k`-th coefficient of the component ``ch`` of the product.
INPUT:
- ``(ch, k)`` -- A pair of character and monoid element.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_lazyelement import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: emps = EquivariantMonoidPowerSeriesRing( NNMonoid(), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", QQ) )
sage: e = EquivariantMonoidPowerSeries(emps, {emps.characters().one_element() : { 1 : 1}}, emps.action().filter_all())
sage: EquivariantMonoidPowerSeries_LazyMultiplication(e, e).coefficients() # indirect doctest
{0: 0, 1: 0, 2: 1}
"""
res = self.__coefficient_ring(0)
if self.__left_coefficients is None :
self.__left_coefficients = self.__left.coefficients(True)
if self.__right_coefficients is None :
self.__right_coefficients = self.__right.coefficients(True)
for c1 in self.__left_coefficients :
lcoeffs = self.__left_coefficients[c1]
if len(lcoeffs) == 0 : continue
for c2 in self.__right_coefficients :
rcoeffs = self.__right_coefficients[c2]
if len(rcoeffs) == 0 : continue
if c1 * c2 != ch :
continue
res += self.__mul_fc( k, lcoeffs, rcoeffs, c1, c2, self.__coefficient_ring(0) )
return res
#===============================================================================
# EquivariantMonoidPowerSeries_LazyMultiplication
#===============================================================================
def EquivariantMonoidPowerSeries_LazyMultiplication(left, right) :
"""
The product of two equivariant monoid power series which is only evaluated
if a coefficient is demanded.
INPUT:
- ``left`` -- An instance of :class:~`fourier_expansion_framework.monoidpowerseries.EquivariantMonoidPowerSeries_abstract`.
- ``right`` -- An instance of :class:~`fourier_expansion_framework.monoidpowerseries.EquivariantMonoidPowerSeries_abstract`.
EXAMPLES:
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_lazyelement import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: emps = EquivariantMonoidPowerSeriesRing( NNMonoid(), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", QQ) )
sage: e = EquivariantMonoidPowerSeries(emps, {emps.characters().one_element() : { 1 : 1}}, emps.action().filter_all())
sage: EquivariantMonoidPowerSeries_LazyMultiplication(e, e).coefficients() # indirect doctest
{0: 0, 1: 0, 2: 1}
"""
# TODO: Insert coercing
if not isinstance(left.parent(), EquivariantMonoidPowerSeriesAmbient_abstract) \
or not isinstance(right.parent(), EquivariantMonoidPowerSeriesAmbient_abstract) :
raise TypeError, "both factors must be power series"
if left.parent() != right.parent() :
if left.parent() is right.parent().base_ring() :
parent = right.parent()
elif left.parent().base_ring() is right.parent() :
parent = left.parent()
raise ValueError, "incorrect parents of the factors"
else :
parent = left.parent()
coefficients_factory = \
EquivariantMonoidPowerseries_MultiplicationDelayedFactory( left, right )
precision = min(left.precision(), right.precision())
bounding_precision = None
if precision.is_infinite() :
left_coefficients = left.coefficients(True)
right_coefficients = right.coefficients(True)
left_keys = reduce(union, (set(c) for c in left_coefficients.itervalues()), set())
right_keys = reduce(union, (set(c) for c in right_coefficients.itervalues()), set())
bounding_precision = left.parent().action(). \
minimal_composition_filter(left_keys, right_keys)
return EquivariantMonoidPowerSeries_lazy( parent,
precision,
coefficients_factory.getcoeff,
bounding_precision = bounding_precision )
| Python |
"""
Implementation of base classes used as parameters for a ring of monoid
power series.
AUTHOR :
-- Martin Raum (2009 - 07 - 25) Initial version
"""
#===============================================================================
#
# Copyright (C) 2009 Martin Raum
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 3
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, see <http://www.gnu.org/licenses/>.
#
#===============================================================================
from operator import xor
from sage.misc.latex import latex
from sage.rings.all import is_Ring
from sage.rings.infinity import infinity
from sage.rings.integer import Integer
from sage.rings.integer_ring import ZZ
from sage.structure.sage_object import SageObject
#===============================================================================
# CharacterMonoid_class
#===============================================================================
class CharacterMonoid_class ( SageObject ) :
"""
The characters for an equivariant monoid power series must
form a monoid. A basic implementation is given here.
"""
def __init__(self, G, C, codomain, eval, C_multiplicative = True) :
"""
INPUT:
- `G` -- Every type accepted; Representative of a group which
the characters can be evaluated on.
- `C` -- A class implementing all functions of :class:`~.TrivialMonoid_class`;
A monoid whose elements represent one character each.
- ``codomain`` -- A ring; A common codomain for all characters.
- ``eval`` -- A function; It accepts a group element and a character,
returning the evaluation of this character at the
group element.
- ``C_multiplicative`` -- A boolean; If true the monoid `C` is assumed
to be multiplicative. Otherwise it is assumed to be additive.
NOTE:
The interface may change in the future, enforcing `G` to be a group.
EXAMPLES::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import CharacterMonoid_class
sage: cm = CharacterMonoid_class("ZZ", TrivialMonoid(), QQ, lambda g, c: 1)
TESTS::
sage: cm = CharacterMonoid_class(None, TrivialMonoid(), AbelianGroup([3,3]), lambda g, c: 1)
sage: cm = CharacterMonoid_class("ZZ", ZZ, AbelianGroup([3,3]), lambda g, c: 1, True)
"""
self.__G = G
self.__C = C
self.__codomain = codomain
self.__eval = eval
self.__C_multiplicative = C_multiplicative
def ngens(self) :
"""
OUTPUT:
An integer.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import CharacterMonoid_class
sage: cm = CharacterMonoid_class("ZZ", TrivialMonoid(), QQ, lambda g, c: 1)
sage: cm.ngens()
1
sage: cm = CharacterMonoid_class("ZZ", AbelianGroup([3, 3]), ZZ, lambda g, c: 1)
sage: cm.ngens()
2
"""
return self.__C.ngens()
def gen(self, i = 0) :
"""
OUTPUT:
An instance of :class:`~.CharacterMonoidElement_class`.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import CharacterMonoid_class
sage: cm = CharacterMonoid_class("ZZ", TrivialMonoid(), QQ, lambda g, c: 1)
sage: cm.gen()
1
"""
return CharacterMonoidElement_class(self, self.__C.gen(i))
def gens(self) :
"""
OUTPUT:
A tuple of instances of :class:`~.CharacterMonoidElement_class`.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import CharacterMonoid_class
sage: cm = CharacterMonoid_class("ZZ", TrivialMonoid(), QQ, lambda g, c: 1)
sage: cm.gens()
(1,)
"""
return tuple(map(lambda c: CharacterMonoidElement_class(self, c), self.__C.gens()))
def group(self) :
"""
Return the group, which is the common domain of all characters
of this monoid of characters.
OUTPUT:
Of arbitrary type.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import CharacterMonoid_class
sage: cm = CharacterMonoid_class("ZZ", TrivialMonoid(), QQ, lambda g, c: 1)
sage: cm.group()
'ZZ'
"""
return self.__G
def codomain(self) :
"""
Return the common codomain of all characters of this monoid of characters.
OUTPUT:
A ring.
EXAMPLES::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import CharacterMonoid_class
sage: cm = CharacterMonoid_class("ZZ", TrivialMonoid(), QQ, lambda g, c: 1)
sage: cm.codomain()
Rational Field
"""
return self.__codomain
def monoid(self) :
"""
Return the abstract monoid underlying this monoid of characters.
OUTPUT:
A monoid.
EXAMPLES::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import CharacterMonoid_class
sage: cm = CharacterMonoid_class("ZZ", TrivialMonoid(), QQ, lambda g, c: 1)
sage: cm.monoid()
Trivial monoid
sage: cm = CharacterMonoid_class("ZZ", AbelianGroup([3, 3]), ZZ, lambda g, c: 1)
sage: cm.monoid()
Multiplicative Abelian Group isomorphic to C3 x C3
"""
return self.__C
def extends(self, other) :
"""
Decide whether ``self`` extends ``other``. Namely, whether there is a is an embedding of ``other``
into ``self`` that is compatible with a common codomain. A negative answer does not mean
that there is no such embedding.
INPUT:
- other -- An instance of :class:.`~CharacterMonoid_class`.
OUTPUT:
A boolean.
EXAMPLES::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import CharacterMonoid_class
sage: cm1 = CharacterMonoid_class("ZZ", TrivialMonoid(), QQ, lambda g, c: 1)
sage: cm2 = CharacterMonoid_class("ZZ", TrivialMonoid(), QQ, lambda g, c: 1)
sage: cm1 == cm2
False
"""
return self == other
def _is_C_multiplicative(self) :
"""
Return whether the underlying monoid is multiplicative.
OUTPUT:
A boolean.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import CharacterMonoid_class
sage: cm = CharacterMonoid_class("ZZ", TrivialMonoid(), QQ, lambda g, c: 1)
sage: cm._is_C_multiplicative()
True
"""
return self.__C_multiplicative
def _eval_function(self) :
"""
Return the evaluation function, mapping an element of the associated group and an element of ``self``
to an element of the codomain.
OUTPUT:
A function with signature `g, c \mapsto e`.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import CharacterMonoid_class
sage: e = lambda g, c: 1
sage: cm = CharacterMonoid_class("ZZ", TrivialMonoid(), QQ, e)
sage: e == cm._eval_function()
True
"""
return self.__eval
def _apply(self, g, c, b) :
"""
Apply `c(g)` to some element `b` by multiplication.
INPUT:
- g -- Arbitrary type; A representative of the group.
- c -- An element of self; A character.
- b -- An element of a ring with embedding from the codomain. An element to
apply `c(g)` to.
OUTPUT:
An element of a ring.
EXAMPLES::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import CharacterMonoid_class
sage: cm = CharacterMonoid_class("ZZ", TrivialMonoid(), QQ, lambda g, c: 1)
sage: cm._apply(1, 1, 2)
2
"""
return self.__eval(g, c) * b
def __cmp__(self, other) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import CharacterMonoid_class
sage: cm1 = CharacterMonoid_class("ZZ", TrivialMonoid(), QQ, lambda g, c: 1)
sage: cm2 = CharacterMonoid_class("ZZ", TrivialMonoid(), QQ, lambda g, c: 1)
sage: cm1 == cm2
False
"""
c = cmp(type(self), type(other))
if c == 0 :
c = cmp(self.__G, other.__G)
if c == 0 :
c = cmp(self.__codomain, other.__codomain)
if c == 0 :
c = cmp(self.__C, other.__C)
if c == 0 and not self.__eval is other.__eval :
return -1
return c
def __iter__(self) :
"""
TEST::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import CharacterMonoid_class
sage: cm = CharacterMonoid_class("ZZ", TrivialMonoid(), QQ, lambda g, c: 1)
sage: list(cm)
[1]
"""
for c in self.__C :
yield CharacterMonoidElement_class(self, c)
raise StopIteration
def one_element(self) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import CharacterMonoid_class
sage: cm = CharacterMonoid_class("ZZ", TrivialMonoid(), QQ, lambda g, c: 1)
sage: cm.one_element()
1
"""
return CharacterMonoidElement_class(self, self.__C.one_element())
def __call__(self, x) :
"""
Convert an element to ``self``.
INPUT:
- `x` -- An element that is convertible to :meth:~`.monoid()`.
OUTPUT:
An element of ``self``.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import CharacterMonoid_class
sage: cm = CharacterMonoid_class("ZZ", TrivialMonoid(), QQ, lambda g, c: 1)
sage: cm(1)
1
"""
return CharacterMonoidElement_class(self, self.__C(x))
def __hash__(self) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import CharacterMonoid_class
sage: cm = CharacterMonoid_class("ZZ", TrivialMonoid(), QQ, lambda g, c: 1)
sage: d = dict([(cm.one_element, 0)]) # indirect doctest
"""
return xor(hash(self.__C), hash(self.__G))
def _repr_(self) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import CharacterMonoid_class
sage: CharacterMonoid_class("ZZ", TrivialMonoid(), QQ, lambda g, c: 1)
Character monoid over Trivial monoid
"""
return "Character monoid over %s" % self.__C
def _latex_(self) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import CharacterMonoid_class
sage: CharacterMonoid_class("ZZ", TrivialMonoid(), QQ, lambda g, c: 1)
Character monoid over Trivial monoid
"""
return "Character monoid over %s" % latex(self.__C)
#===============================================================================
# CharacterMonoidElement_class
#===============================================================================
class CharacterMonoidElement_class ( SageObject ) :
"""
The element class of :class:`~.CharacterMonoid_class`.
"""
def __init__(self, parent, c) :
"""
INPUT:
- ``parent`` -- An instance of :class:`~.CharacterMonoid_class`; The parent of ``self``.
- `c` -- An element of a monoid; The element in the underlying monoid of ``parent``
associated to ``self``.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import CharacterMonoid_class
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import CharacterMonoidElement_class
sage: cm = CharacterMonoid_class("ZZ", TrivialMonoid(), QQ, lambda g, c: 1)
sage: c = CharacterMonoidElement_class(cm, cm.monoid().one_element())
"""
self.__parent = parent
self.__c = c
def parent(self) :
"""
OUTPUT:
An instance of :class:`~.CharacterMonoid_class`.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import CharacterMonoid_class
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import CharacterMonoidElement_class
sage: cm = CharacterMonoid_class("ZZ", TrivialMonoid(), QQ, lambda g, c: 1)
sage: c = CharacterMonoidElement_class(cm, cm.monoid().one_element())
sage: c.parent() is cm
True
"""
return self.__parent
def _monoid_element(self) :
"""
The underlying element of the monoid.
OUTPUT:
An element of a character.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import CharacterMonoid_class
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import CharacterMonoidElement_class
sage: cm = CharacterMonoid_class("ZZ", TrivialMonoid(), QQ, lambda g, c: 1)
sage: c = CharacterMonoidElement_class(cm, cm.monoid().one_element())
sage: c._monoid_element() == cm.monoid().one_element()
True
"""
return self.__c
def __call__(self, g) :
"""
OUTPUT:
An element of the codomain of the parent.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import CharacterMonoid_class
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import CharacterMonoidElement_class
sage: cm = CharacterMonoid_class("ZZ", TrivialMonoid(), QQ, lambda g, c: 1)
sage: c = CharacterMonoidElement_class(cm, cm.monoid().one_element())
sage: c(2)
1
Test old bug, where elements of the underlying monoid were passed to the eval function::
sage: cm = CharacterMonoid_class("ZZ", TrivialMonoid(), QQ, lambda g, c: 1 if isinstance(c, CharacterMonoidElement_class) else -1)
sage: c = CharacterMonoidElement_class(cm, cm.monoid().one_element())
sage: c(2)
1
"""
return self.parent()._eval_function()(g, self)
def __mul__(left, right) :
"""
NOTE:
If the underlying monoid is additive the character are nevertheless multiplied.
OUTPUT:
An instance of :class:`~.CharacterMonoidElement_class`.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import CharacterMonoid_class
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import CharacterMonoidElement_class
sage: cm = CharacterMonoid_class("ZZ", TrivialMonoid(), QQ, lambda g, c: 1)
sage: c = CharacterMonoidElement_class(cm, cm.monoid().one_element())
sage: c * c # indirect doctest
1
sage: cm = CharacterMonoid_class("ZZ", ZZ, QQ, lambda g, c: 1, False)
sage: c = CharacterMonoidElement_class(cm, cm.monoid().one_element())
sage: c * c # indirect doctest
2
"""
if not isinstance(right, CharacterMonoidElement_class) or \
not left.parent() == right.parent() :
raise TypeError( "Right factor should be an element of the monoid." )
if left.parent()._is_C_multiplicative() :
return CharacterMonoidElement_class(left.parent(), left.__c * right.__c)
else :
return CharacterMonoidElement_class(left.parent(), left.__c + right.__c)
def __cmp__(self, other) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import CharacterMonoid_class
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import CharacterMonoidElement_class
sage: cm = CharacterMonoid_class("ZZ", ZZ, QQ, lambda g, c: 1, False)
sage: c1 = CharacterMonoidElement_class(cm, cm.monoid().one_element())
sage: c2 = CharacterMonoidElement_class(cm, cm.monoid().one_element())
sage: c1 == c2 # indirect doctest
True
sage: c1 * c1 == c1 # indirect doctest
False
"""
c = cmp(type(self), type(other))
if c == 0 :
c = cmp(self.__parent, other.__parent)
if c == 0 :
c = cmp(self.__c, other.__c)
return c
def __hash__(self) :
"""
OUTPUT:
An integer.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import CharacterMonoid_class
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import CharacterMonoidElement_class
sage: cm = CharacterMonoid_class("ZZ", TrivialMonoid(), QQ, lambda g, c: 1)
sage: c1 = CharacterMonoidElement_class(cm, cm.monoid().one_element())
sage: hash(c1) # indirect doctest
-582796950 # 32-bit
-3589969894075844246 # 64-bit
"""
return xor(hash(self.__parent), hash(self.__c))
def _repr_(self) :
"""
OUTPUT:
A string.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import CharacterMonoid_class
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import CharacterMonoidElement_class
sage: cm = CharacterMonoid_class("ZZ", TrivialMonoid(), QQ, lambda g, c: 1)
sage: c1 = CharacterMonoidElement_class(cm, cm.monoid().one_element())
sage: repr(c1) # indirect doctest
'1'
"""
return repr(self.__c)
def _latex_(self) :
"""
OUTPUT:
A string.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import CharacterMonoid_class
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import CharacterMonoidElement_class
sage: cm = CharacterMonoid_class("ZZ", TrivialMonoid(), QQ, lambda g, c: 1)
sage: c1 = CharacterMonoidElement_class(cm, cm.monoid().one_element())
sage: repr(c1) # indirect doctest
'1'
"""
return latex(self.__c)
#===============================================================================
# TrivialMonoid
#===============================================================================
class TrivialMonoid ( SageObject ) :
"""
A monoid with one element, which implements only functions that are necessary for
being an arguemnt of :meth:`~.CharacterMonoid_class.__init__`.
"""
def __init__(self) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import TrivialMonoid
sage: m = TrivialMonoid()
"""
SageObject.__init__(self)
def ngens(self) :
"""
OUTPUT:
An integer.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import TrivialMonoid
sage: m = TrivialMonoid()
sage: m.ngens()
1
"""
return 1
def gen(self, i = 0) :
"""
OUTPUT:
An integer.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import TrivialMonoid
sage: m = TrivialMonoid()
sage: m.gen()
1
sage: m.gen(1)
Traceback (most recent call last):
...
ValueError: Generator not defined.
"""
if i == 0 :
return Integer(1)
raise ValueError, "Generator not defined."
def gens(self) :
"""
OUTPUT:
A tuple of integers.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import TrivialMonoid
sage: m = TrivialMonoid()
sage: m.gens()
(1,)
"""
return (Integer(1), )
def one_element(self) :
"""
OUTPUT:
An integer.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import TrivialMonoid
sage: m = TrivialMonoid()
sage: m.one_element()
1
"""
return Integer(1)
def __call__(self, x) :
"""
INPUT:
- `x` -- An integer.
OUTPUT:
An integer.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import TrivialMonoid
sage: m = TrivialMonoid()
sage: m(1)
1
sage: m(2)
Traceback (most recent call last):
...
TypeError: Cannot convert 2 into Trivial monoid.
"""
if x == 1 :
return 1
raise TypeError( "Cannot convert %s into Trivial monoid." % (x,) )
def __cmp__(self, other) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import TrivialMonoid
sage: TrivialMonoid() == TrivialMonoid() # indirect doctest
True
"""
return cmp(type(self), type(other))
def __iter__(self) :
"""
OUTPUT:
A generator over integers.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import TrivialMonoid
sage: m = TrivialMonoid()
sage: list(m) # indirect doctest
[1]
"""
yield Integer(1)
raise StopIteration
def _repr_(self) :
"""
OUTPUT:
A string.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import TrivialMonoid
sage: m = TrivialMonoid()
sage: repr(m) # indirect doctest
'Trivial monoid'
"""
return "Trivial monoid"
def _latex_(self) :
"""
OUTPUT:
A string.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import TrivialMonoid
sage: m = TrivialMonoid()
sage: latex(m) # indirect doctest
Trivial monoid
"""
return "Trivial monoid"
#===============================================================================
# TrivialCharacterMonoid
#===============================================================================
_trivial_evaluations = dict()
def TrivialCharacterMonoid(G, K) :
"""
Return the monoid of characters with codomain `K` with one element.
INPUT:
- `K` -- A ring; The codomain for the characters.
OUTPUT:
An instance of :class:`~.CharacterMonoid_class`.
TESTS::
sage: h = TrivialCharacterMonoid("ZZ", QQ)
sage: h
Character monoid over Trivial monoid
sage: h == TrivialCharacterMonoid("ZZ", QQ)
True
"""
global _trivial_evaluations
try :
eval = _trivial_evaluations[K]
except KeyError :
eval = lambda g, c : K.one_element()
_trivial_evaluations[K] = eval
return CharacterMonoid_class(G, TrivialMonoid(), K, eval)
#===============================================================================
# TrivialRepresentation
#===============================================================================
class TrivialRepresentation ( SageObject ) :
"""
A trivial representation over a group `G` with codomain `K` occurring as a representation for
:class:`~fourier_expansion_framework.monoidpowerseries.EquivariantMonoidPowerSeriesAmbient_abstract`.
"""
def __init__(self, G, K) :
"""
INPUT:
- `G` -- Arbitrary type; A group or representative of a group.
- `K` -- A module or ring; The codomain of the representation.
OUTPUT:
An instance of :class:`~.TrivialRepresentation`.
NOTE:
The interface may change late, enforcing `G` to be an actual group.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import TrivialRepresentation
sage: rep = TrivialRepresentation("ZZ", QQ) # indirect doctest
"""
self.__G = G
self.__K = K
def base_ring(self) :
"""
The base ring of the representation, commuting with the action.
OUTPUT:
A ring.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import TrivialRepresentation
sage: rep = TrivialRepresentation("ZZ", QQ)
sage: rep.base_ring()
Rational Field
sage: rep = TrivialRepresentation("ZZ", FreeModule(ZZ, 3))
sage: rep.base_ring()
Integer Ring
"""
if is_Ring(self.__K) :
return self.__K
else :
return self.__K.base_ring()
def codomain(self) :
"""
The codomain of the representation.
OUTPUT:
A ring or a module.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import TrivialRepresentation
sage: rep = TrivialRepresentation("ZZ", FreeModule(ZZ, 3))
sage: rep.codomain()
Ambient free module of rank 3 over the principal ideal domain Integer Ring
"""
return self.__K
def base_extend(self, L) :
"""
Extend the representation's codomain by `L`.
INPUT:
- `L` -- A ring; A new base ring.
OUTPUT:
An instance of :class:`~.TrivialRepresentation`.
EXAMPLES::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import TrivialRepresentation
sage: rep = TrivialRepresentation("ZZ", FreeModule(ZZ, 3))
sage: repQQ = rep.base_extend(QQ)
sage: repQQ.codomain()
Vector space of dimension 3 over Rational Field
sage: repQQ.base_extend(GF(3))
Traceback (most recent call last):
...
TypeError: Base extension of self (over 'Rational Field') to ring 'Finite Field of size 3' not defined.
"""
return TrivialRepresentation( self.__G, self.__K.base_extend(L) )
def extends(self, other) :
"""
Wheter ``self`` is an extension of ``other``.
INPUT:
- ``other`` -- A representation.
OUTPUT:
A boolean.
NOTE:
This does not necessarily mean that ``self`` ocurres as a base extension of
``other``.
EXAMPLES::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import TrivialRepresentation
sage: rep1 = TrivialRepresentation("ZZ", ZZ)
sage: rep2 = TrivialRepresentation("ZZ", QQ)
sage: rep1.extends(rep2)
False
sage: rep2.extends(rep1)
True
"""
if type(self) != type(other) :
return False
return self.__K.has_coerce_map_from(other.__K)
def group(self) :
"""
The group that acts.
OUTPUT:
Arbitrary type.
EXAMPLES::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import TrivialRepresentation
sage: rep = TrivialRepresentation("ZZ", QQ)
sage: rep.group()
'ZZ'
"""
return self.__G
def _apply_function(self) :
"""
A function that maps a group element and an element of the codomain to its image.
OUTPUT:
A function with signature `(g,a) \mapsto g.a`.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import TrivialRepresentation
sage: rep = TrivialRepresentation("ZZ", QQ)
sage: rep._apply_function() == rep.apply
True
"""
return self.apply
def apply(self, g, a) :
"""
Return the image of `a` under the transformation `g`.
INPUT:
- `g` -- Arbitrary type; A group element.
- `a` -- An element of a ring of module; An elemento the codomain.
OUTPUT:
A element of the codomain.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import TrivialRepresentation
sage: rep = TrivialRepresentation("ZZ", QQ)
sage: rep.apply(2, 1/2)
1/2
"""
return a
def __cmp__(self, other) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import TrivialRepresentation
sage: rep1 = TrivialRepresentation("ZZ", QQ)
sage: rep2 = TrivialRepresentation("ZZ", FreeModule(QQ, 1))
sage: rep1 == rep1 # indirect doctest
True
sage: rep1 == rep2 # indirect doctest
False
"""
c = cmp(type(self), type(other))
if c == 0 :
c = cmp(self.__G, self.__G)
if c == 0 :
c = cmp(self.__K, other.__K)
return c
def __hash__(self) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import TrivialRepresentation
sage: rep = TrivialRepresentation("ZZ", QQ)
sage: hash(rep) # indirect doctest
-564657610 # 32-bit
-11520069220171210 # 64-bit
"""
return xor(hash(self.__G), hash(self.__K))
def _repr_(self) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import TrivialRepresentation
sage: rep = TrivialRepresentation("ZZ", QQ)
sage: repr(rep)
'Trivial representation of ZZ on Rational Field'
"""
return "Trivial representation of %s on %s" % (self.__G, self.__K)
def _latex_(self) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import TrivialRepresentation
sage: rep = TrivialRepresentation("ZZ", QQ)
sage: latex(rep)
Trivial representation of \texttt{ZZ} on \Bold{Q}
"""
return "Trivial representation of %s on %s" % (latex(self.__G), latex(self.__K))
#===============================================================================
# NNMonoid
#===============================================================================
class NNMonoid( SageObject ) :
"""
Monoid of all natural numbers with zero as is can occure as an arguement of
:class:`~fourier_expansion_framework.monoidpowerseries.MonoidPowerSeriesAmbient_abstract`.
"""
def __init__(self, reduced = True) :
"""
INPUT:
- ``reduce`` -- A boolean (default: True); Wheter ``self`` is equipped with an action
or not.
OUTPUT:
An instance of :class:`~.NNmonoid`.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import NNMonoid
sage: m = NNMonoid()
"""
self.__reduced = reduced
def ngens(self) :
"""
OUTPUT:
An integer.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import NNMonoid
sage: m = NNMonoid()
sage: m.ngens()
1
"""
return 1
def gen(self, i = 0) :
"""
OUTPUT:
An integer.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import NNMonoid
sage: m = NNMonoid()
sage: m.gen()
1
sage: m.gen(1)
Traceback (most recent call last):
...
ValueError: Generator not defined.
"""
if i == 0 :
return 1
raise ValueError( "Generator not defined." )
def gens(self) :
"""
OUTPUT:
A tuple of integers.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import NNMonoid
sage: m = NNMonoid()
sage: m.gens()
(1,)
"""
return tuple([self.gen(i) for i in xrange(self.ngens())])
def is_commutative(self) :
"""
Whether the monoid is commutative or not.
OUTPUT:
A boolean.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import NNMonoid
sage: m = NNMonoid()
sage: m.is_commutative()
True
"""
return True
def monoid(self) :
"""
If ``self`` respects the action of the trivial group return the underlying
monoid without this action. Otherwise return a copy of ``self``.
OUTPUT:
An instance of :class:`~.NNMonoid`.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import NNMonoid
sage: m_a = NNMonoid()
sage: m_woa = NNMonoid(False)
sage: m_a.monoid() == m_woa
True
sage: m_woa.monoid() == m_woa
True
sage: m_woa.monoid() is m_woa
False
"""
return NNMonoid(False)
def group(self) :
"""
If ``self`` respects the action of a group return representative.
OUTPUT:
Arbitrary type.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import NNMonoid
sage: m_a = NNMonoid()
sage: m_woa = NNMonoid(False)
sage: m_a.group()
'1'
sage: m_woa.group()
Traceback (most recent call last):
...
ArithmeticError: Monoid is not equipped with a group action.
"""
if self.__reduced :
return "1"
else :
raise ArithmeticError( "Monoid is not equipped with a group action.")
def is_monoid_action(self) :
"""
In case ``self`` respects the action of a group, decide whether this action is a monoid action
on the underlying monoid.
OUTPUT:
A boolean.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import NNMonoid
sage: m_a = NNMonoid()
sage: m_woa = NNMonoid(False)
sage: m_a.is_monoid_action()
1
sage: m_woa.is_monoid_action()
Traceback (most recent call last):
...
ArithmeticError: Monoid is not equipped with a group action.
"""
if self.__reduced :
return True
else :
raise ArithmeticError( "Monoid is not equipped with a group action.")
def filter(self, bound) :
"""
Return a filter with given bound associated to this monoid.
INPUT:
- ``bound`` -- An integer; An upper bound for natural numbers.
OUTPUT:
An instance of :class:`~.NNFilter`.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import NNMonoid
sage: m_a = NNMonoid()
sage: m_woa = NNMonoid(False)
sage: f = m_a.filter(5)
sage: f.index()
5
sage: f.is_reduced()
True
sage: f = m_woa.filter(7)
sage: f.is_reduced()
False
"""
return NNFilter(bound, self.__reduced)
def filter_all(self) :
"""
Return the filter associated to this monoid which contains all elements.
OUTPUT:
An instance of :class:`~.NNFilter`.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import NNMonoid
sage: m_a = NNMonoid()
sage: m_woa = NNMonoid(False)
sage: f = m_a.filter_all()
sage: f.index()
+Infinity
sage: f.is_reduced()
True
sage: m_woa.filter_all().is_reduced()
False
"""
return NNFilter(infinity, self.__reduced)
def zero_filter(self) :
"""
Return the filter associated to this monoid which contains no elements.
OUTPUT:
An instance of :class:`~.NNFilter`.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import NNMonoid
sage: m_a = NNMonoid()
sage: m_woa = NNMonoid(False)
sage: f = m_a.zero_filter()
sage: f.index()
0
sage: f.is_reduced()
True
sage: m_woa.zero_filter().is_reduced()
False
"""
return NNFilter(0, self.__reduced)
def minimal_composition_filter(self, ls, rs) :
"""
Given two lists `ls` and `rs` of natural numbers return a filter that contains
all the sums `l + r` of elements `l \in ls,\, r \in rs`.
INPUT:
- `ls` -- A list of integers.
- `rs` -- A list of integers.
OUTPUT:
An instance of :class:`~.NNFilter`.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import NNMonoid
sage: m = NNMonoid()
sage: m.minimal_composition_filter([], []).is_reduced()
True
sage: m = NNMonoid(False)
sage: m.minimal_composition_filter([], []).is_reduced()
False
sage: m = NNMonoid()
sage: m.minimal_composition_filter([], []).index()
0
sage: m.minimal_composition_filter([], [1]).index()
0
sage: m.minimal_composition_filter([1], []).index()
0
sage: m.minimal_composition_filter([1], [1]).index()
3
sage: m.minimal_composition_filter([1,2,4], [1,5]).index()
10
"""
if len(ls) == 0 or len(rs) == 0 :
return NNFilter(0, self.__reduced)
return NNFilter(max(0, max(ls) + max(rs) + 1), self.__reduced)
def _reduction_function(self) :
"""
In case ``self`` respects the action of a group, return the
reduction funtion for elements of this monoid.
SEE::
:meth:`~.reduce`
OUTPUT:
A function accepting one argument.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import NNMonoid
sage: m = NNMonoid()
sage: m._reduction_function() == m.reduce
True
sage: m = NNMonoid(False)
sage: m._reduction_function()
Traceback (most recent call last):
...
ArithmeticError: Monoid is not equipped with a group action.
"""
if self.__reduced :
return self.reduce
else :
raise ArithmeticError( "Monoid is not equipped with a group action." )
def reduce(self, s) :
"""
Reduce a natural number with respect to the trivial groups.
INPUT:
- `s` -- An integer.
OUTPUT:
The pair `(s, 1)`.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import NNMonoid
sage: m = NNMonoid()
sage: m.reduce(7)
(7, 1)
"""
return (s, 1)
def decompositions(self, s) :
"""
Decompose a natural number `s` in to a sum of two.
INPUT:
- `s` -- An integer.
OUTPUT:
A generator of pairs of integers.
EXAMPLES::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import NNMonoid
sage: m = NNMonoid()
sage: list(m.decompositions(4))
[(0, 4), (1, 3), (2, 2), (3, 1), (4, 0)]
"""
for n in xrange(s+1) :
yield (n, s-n)
raise StopIteration
def zero_element(self) :
"""
The zero element of this monoid.
OUTPUT:
An integer.
TESTS:
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import NNMonoid
sage: m = NNMonoid()
sage: m.zero_element()
0
"""
return 0
def __contains__(self, x) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import NNMonoid
sage: m = NNMonoid()
sage: 2 in m
True
sage: 'a' in m
False
sage: -1 in m
False
"""
return isinstance(x, (int, Integer)) and x >= 0
def __cmp__(self, other) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import NNMonoid
sage: m = NNMonoid()
sage: m == NNMonoid()
True
sage: m == NNMonoid(False)
False
"""
c = cmp(type(self), type(other))
if c == 0 :
c = cmp(self.__reduced, other.__reduced)
return c
def __hash__(self) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import NNMonoid
sage: hash(NNMonoid())
1
sage: hash(NNMonoid(False))
0
"""
return hash(self.__reduced)
def _repr_(self) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import NNMonoid
sage: repr(NNMonoid())
'NN with action'
sage: repr(NNMonoid(False))
'NN'
"""
if not self.__reduced :
return "NN"
else :
return "NN with action"
def _latex_(self) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import NNMonoid
sage: latex(NNMonoid())
$\NN$ with action
sage: latex(NNMonoid(False))
$\NN$
"""
if not self.__reduced :
return "$\NN$"
else :
return "$\NN$ with action"
#===============================================================================
# NNFilter
#===============================================================================
class NNFilter ( SageObject ) :
"""
A filter for the monoid of natrual numbers bounding elements by their value.
"""
def __init__(self, bound, reduced = True) :
"""
INPUT:
- ``bound`` -- An integer; A bound for the natural numbers.
- ``reduced`` -- A boolean (default: True); If True the action of the trivial
group is respected by the filter.
OUTPUT:
An instance of :class:`~.NNFilter`.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import NNMonoid
sage: f = NNFilter(3) # indirect doctest
sage: f = NNFilter(7, False) # indirect doctest
"""
if isinstance(bound, NNFilter) :
bound = bound.index()
self.__bound = bound
self.__reduced = reduced
def is_infinite(self) :
"""
Whether the filter contains infinitely many elements.
OUTPUT:
A boolean.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import NNMonoid
sage: NNFilter(3).is_infinite()
False
sage: NNFilter(infinity).is_infinite()
True
"""
return self.__bound is infinity
def is_all(self) :
"""
Whether the filter contains all elements of the associated monoid.
OUTPUT:
A boolean.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import NNMonoid
sage: NNFilter(3).is_all()
False
sage: NNFilter(infinity).is_all()
True
"""
return self.is_infinite()
def index(self) :
"""
Return the bound for this filter.
OUTPUT:
An integer.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import NNMonoid
sage: NNFilter(3).index()
3
"""
return self.__bound
def is_reduced(self) :
"""
Whether the filter respects the action of a group.
OUTPUT:
A boolean.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import NNMonoid
sage: NNFilter(3).is_reduced()
True
sage: NNFilter(7, False).is_reduced()
False
"""
return self.__reduced
def __contains__(self, n) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import NNMonoid
sage: f = NNFilter(10)
sage: 3 in f # indirect doctest
True
sage: 10 in f # indirect doctest
False
sage: 78 in NNFilter(infinity) # indirect doctest
True
"""
if self.__bound is infinity :
return True
return n < self.__bound
def __iter__(self) :
"""
OUTPUT:
A generator over integers.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import NNMonoid
sage: list(NNFilter(4)) == range(4) # indirect doctest
True
sage: list(NNFilter(infinity))
Traceback (most recent call last):
...
ArithmeticError: Cannot iterate over infinite filters.
"""
if self.__bound is infinity :
raise ArithmeticError( "Cannot iterate over infinite filters." )
for n in xrange(self.__bound) :
yield n
raise StopIteration
def __cmp__(self, other) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import NNMonoid
sage: NNFilter(4) == NNFilter(4) # indirect doctest
True
sage: NNFilter(4) == NNFilter(5) # indirect doctest
False
sage: NNFilter(4) == NNFilter(4, False) # indirect doctest
False
"""
c = cmp(type(self), type(other))
if c == 0 :
c = cmp(self.__reduced, other.__reduced)
if c == 0 :
c = cmp(self.__bound, other.__bound)
return c
def __hash__(self) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import NNMonoid
sage: hash(NNFilter(4)) # indirect doctest
21
sage: hash(NNFilter(7, False)) # indirect doctest
7
"""
return hash(self.__bound) + 17 * hash(self.__reduced)
def _repr_(self) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import NNMonoid
sage: repr(NNFilter(3))
'Filtered NN with action up to 3'
sage: repr(NNFilter(4, False))
'Filtered NN up to 4'
"""
if self.__reduced :
return "Filtered NN with action up to %s" % self.__bound
else :
return "Filtered NN up to %s" % self.__bound
def _latex_(self) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import NNMonoid
sage: latex(NNFilter(3))
Filtered $\NN$ with action up to $3$
sage: latex(NNFilter(4, False))
Filtered $\NN$ up to $4$
"""
if self.__reduced :
return "Filtered $\NN$ with action up to $%s$" % latex(self.__bound)
else :
return "Filtered $\NN$ up to $%s$" % latex(self.__bound)
| Python |
r"""
Monoid power series and equivariant monoid power series.
AUTHOR :
-- Martin Raum (2009 - 07 - 25) Initial version
"""
#===============================================================================
#
# Copyright (C) 2009 Martin Raum
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 3
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, see <http://www.gnu.org/licenses/>.
#
#===============================================================================
from copy import copy
from sage.algebras.algebra_element import AlgebraElement
from sage.misc.latex import latex
from sage.misc.misc import union
from sage.modules.module import Module
from sage.modules.module_element import ModuleElement
from sage.rings.ring import Ring
#===============================================================================
# MonoidPowerSeries
#===============================================================================
def MonoidPowerSeries( parent, coefficients, precision, cleanup_coefficients = False) :
"""
Create a monoid power series within a given parent.
INPUT:
- ``parent`` -- A ring or module of monoid power series.
- ``coefficients`` -- A dictionary with keys in the parent's monoid and values
in the parent coefficient domain.
- ``precision`` -- A filter for the parent's monoid.
- ``cleanup_coefficients`` -- A boolean (default: ``False``); If ``True`` zero
coefficients will be erased from the dictionary.
OUTPUT:
An instance of :class:~`.MonoidPowerSeries_abstract`.
EXAMPLES::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_module import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
sage: h = MonoidPowerSeries(mps, {1 : 1}, mps.monoid().filter(3))
TESTS::
sage: h = MonoidPowerSeries(mps, {1 : 1}, mps.monoid().zero_filter(), True)
sage: h = MonoidPowerSeries(mps, {1 : 4, 0 : 3}, mps.monoid().filter_all())
sage: mps = MonoidPowerSeriesModule(FreeModule(QQ, 2), NNMonoid(False))
sage: h = MonoidPowerSeries(mps, {1 : 1}, mps.monoid().filter(3))
"""
if isinstance(parent, Module) :
return MonoidPowerSeries_moduleelement(parent, coefficients, precision, cleanup_coefficients)
if isinstance(parent, Ring) :
return MonoidPowerSeries_algebraelement(parent, coefficients, precision, cleanup_coefficients)
raise TypeError, "Unexpected type of parent"
#===============================================================================
# MonoidPowerSeries_abstract
#===============================================================================
class MonoidPowerSeries_abstract :
"""
An element of the monoid power series ring or module up to
given precision.
"""
def __init__(self, parent, precision) :
"""
INPUT:
- ``parent`` -- An instance of :class:~`fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ambient.MonoidPowerSeriesAmbient_abstract`.
- ``precision`` -- A filter associated to the parent's monoid.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
sage: h = MonoidPowerSeries_abstract(mps, mps.monoid().zero_filter())
"""
self.__precision = parent.monoid().filter(precision)
def precision(self) :
"""
The series' precision.
OUTPUT:
A filter for the parent's monoid.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
sage: MonoidPowerSeries_abstract(mps, mps.monoid().zero_filter()).precision() == mps.monoid().zero_filter()
True
"""
return self.__precision
def _set_precision(self, precision) :
"""
Set the series' precision.
INPUT:
- ``precision`` -- A filter for the parent's monoid or a an object that can be converted
to a filter.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
sage: h = copy(mps.one_element())
sage: h._set_precision(mps.monoid().filter(2))
sage: h.precision() == mps.monoid().filter(2)
True
sage: h._set_precision(3)
sage: h.precision() == mps.monoid().filter(3)
True
"""
self.__precision = self.parent().monoid().filter(precision)
def _bounding_precision(self) :
"""
If ``self.precision()`` is an infinite filter, return a filter
which contains all non zero coefficients of this series. Otherwise,
return ``self.precision()``
OUTPUT:
A filter for the parent's monoid.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
sage: h = MonoidPowerSeries(mps, dict(), mps.monoid().filter(2))
sage: h._bounding_precision() == mps.monoid().filter(2)
True
sage: h = MonoidPowerSeries(mps, dict(), mps.monoid().filter_all())
sage: h._bounding_precision() == mps.monoid().zero_filter()
True
"""
if not self.precision().is_infinite() :
return self.precision()
return self.parent().monoid().minimal_composition_filter( self.coefficients().keys(),
[self.parent().monoid().zero_element()] )
def coefficients(self) :
"""
The coefficients of ``self``.
OUTPUT:
A dictionary with keys the elements of the parent's monoid and values in the
parent's coefficient domain.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
sage: MonoidPowerSeries_abstract(mps, mps.monoid().filter_all()).coefficients()
Traceback (most recent call last):
...
NotImplementedError
"""
raise NotImplementedError
def _truncate_in_place(self, precision) :
"""
Truncate ``self`` modifying the coefficient dictionary directly.
INPUT:
- ``precision`` -- A filter for the parent's monoid or a an object that can be converted
to a filter.
OUTPUT:
``None``
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
sage: MonoidPowerSeries_abstract(mps, mps.monoid().filter_all())._truncate_in_place(mps.monoid().zero_filter())
Traceback (most recent call last):
...
NotImplementedError
"""
raise NotImplementedError
def truncate(self, precision) :
"""
Truncate a copy of ``self``.
INPUT:
- ``precision`` -- A filter for the parent's monoid or a an object that can be converted
to a filter.
OUTPUT:
An instance of :class:~`.MonoidPowerSeries_abstract_nonlazy`.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
sage: MonoidPowerSeries_abstract(mps, mps.monoid().filter_all()).truncate(mps.monoid().zero_filter())
Traceback (most recent call last):
...
NotImplementedError
"""
raise NotImplementedError
def _add_(left, right) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
sage: mps.one_element() == mps.one_element() + MonoidPowerSeries(mps, dict(), mps.monoid().filter_all())
True
"""
prec = min(left.__precision, right.__precision)
lcoeffs = left.coefficients()
rcoeffs = right.coefficients()
lkeys = set(lcoeffs)
rkeys = set(rcoeffs)
d = dict()
for k in lkeys - rkeys :
d[k] = lcoeffs[k]
for k in rkeys - lkeys :
d[k] = rcoeffs[k]
for k in lkeys.intersection(rkeys) :
d[k] = lcoeffs[k] + rcoeffs[k]
return MonoidPowerSeries(left.parent(), d, prec)
def _mul_(left, right, switch_factors = False) :
"""
NOTE:
This function has to accept algebra and module elements and will
also compute the action of the base ring (which might be a monoid power series)
on a module.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
sage: mps.one_element() * mps.one_element() == mps.one_element()
True
"""
mul_fc = left.parent()._multiply_function()
if not switch_factors :
lcoeffs = left.coefficients()
rcoeffs = right.coefficients()
else :
lcoeffs = right.coefficients()
rcoeffs = left.coefficients()
prec = min(left.precision(), right.precision())
if prec.is_infinite() :
if len(lcoeffs) == 0 or len(rcoeffs) == 0:
return MonoidPowerSeries(left.parent(), dict(), prec)
iter_prec = left.parent().monoid(). \
minimal_composition_filter(set(lcoeffs), set(rcoeffs))
else :
iter_prec = prec
d = dict()
for k in iter_prec :
v = mul_fc( k, lcoeffs, rcoeffs,
left.parent().coefficient_domain().zero_element() )
if not v.is_zero() :
d[k] = v
return MonoidPowerSeries(left.parent(), d, prec)
def _lmul_(self, c) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_module import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
sage: (mps.one_element() * 2) * 3 == mps.one_element() * 6
True
sage: m = FreeModule(QQ, 3)
sage: mpsm = MonoidPowerSeriesModule(m, NNMonoid(False))
sage: h = MonoidPowerSeries(mps, {1 : 1, 3 : 2}, mps.monoid().filter(4))
sage: hv = MonoidPowerSeries(mpsm, {1 : m([1,0,0]), 2 : m([0,1,0])}, mps.monoid().filter(4))
sage: hh = hv * h
"""
if c.is_zero() :
return MonoidPowerSeries(self.parent(), dict(), None)
if isinstance(c, MonoidPowerSeries_abstract) and not isinstance(self, AlgebraElement) :
coeffs = c.coefficients()
if len(coeffs) == 1 and self.parent().monoid().zero_element() in coeffs :
c = coeffs[self.parent().monoid().zero_element()]
d = dict((k, c*v) for (k,v) in self.coefficients().iteritems())
return MonoidPowerSeries(self.parent(), d, self.precision())
return self._mul_(c, False)
else :
d = dict((k, c*v) for (k,v) in self.coefficients().iteritems())
return MonoidPowerSeries(self.parent(), d, self.precision())
def _rmul_(self, c) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_module import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
sage: 3 * (2 * mps.one_element()) == 6 * mps.one_element()
True
sage: m = FreeModule(QQ, 3)
sage: mpsm = MonoidPowerSeriesModule(m, NNMonoid(False))
sage: h = MonoidPowerSeries(mps, {1 : 1, 3 : 2}, mps.monoid().filter(4))
sage: hv = MonoidPowerSeries(mpsm, {1 : m([1,0,0]), 2 : m([0,1,0])}, mps.monoid().filter(4))
sage: hh = h * hv
"""
if c.is_zero() :
return MonoidPowerSeries(self.parent(), dict(), None)
if isinstance(c, MonoidPowerSeries_abstract) and not isinstance(self, AlgebraElement) :
coeffs = c.coefficients()
if len(coeffs) == 1 and self.parent().monoid().zero_element() in coeffs :
c = coeffs[self.parent().monoid().zero_element()]
d = dict((k, v*c) for (k,v) in self.coefficients().iteritems())
return MonoidPowerSeries(self.parent(), d, self.precision())
return self._mul_(c, True)
else :
d = dict((k, v*c) for (k,v) in self.coefficients().iteritems())
return MonoidPowerSeries(self.parent(), d, self.precision())
def __contains__(self, k) :
"""
Check whether `k` is below the series' precision.
INPUT:
- `k` -- An element of the parent's monoid.
OUTPUT:
A boolean.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
sage: 2 in mps.one_element()
True
sage: 1 in mps.one_element().truncate(mps.monoid().zero_filter())
False
"""
return k in self.precision()
def __getitem__(self, s) :
"""
Return the `k`-th coefficient if it below the series' precision.
INPUT:
- `k` -- An element of the parent's monoid.
OUTPUT:
An element of the parent's coefficient domain.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
sage: MonoidPowerSeries_abstract(mps, mps.monoid().filter_all())[0]
Traceback (most recent call last):
...
NotImplementedError
"""
raise NotImplementedError
def __cmp__(self, other) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
sage: mps.one_element() == mps.one_element()
True
sage: mps.one_element() == mps.zero_element()
False
"""
c = cmp(self.precision(), other.precision())
if c != 0 : return c
self_coeffs = self.coefficients()
other_coeffs = other.coefficients()
self_keys = set(self_coeffs)
other_keys = set(other_coeffs)
for k in self_keys - other_keys :
if not self_coeffs[k].is_zero() :
return -1
for k in other_keys - self_keys :
if not other_coeffs[k].is_zero() :
return -1
for k in self_keys.intersection(other_keys) :
if self_coeffs[k] != other_coeffs[k] :
return -1
return 0
def _repr_(self) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
sage: mps.one_element() # indirect doctest
Monoid power series in Ring of monoid power series over NN
"""
return "Monoid power series in %s" % self.parent()
def _latex_(self) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
sage: latex(mps.one_element()) # indirect doctest
Monoid power series in %sRing of monoid power series over $\NN$
"""
return "Monoid power series in %s" + latex(self.parent())
#===============================================================================
# MonoidPowerSeries_abstract_nonlazy
#===============================================================================
class MonoidPowerSeries_abstract_nonlazy (MonoidPowerSeries_abstract) :
"""
A abstract implementation of monoid power series that store their coefficients.
"""
def __init__(self, parent, coefficients, precision, cleanup_coefficients) :
"""
INPUT:
- ``parent`` -- An instance of :class:~`fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ambient.MonoidPowerSeriesAmbient_abstract`.
- ``coefficients`` -- A dictionary with keys in the parent's monoid and values
in the parent coefficient domain.
- ``precision`` -- A filter associated to the parent's monoid.
- ``cleanup_coefficients`` -- A boolean; If ``True`` zero coefficients will be
erased from the dictionary.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
sage: h = MonoidPowerSeries_abstract_nonlazy(mps, dict(), mps.monoid().zero_filter(), False)
"""
MonoidPowerSeries_abstract.__init__(self, parent, precision)
if cleanup_coefficients and len(coefficients) != 0 :
coefficients = self._cleanup_coefficients( coefficients, in_place = True )
self.__coefficients = coefficients
def coefficients(self) :
"""
The coefficients of ``self``.
OUTPUT:
A dictionary with keys the elements of the parent's monoid and values in the
parent's coefficient domain.
NOTE:
Some keys may be invalid. To get an exact result
call ``_cleanup_coefficients(in_place = True)`` before.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
sage: mps.one_element().coefficients()
{0: 1}
"""
return self.__coefficients
def _cleanup_coefficients(self, coefficients = None, in_place = True) :
"""
Remove zero entries and entries not below ``self.precision()`` from a coefficient dictionary.
INPUT:
- ``coefficients`` -- ``None`` or a dictionary (default: ``None``); If ``None`` the
coefficient dictionary assigned to ``self`` will be cleaned.
- ``in_place`` -- A boolean (default: ``True``); If ``False`` a copy of the coefficient
dictionary will me cleaned and returned.
OUTPUT:
A dictionary with keys the elements of the parent's monoid and values in the
parent's coefficient domain.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
sage: mps.one_element()._cleanup_coefficients()
{0: 1}
sage: d = {1 : 1}
sage: tmp = MonoidPowerSeries(mps, dict(), mps.monoid().zero_filter())._cleanup_coefficients(d)
sage: d
{}
sage: mps.zero_element()._cleanup_coefficients({1 : 0}, False)
{}
sage: h = copy(mps.one_element())
sage: h._set_precision(mps.monoid().zero_filter())
sage: h._cleanup_coefficients(in_place = False)
{}
"""
if coefficients is None :
coefficients = self.__coefficients
if in_place :
for s in coefficients.keys() :
if not s in self.precision() or coefficients[s].is_zero() :
del coefficients[s]
else :
ncoefficients = dict()
for s in coefficients :
if not s in self.precision() : continue
v = coefficients[s]
if v.is_zero() : continue
ncoefficients[s] = v
if in_place :
return coefficients
else :
return ncoefficients
def _truncate_in_place(self, precision) :
"""
Truncate ``self`` modifying the coefficient dictionary directly.
INPUT:
- ``precision`` -- A filter for the parent's monoid or a an object that can be converted
to a filter.
OUTPUT:
``None``
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
sage: h = copy(mps.one_element())
sage: h._truncate_in_place(mps.monoid().zero_filter())
sage: h.coefficients()
{}
sage: h = copy(mps.one_element())
sage: h._truncate_in_place(0)
sage: h.coefficients()
{}
"""
precision = self.parent().monoid().filter(precision)
nprec = min(self.precision(), precision)
if nprec != self.precision() :
coefficients = self.__coefficients
for k in coefficients.keys() :
if not k in nprec :
del coefficients[k]
self._set_precision(nprec)
def truncate(self, precision) :
"""
Truncate a copy of ``self``.
INPUT:
- ``precision`` -- A filter for the parent's monoid or a an object that can be converted
to a filter.
OUTPUT:
An instance of :class:~`.MonoidPowerSeries_abstract_nonlazy`.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
sage: mps.one_element().truncate(mps.monoid().zero_filter()).coefficients()
{}
sage: mps.one_element().truncate(0).coefficients()
{}
"""
precision = self.parent().monoid().filter(precision)
nprec = min(self.precision(), precision)
ncoefficients = copy(self.__coefficients)
return MonoidPowerSeries( self.parent(), ncoefficients, nprec, cleanup_coefficients = True )
def __getitem__(self, s) :
"""
Return the `k`-th coefficient if it below the series' precision.
INPUT:
- `k` -- An element of the parent's monoid.
OUTPUT:
An element of the parent's coefficient domain.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
sage: MonoidPowerSeries_abstract_nonlazy(mps, { 0 : 10, 1 : 1 }, mps.monoid().filter_all(), False)[0]
10
"""
try :
return self.coefficients()[s]
except KeyError :
return self.parent().coefficient_domain().zero_element()
#===============================================================================
# MonoidPowerSeries_moduleelement
#===============================================================================
class MonoidPowerSeries_moduleelement ( MonoidPowerSeries_abstract_nonlazy, ModuleElement ) :
"""
An element of a module of monoid power series.
"""
def __init__(self, parent, coefficients, precision, cleanup_coefficients) :
"""
INPUT:
- ``parent`` -- An instance of :class:~`fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ambient.MonoidPowerSeriesAmbient_abstract`.
- ``coefficients`` -- A dictionary with keys in the parent's monoid and values
in the parent coefficient domain.
- ``precision`` -- A filter associated to the parent's monoid.
- ``cleanup_coefficients`` -- A boolean; If ``True`` zero coefficients will be
erased from the dictionary.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_module import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: mps = MonoidPowerSeriesModule(FreeModule(QQ, 2), NNMonoid(False))
sage: h = MonoidPowerSeries_moduleelement(mps, dict(), mps.monoid().zero_filter(), False)
"""
ModuleElement.__init__(self, parent)
MonoidPowerSeries_abstract_nonlazy.__init__(self, parent, coefficients, precision, cleanup_coefficients)
#===============================================================================
# MonoidPowerSeries_algebraelement
#===============================================================================
class MonoidPowerSeries_algebraelement ( MonoidPowerSeries_abstract_nonlazy, AlgebraElement ) :
"""
An element of a algebra of monoid power series.
"""
def __init__(self, parent, coefficients, precision, cleanup_coefficients) :
"""
INPUT:
- ``parent`` -- An instance of :class:~`fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ambient.MonoidPowerSeriesAmbient_abstract`.
- ``coefficients`` -- A dictionary with keys in the parent's monoid and values
in the parent coefficient domain.
- ``precision`` -- A filter associated to the parent's monoid.
- ``cleanup_coefficients`` -- A boolean; If ``True`` zero coefficients will be
erased from the dictionary.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
sage: h = MonoidPowerSeries_algebraelement(mps, dict(), mps.monoid().zero_filter(), False)
"""
AlgebraElement.__init__(self, parent)
MonoidPowerSeries_abstract_nonlazy.__init__(self, parent, coefficients, precision, cleanup_coefficients)
#===============================================================================
# EquivariantMonoidPowerSeries
#===============================================================================
def EquivariantMonoidPowerSeries( parent, coefficients, precision, symmetrise = False,
cleanup_coefficients = False) :
"""
Create an equivariant monoid power series within a given parent.
INPUT:
- ``parent`` -- A ring or module of equivariant monoid power series.
- ``coefficients`` -- A dictionary with keys in the parent's monoid and values
in the parent coefficient domain.
- ``precision`` -- A filter for the parent's action.
- ``symmetrise`` -- A boolean (default: ``False``); If ``True`` every enty in
``coefficients`` will contribute to its whole orbit.
- ``cleanup_coefficients`` -- A boolean (default: ``False``); If ``True`` zero
coefficients will be erased from the dictionary.
OUTPUT:
An instance of :class:~`.EquivariantMonoidPowerSeries_abstract`.
EXAMPLES::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_module import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: emps = EquivariantMonoidPowerSeriesRing( NNMonoid(), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", QQ) )
sage: h = EquivariantMonoidPowerSeries(emps, {emps.characters().one_element() : {1 : 1}}, emps.action().filter(3))
TESTS::
sage: h = EquivariantMonoidPowerSeries(emps, {emps.characters().one_element() : {1 : 1}}, emps.action().zero_filter(), True)
sage: h = EquivariantMonoidPowerSeries(emps, {emps.characters().one_element() : {1 : 4, 0 : 3}}, emps.action().filter_all())
sage: h = EquivariantMonoidPowerSeries(emps, {emps.characters().one_element() : {1 : 4, 0 : 3}}, emps.action().filter_all(), symmetrise = True)
sage: emps = EquivariantMonoidPowerSeriesModule( NNMonoid(), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", FreeModule(QQ, 2)) )
sage: h = EquivariantMonoidPowerSeries(emps, {emps.characters().one_element() : {1 : 1}}, emps.action().filter(3))
"""
if isinstance(parent, Module) :
return EquivariantMonoidPowerSeries_moduleelement( parent, coefficients, precision, symmetrise,
cleanup_coefficients )
if isinstance(parent, Ring) :
return EquivariantMonoidPowerSeries_algebraelement( parent, coefficients, precision, symmetrise,
cleanup_coefficients )
raise TypeError, "Unexpected type of parent"
#===============================================================================
# EquivariantMonoidPowerSeries_abstract
#===============================================================================
class EquivariantMonoidPowerSeries_abstract :
"""
An abstract element of an equivariant monoid power series ring up to
given precision.
"""
def __init__( self, parent, precision ) :
"""
INPUT:
- ``parent`` -- A ring or module of equivariant monoid power series.
- ``precision`` -- A filter for the parent's action.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: emps = EquivariantMonoidPowerSeriesRing( NNMonoid(), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", QQ) )
sage: h = EquivariantMonoidPowerSeries_abstract(emps, emps.action().zero_filter()) # indirect doctest
"""
self.__precision = parent.action().filter(precision)
def precision(self) :
"""
The series' precision.
OUTPUT:
A filter for the parent's action.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: emps = EquivariantMonoidPowerSeriesRing( NNMonoid(), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", QQ) )
sage: EquivariantMonoidPowerSeries_abstract(emps, emps.action().filter(3)).precision() == emps.action().filter(3)
True
"""
return self.__precision
def _set_precision(self, precision) :
"""
Set the series' precision.
INPUT:
- ``precision`` -- A filter for the parent's action.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: emps = EquivariantMonoidPowerSeriesRing( NNMonoid(), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", QQ) )
sage: e = copy(emps.one_element())
sage: e._set_precision(emps.action().filter(3))
sage: e.precision() == emps.action().filter(3)
True
sage: e._set_precision(2)
sage: e.precision() == emps.action().filter(2)
True
"""
self.__precision = self.parent().action().filter(precision)
def non_zero_components(self) :
"""
Return all those characters which are not guaranteed to have only
vanishing coefficients associated to.
OUTPUT:
A list of elements of the character monoid.
NOTE:
The components associated to characters this function returns can vanish.
For exact results use ``_cleanup_coefficients(in_place = True)`` before.
EXAMPLES::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: emps = EquivariantMonoidPowerSeriesRing( NNMonoid(), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", QQ) )
sage: e = EquivariantMonoidPowerSeries(emps, dict(), emps.monoid().zero_filter())
sage: e.non_zero_components()
[]
sage: emps.one_element().non_zero_components()
[1]
"""
return list(self.parent().characters())
def _bounding_precision(self) :
"""
If ``self.precision()`` is an infinite filter, return a filter
which contains all non zero coefficients of this series. Otherwise,
return ``self.precision()``
OUTPUT:
A filter for the parent's action.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: emps = EquivariantMonoidPowerSeriesRing( NNMonoid(), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", QQ) )
sage: e = EquivariantMonoidPowerSeries(emps, dict(), emps.action().filter(2))
sage: e._bounding_precision() == emps.action().filter(2)
True
sage: e = EquivariantMonoidPowerSeries(emps, dict(), emps.action().filter_all())
sage: e._bounding_precision() == emps.action().zero_filter()
True
"""
if not self.precision().is_infinite() :
return self.precision()
coeffs = self.coefficients(True)
m = self.parent().action().zero_filter()
for c in self.non_zero_components() :
m = max(m, self.parent().action().minimal_composition_filter( coeffs[c].keys(),
[self.parent().action().zero_element()] ))
return m
def coefficients(self, force_characters = False) :
"""
The coefficients of ``self``.
INPUT:
- ``force_characters`` -- A boolean (default: ``False``); If ``True`` the
the dictionary returned will have characters as keys
in any cases.
OUTPUT:
Either of the following two:
- A dictionary with keys the elements of the parent's monoid and values in the
parent's coefficient domain.
- A dictionary with keys the parent's characters and values the a dictionary as follows. This
dictionary has keys the elements of the parent's monoid and values in the parent's
coefficient domain.
EXAMPLES::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: emps = EquivariantMonoidPowerSeriesRing( NNMonoid(), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", QQ) )
sage: EquivariantMonoidPowerSeries_abstract(emps, emps.action().zero_filter()).coefficients()
Traceback (most recent call last):
...
NotImplementedError
"""
raise NotImplementedError
def _truncate_in_place(self, precision) :
"""
Truncate ``self`` modifying the coefficient dictionary directly.
INPUT:
- ``precision`` -- A filter for the parent's monoid or a an object that can be converted
to a filter.
OUTPUT:
``None``
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: emps = EquivariantMonoidPowerSeriesRing( NNMonoid(), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", QQ) )
sage: e = emps.one_element()
sage: EquivariantMonoidPowerSeries_abstract(emps, emps.action().filter_all())._truncate_in_place(emps.monoid().zero_filter())
Traceback (most recent call last):
...
NotImplementedError
"""
raise NotImplementedError
def truncate(self, precision) :
"""
Truncate a copy of ``self``.
INPUT:
- ``precision`` -- A filter for the parent's monoid or a an object that can be converted
to a filter.
OUTPUT:
An instance of :class:~`.EquivariantMonoidPowerSeries_abstract`.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: emps = EquivariantMonoidPowerSeriesRing( NNMonoid(), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", QQ) )
sage: EquivariantMonoidPowerSeries_abstract(emps, emps.action().filter_all()).truncate(emps.action().zero_filter())
Traceback (most recent call last):
...
NotImplementedError
"""
raise NotImplementedError
def _add_(left, right) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: emps = EquivariantMonoidPowerSeriesRing( NNMonoid(), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", QQ) )
sage: e = EquivariantMonoidPowerSeries(emps, {emps.characters().one_element() : { 1 : 1 }}, emps.action().filter_all())
sage: (e + e)[1]
2
"""
prec = min(left.precision(), right.precision())
left_coefficients = left.coefficients(True)
right_coefficients = right.coefficients(True)
left_characters = set(left_coefficients)
right_characters = set(right_coefficients)
coefficients = dict()
for ch in left_characters - right_characters :
coefficients[ch] = copy(left_coefficients[ch])
for ch in right_characters - left_characters :
coefficients[ch] = copy(right_coefficients[ch])
for ch in left_characters.intersection(right_characters) :
lcoeffs = left_coefficients[ch]
rcoeffs = right_coefficients[ch]
lcoeff_keys = set(lcoeffs)
rcoeff_keys = set(rcoeffs)
nd = dict()
for k in lcoeff_keys - rcoeff_keys :
nd[k] = lcoeffs[k]
for k in rcoeff_keys - lcoeff_keys :
nd[k] = rcoeffs[k]
for k in lcoeff_keys.intersection(rcoeff_keys) :
nd[k] = lcoeffs[k] + rcoeffs[k]
coefficients[ch] = nd
return EquivariantMonoidPowerSeries(left.parent(),
coefficients, prec)
def _mul_(left, right, switch_factors = False) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: emps = EquivariantMonoidPowerSeriesRing( NNMonoid(), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", QQ) )
sage: e = EquivariantMonoidPowerSeries(emps, {emps.characters().one_element() : { 1 : 1 }}, emps.action().filter_all())
sage: (e * e)[2]
1
"""
mul_fc = left.parent()._multiply_function()
coefficient_domain = left.parent().coefficient_domain()
prec = min(left.precision(), right.precision())
if not switch_factors :
left_coefficients = left.coefficients(True)
right_coefficients = right.coefficients(True)
else :
right_coefficients = left.coefficients(True)
left_coefficients = right.coefficients(True)
if prec.is_infinite() :
left_keys = reduce(union, (set(left_coefficients[c]) for c in left_coefficients), set())
right_keys = reduce(union, (set(right_coefficients[c]) for c in right_coefficients), set())
if len(left_keys) == 0 or len(right_keys) == 0:
return EquivariantMonoidPowerSeries(left.parent(), dict(), prec)
iter_prec = left.parent().action(). \
minimal_composition_filter(left_keys, right_keys)
else :
iter_prec = prec
coefficients = dict()
for c1 in left_coefficients :
lcoeffs = left_coefficients[c1]
if len(lcoeffs) == 0 : continue
for c2 in right_coefficients :
rcoeffs = right_coefficients[c2]
if len(rcoeffs) == 0 : continue
try :
d = coefficients[c1 * c2]
except KeyError :
d = dict()
coefficients[c1 * c2] = d
for k in iter_prec :
v = mul_fc( k, lcoeffs, rcoeffs, c1, c2, coefficient_domain(0) )
if not v.is_zero() :
try :
d[k] += v
if d[k].is_zero() :
del d[k]
except KeyError :
d[k] = v
return EquivariantMonoidPowerSeries( left.parent(), coefficients, prec )
def _lmul_(self, c) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_module import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: emps = EquivariantMonoidPowerSeriesRing( NNMonoid(), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", QQ) )
sage: (emps.one_element() * 2) * 3 == emps.one_element() * 6
True
sage: m = FreeModule(QQ, 3)
sage: empsm = EquivariantMonoidPowerSeriesModule(NNMonoid(True), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", m))
sage: h = EquivariantMonoidPowerSeries(emps, {emps.characters().one_element(): {1: 1, 3: 2}}, emps.action().filter_all())
sage: hv = EquivariantMonoidPowerSeries(empsm, {empsm.characters().one_element(): {1: m([1,0,0]), 2: m([0,0,1])}}, empsm.action().filter_all())
sage: hh = hv * h
"""
if c.is_zero() :
return EquivariantMonoidPowerSeries(self.parent(), dict(), self.parent().monoid().filter_all())
if isinstance(c, EquivariantMonoidPowerSeries_abstract) and not isinstance(self, AlgebraElement) :
nzc = c.non_zero_components()
if len(nzc) == 1 :
coeffs = c.coefficients(True)[nzc[0]]
if len(coeffs) == 1 and self.parent().action().zero_element() in coeffs :
c = coeffs[self.parent().action().zero_element()]
self_coefficients = self.coefficients(True)
coefficients = dict()
for ch in self_coefficients :
coefficients[ch] = dict((k, c*v) for (k,v) in self_coefficients[ch].iteritems())
return EquivariantMonoidPowerSeries(self.parent(),
coefficients, self.precision())
return self._mul_(c, False)
else :
self_coefficients = self.coefficients(True)
coefficients = dict()
for ch in self_coefficients :
coefficients[ch] = dict((k, c*v) for (k,v) in self_coefficients[ch].iteritems())
return EquivariantMonoidPowerSeries(self.parent(),
coefficients, self.precision())
def _rmul_(self, c) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_module import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: emps = EquivariantMonoidPowerSeriesRing( NNMonoid(), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", QQ) )
sage: 3 * (2 * emps.one_element()) == 6 * emps.one_element()
True
sage: m = FreeModule(QQ, 3)
sage: empsm = EquivariantMonoidPowerSeriesModule(NNMonoid(True), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", m))
sage: h = EquivariantMonoidPowerSeries(emps, {emps.characters().one_element(): {1: 1, 3: 2}}, emps.action().filter_all())
sage: hv = EquivariantMonoidPowerSeries(empsm, {empsm.characters().one_element(): {1: m([1,0,0]), 2: m([0,0,1])}}, empsm.action().filter_all())
sage: hh = h * hv
"""
if c.is_zero() :
return EquivariantMonoidPowerSeries(self.parent(), dict(), self.parent().monoid().filter_all())
if isinstance(c, EquivariantMonoidPowerSeries_abstract) and not isinstance(self, AlgebraElement) :
nzc = c.non_zero_components()
if len(nzc) == 1 :
coeffs = c.coefficients(True)[nzc[0]]
if len(coeffs) == 1 and self.parent().action().zero_element() in coeffs :
c = coeffs[self.parent().action().zero_element()]
self_coefficients = self.coefficients(True)
coefficients = dict()
for ch in self_coefficients :
coefficients[ch] = dict((k, v*c) for (k,v) in self_coefficients[ch].iteritems())
return EquivariantMonoidPowerSeries(self.parent(),
coefficients, self.precision())
return self._mul_(c, True)
else :
self_coefficients = self.coefficients(True)
coefficients = dict()
for ch in self_coefficients :
coefficients[ch] = dict((k, v*c) for (k,v) in self_coefficients[ch].iteritems())
return EquivariantMonoidPowerSeries(self.parent(),
coefficients, self.precision())
def __contains__(self, k) :
"""
Check whether an index or a pair of character and index
is containted in the precision.
EXAMPLES:
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: emps = EquivariantMonoidPowerSeriesRing( NNMonoid(), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", QQ) )
sage: e = EquivariantMonoidPowerSeries(emps, {emps.characters().one_element() : {1 : 1, 2 : 1}}, emps.action().filter(3))
sage: 3 in e
False
sage: 2 in e
True
sage: (emps.characters().one_element(),2) in e
True
"""
try :
(ch, k) = k
if k not in self.parent().monoid() :
k = (ch, k)
except TypeError :
pass
return k in self.precision()
def __getitem__(self, k) :
"""
Return the `k`-th coefficient if it below the series' precision. If no character is contained
in the key ``self`` must have only one nonvanishing component.
INPUT:
- `k` -- A pair of an element of the parent's character monoid and
and element of the parent's monoid or an element of the parent's monoid.
OUTPUT:
An element of the parent's coefficient domain.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: emps = EquivariantMonoidPowerSeriesRing( NNMonoid(), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", QQ) )
sage: EquivariantMonoidPowerSeries_abstract(emps, emps.action().filter_all())[(emps.characters().one_element(), 0)]
Traceback (most recent call last):
...
NotImplementedError
"""
raise NotImplementedError
def __cmp__(self, other) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: emps = EquivariantMonoidPowerSeriesRing( NNMonoid(), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", QQ) )
sage: e = EquivariantMonoidPowerSeries(emps, {emps.characters().one_element() : { 1 : 1 }}, emps.action().zero_filter())
sage: e == EquivariantMonoidPowerSeries(emps, {emps.characters().one_element() : { 1 : 1 }}, emps.action().zero_filter())
True
sage: e == 2 * e
False
sage: e == EquivariantMonoidPowerSeries(emps, {}, emps.action().zero_filter())
False
"""
c = cmp(self.precision(), other.precision())
if c != 0 : return c
self_coefficients = self.coefficients(True)
other_coefficients = other.coefficients(True)
for ch in set(self_coefficients) - set(other_coefficients) :
d = self_coefficients[ch]
for k in d:
if not d[k] == 0 :
return -1
for ch in set(other_coefficients) - set(self_coefficients) :
d = other_coefficients[ch]
for k in d:
if not d[k] == 0 :
return -1
for ch in set(self_coefficients).intersection(set(other_coefficients)) :
s = self_coefficients[ch]
o = other_coefficients[ch]
self_keys = set(s)
other_keys = set(o)
for k in self_keys - other_keys :
if not s[k] == 0 :
return -1
for k in other_keys - self_keys :
if not o[k] == 0 :
return -1
for k in self_keys.intersection(other_keys) :
if s[k] != o[k] :
return -1
return 0
def _repr_(self) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: emps = EquivariantMonoidPowerSeriesRing( NNMonoid(), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", QQ) )
sage: EquivariantMonoidPowerSeries(emps, {emps.characters().one_element() : { 1 : 1 }}, emps.action().zero_filter())
Equivariant monoid power series in Ring of equivariant monoid power series over NN
"""
return "Equivariant monoid power series in %s" % (self.parent(),)
def _latex_(self) :
"""
EXAMPLES:
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: emps = EquivariantMonoidPowerSeriesRing( NNMonoid(), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", QQ) )
sage: latex( EquivariantMonoidPowerSeries(emps, {emps.characters().one_element() : { 1 : 1 }}, emps.action().zero_filter()) )
Equivariant monoid power series in Ring of equivariant monoid power series over $\NN$
"""
return "Equivariant monoid power series in %s" % latex(self.parent())
#===============================================================================
# EquivariantMonoidPowerSeries_abstract_nonlazy
#===============================================================================
class EquivariantMonoidPowerSeries_abstract_nonlazy ( EquivariantMonoidPowerSeries_abstract ) :
"""
A abstract implementation of equiavariant monoid power series that store their coefficients.
"""
def __init__( self, parent, coefficients, precision, symmetrise,
cleanup_coefficients ) :
"""
INPUT:
- ``parent`` -- A ring or module of equivariant monoid power series.
- ``coefficients`` -- A dictionary with keys in the parent's monoid and values
in the parent coefficient domain.
- ``precision`` -- A filter for the parent's action.
- ``symmetrise`` -- A boolean (default: ``False``); If ``True`` every enty in
``coefficients`` will contribute to its whole orbit.
- ``cleanup_coefficients`` -- A boolean (default: ``False``); If ``True`` zero
coefficients will be erased from the dictionary.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_module import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: emps = EquivariantMonoidPowerSeriesRing( NNMonoid(), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", QQ) )
sage: h = EquivariantMonoidPowerSeries_abstract_nonlazy(emps, {emps.characters().one_element() : {1 : 1}}, emps.action().filter(3), False, False)
sage: h = EquivariantMonoidPowerSeries_abstract_nonlazy(emps, {emps.characters().one_element() : {1 : 1}}, emps.action().zero_filter(), False, True)
sage: h = EquivariantMonoidPowerSeries_abstract_nonlazy(emps, {emps.characters().one_element() : {1 : 4, 0 : 3}}, emps.action().filter_all(), False, False,)
sage: h = EquivariantMonoidPowerSeries_abstract_nonlazy(emps, {emps.characters().one_element() : {1 : 4, 0 : 3}}, emps.action().filter_all(), True, False)
sage: emps = EquivariantMonoidPowerSeriesModule( NNMonoid(), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", FreeModule(QQ, 2)) )
sage: h = EquivariantMonoidPowerSeries_abstract_nonlazy(emps, {emps.characters().one_element() : {1 : 1}}, emps.action().filter(3), False, False)
"""
EquivariantMonoidPowerSeries_abstract.__init__(self, parent, precision)
if cleanup_coefficients and len(coefficients) != 0 :
ncoefficients = self._cleanup_coefficients( coefficients,
in_place = True )
else :
ncoefficients = coefficients
if symmetrise :
## for symmetrisation we are guaranteed that
## the representation acts trivially on all coefficients
reduction = parent._reduction_function()
character_eval = parent._character_eval_function()
self.__coefficients = dict()
for ch in ncoefficients :
d = ncoefficients[ch]
nd = dict()
self.__coefficients[ch] = nd
for s in d :
rs, g = reduction(s)
try :
nd[rs] += character_eval(g, ch) * d[s]
except KeyError :
nd[rs] = character_eval(g, ch) * d[s]
else :
self.__coefficients = ncoefficients
def non_zero_components(self) :
"""
Return all those characters which are not guaranteed to have only
vanishing coefficients associated to.
OUTPUT:
A list of elements of the character monoid.
NOTE:
The components associated to characters this function returns can vanish.
For exact results use ``_cleanup_coefficients(in_place = True)`` before.
EXAMPLES::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: emps = EquivariantMonoidPowerSeriesRing( NNMonoid(), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", QQ) )
sage: e = EquivariantMonoidPowerSeries_abstract_nonlazy(emps, {emps.characters().one_element() : {1 : 0}}, emps.action().zero_filter(), False, False)
sage: e.non_zero_components()
[1]
sage: e._cleanup_coefficients(in_place = True)
{}
sage: e.non_zero_components()
[]
"""
return self.__coefficients.keys()
def coefficients(self, force_characters = False) :
"""
The coefficients of ``self``.
INPUT:
- ``force_characters`` -- A boolean (default: ``False``); If ``True`` the
the dictionary returned will have characters as keys
in any cases.
OUTPUT:
Either of the following two:
- A dictionary with keys the elements of the parent's monoid and values in the
parent's coefficient domain.
- A dictionary with keys the parent's characters and values the a dictionary as follows. This
dictionary has keys the elements of the parent's monoid and values in the parent's
coefficient domain.
NOTE:
Some keys may be invalid. To get an exact result
call ``_cleanup_coefficients(in_place = True)`` before.
EXAMPLES::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: emps = EquivariantMonoidPowerSeriesRing( NNMonoid(), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", QQ) )
sage: EquivariantMonoidPowerSeries_abstract_nonlazy(emps, {emps.characters().one_element() : {1 : 1}}, emps.action().zero_filter(), False, False).coefficients()
{1: 1}
sage: EquivariantMonoidPowerSeries_abstract_nonlazy(emps, {emps.characters().one_element() : {1 : 1}}, emps.action().zero_filter(), False, False).coefficients(True)
{1: {1: 1}}
"""
if len(self.__coefficients) == 0 :
return dict()
elif not force_characters and len(self.__coefficients) == 1 :
return self.__coefficients.values()[0]
else :
return self.__coefficients
def _cleanup_coefficients(self, coefficients = None, in_place = True) :
"""
Remove zero entries and entries not below ``self.precision()`` from a coefficient dictionary.
INPUT:
- ``coefficients`` -- ``None`` or a dictionary (default: ``None``); If ``None`` the
coefficient dictionary assigned to ``self`` will be cleaned.
- ``in_place`` -- A boolean (default: ``True``); If ``False`` a copy of the coefficient
dictionary will me cleaned and returned.
OUTPUT:
A dictionary with keys the parent's characters and values the a dictionary as follows. This
dictionary has keys the elements of the parent's monoid and values in the parent's
coefficient domain.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: emps = EquivariantMonoidPowerSeriesRing( NNMonoid(), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", QQ) )
sage: emps.one_element()._cleanup_coefficients()
{1: {0: 1}}
sage: d = {emps.characters().one_element() : {1 : 1}}
sage: tmp = EquivariantMonoidPowerSeries(emps, dict(), emps.action().zero_filter())._cleanup_coefficients(d)
sage: d
{}
sage: emps.zero_element()._cleanup_coefficients({emps.characters().one_element() : {1 : 0}}, False)
{}
sage: h = copy(emps.one_element())
sage: h._set_precision(emps.action().zero_filter())
sage: h._cleanup_coefficients(in_place = False)
{}
"""
if coefficients is None :
coefficients = self.__coefficients
if not in_place :
ncoefficients = dict()
for ch in coefficients.keys() :
d = coefficients[ch]
if in_place :
for s in d.keys() :
if not s in self.precision() or d[s].is_zero() :
del d[s]
if len(d) == 0 :
del coefficients[ch]
else :
nd = dict()
for s in d :
if not s in self.precision() : continue
v = d[s]
if v.is_zero() : continue
nd[s] = v
if len(nd) != 0 :
ncoefficients[ch] = nd
if in_place :
return coefficients
else :
return ncoefficients
def _truncate_in_place(self, precision) :
"""
Truncate ``self`` modifying the coefficient dictionary directly.
INPUT:
- ``precision`` -- A filter for the parent's monoid or a an object that can be converted
to a filter.
OUTPUT:
``None``
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: emps = EquivariantMonoidPowerSeriesRing( NNMonoid(), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", QQ) )
sage: e = copy(emps.one_element())
sage: e._truncate_in_place(emps.monoid().zero_filter())
sage: e.coefficients()
{}
sage: e = EquivariantMonoidPowerSeries(emps, {emps.characters().one_element() : {1 : 1, 2 : 0}}, emps.action().filter(3))
sage: e._truncate_in_place(2)
sage: 2 in e.coefficients()
False
"""
precision = self.parent().action().filter(precision)
nprec = min(self.precision(), precision)
if nprec != self.precision() :
for c in self.__coefficients :
d = self.__coefficients[c]
for k in d.keys() :
if not k in nprec :
del d[k]
self._set_precision(nprec)
def truncate(self, precision) :
"""
Truncate a copy of ``self``.
INPUT:
- ``precision`` -- A filter for the parent's monoid or a an object that can be converted
to a filter.
OUTPUT:
An instance of :class:~`.EquivariantMonoidPowerSeries_abstract`.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: emps = EquivariantMonoidPowerSeriesRing( NNMonoid(), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", QQ) )
sage: emps.one_element().truncate(emps.monoid().zero_filter()).coefficients()
{}
sage: e = EquivariantMonoidPowerSeries(emps, {emps.characters().one_element() : {1 : 1, 2 : 0}}, emps.action().filter(3))
sage: 2 in e.truncate(2)
False
"""
precision = self.parent().action().filter(precision)
nprec = min(self.precision(), precision)
ncoefficients = dict( (ch, copy(self.__coefficients[ch]))
for ch in self.__coefficients )
return EquivariantMonoidPowerSeries( self.parent(),
ncoefficients, nprec, cleanup_coefficients = True )
def __getitem__(self, k) :
"""
Return the `k`-th coefficient if it below the series' precision. If no character is contained
in the key ``self`` must have only one nonvanishing component.
INPUT:
- `k` -- A pair of an element of the parent's character monoid and
and element of the parent's monoid or an element of the parent's monoid.
OUTPUT:
An element of the parent's coefficient domain.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: emps = EquivariantMonoidPowerSeriesRing( NNMonoid(), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", QQ) )
sage: EquivariantMonoidPowerSeries(emps, {emps.characters().one_element() : { 0 : 10, 1 : 1 }}, emps.action().filter_all())[(emps.characters().one_element(), 0)]
10
sage: EquivariantMonoidPowerSeries(emps, {emps.characters().one_element() : { 0 : 10, 1 : 1 }}, emps.action().filter_all())[1]
1
"""
try :
if not isinstance(k, tuple) :
raise ValueError
(ch, k) = k
if k not in self.parent().monoid() :
s = (ch, k)
ch = None
else :
s = k
except ValueError :
s = k
ch = None
try :
if not ch.parent() == self.parent().characters() :
ch = None
except AttributeError :
ch = None
if ch is None :
ns = self.non_zero_components()
if len(ns) == 0 :
return 0
elif len(ns) == 1 :
ch = ns[0]
else :
raise ValueError, "you must specify a character"
if not s in self.precision() :
raise ValueError, "%s out of bound" % (s,)
try :
return self.__coefficients[ch][s]
except KeyError :
(rs, g) = self.parent()._reduction_function()(s)
try :
return self.parent()._character_eval_function()(g, ch) \
* self.parent()._apply_function()(g, self.__coefficients[ch][rs])
except KeyError :
return self.parent().coefficient_domain().zero_element()
#===============================================================================
# EquivariantMonoidPowerSeries_moduleelement
#===============================================================================
class EquivariantMonoidPowerSeries_moduleelement ( EquivariantMonoidPowerSeries_abstract_nonlazy, ModuleElement ) :
"""
An element of a module of equivariant monoid power series.
"""
def __init__(self, parent, coefficients, precision, symmetrise,
cleanup_coefficients ) :
"""
INPUT:
- ``parent`` -- A ring or module of equivariant monoid power series.
- ``coefficients`` -- A dictionary with keys in the parent's monoid and values
in the parent coefficient domain.
- ``precision`` -- A filter for the parent's action.
- ``symmetrise`` -- A boolean (default: ``False``); If ``True`` every enty in
``coefficients`` will contribute to its whole orbit.
- ``cleanup_coefficients`` -- A boolean (default: ``False``); If ``True`` zero
coefficients will be erased from the dictionary.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_module import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: emps = EquivariantMonoidPowerSeriesModule( NNMonoid(), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", FreeModule(QQ, 2)) )
sage: h = EquivariantMonoidPowerSeries_moduleelement(emps, dict(), emps.action().zero_filter(), False, False)
"""
ModuleElement.__init__(self, parent)
EquivariantMonoidPowerSeries_abstract_nonlazy.__init__(self, parent, coefficients, precision, symmetrise,
cleanup_coefficients)
#===============================================================================
# EquivariantMonoidPowerSeries_algebraelement
#===============================================================================
class EquivariantMonoidPowerSeries_algebraelement ( EquivariantMonoidPowerSeries_abstract_nonlazy, AlgebraElement ) :
"""
An element of an algebra of equivariant monoid power series.
"""
def __init__(self, parent, coefficients, precision, symmetrise,
cleanup_coefficients ) :
"""
INPUT:
- ``parent`` -- A ring or module of equivariant monoid power series.
- ``coefficients`` -- A dictionary with keys in the parent's monoid and values
in the parent coefficient domain.
- ``precision`` -- A filter for the parent's action.
- ``symmetrise`` -- A boolean (default: ``False``); If ``True`` every enty in
``coefficients`` will contribute to its whole orbit.
- ``cleanup_coefficients`` -- A boolean (default: ``False``); If ``True`` zero
coefficients will be erased from the dictionary.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: emps = EquivariantMonoidPowerSeriesRing( NNMonoid(), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", QQ) )
sage: h = EquivariantMonoidPowerSeries_algebraelement(emps, dict(), emps.action().zero_filter(), False, False)
"""
AlgebraElement.__init__(self, parent)
EquivariantMonoidPowerSeries_abstract_nonlazy.__init__(self, parent, coefficients, precision, symmetrise,
cleanup_coefficients)
| Python |
"""
Modules of monoid power series and modules of equivariant monoid power series.
AUTHOR :
-- Martin Raum (2010 - 02 - 10) Initial version
"""
#===============================================================================
#
# Copyright (C) 2010 Martin Raum
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 3
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, see <http://www.gnu.org/licenses/>.
#
#===============================================================================
from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ambient import MonoidPowerSeriesAmbient_abstract,\
EquivariantMonoidPowerSeriesAmbient_abstract
from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import TrivialRepresentation
from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_functor import EquivariantMonoidPowerSeriesFunctor,\
MonoidPowerSeriesFunctor
from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import MonoidPowerSeriesRing, \
EquivariantMonoidPowerSeriesRing
from sage.modules.module import Module
from sage.rings.integer import Integer
from sage.structure.element import Element
_monoidpowerseries_module_cache = dict()
_equivariantmonoidpowerseries_module_cache = dict()
#===============================================================================
# MonoidPowerSeriesModule
#===============================================================================
def MonoidPowerSeriesModule(A, S) :
"""
Return the globally unique monoid power series ring with indices
in the filtered monoid `S` and coefficients in `A`.
INPUT:
- `A` -- A module.
- `S` -- A monoid as implemented in :class:~`fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids.NNMonoid`.
EXAMPLES::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_module import MonoidPowerSeriesModule
sage: mps = MonoidPowerSeriesModule(QQ, NNMonoid(False))
sage: mps is MonoidPowerSeriesModule(QQ, NNMonoid(False))
True
"""
global _monoidpowerseries_module_cache
key = (A, S)
try :
return _monoidpowerseries_module_cache[key]
except KeyError :
P = MonoidPowerSeriesModule_generic(A, S)
_monoidpowerseries_module_cache[key] = P
return P
#===============================================================================
# MonoidPowerSeriesModule_generic
#===============================================================================
class MonoidPowerSeriesModule_generic ( MonoidPowerSeriesAmbient_abstract, Module ) :
"""
Given some `K` module `A` and a monoid `S` filtered over
a net `\Lambda` construct a module of monoid power series.
Set `R = B[S]`. Then the projective limit of `R / R_\lambda` for
`\lambda \in \Lambda \rightarrow \infty` considered as a
`K` module is implemented by this class.
NOTE:
The implementation respects left and right modules.
"""
def __init__(self, A, S) :
"""
INPUT:
- `A` -- A module.
- `S` -- A monoid as implemented in :class:~`fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids.NNMonoid`.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_module import MonoidPowerSeriesModule_generic
sage: mps = MonoidPowerSeriesModule_generic(FreeModule(QQ,2), NNMonoid(False))
"""
Module.__init__(self, MonoidPowerSeriesRing(A.base_ring(), S))
MonoidPowerSeriesAmbient_abstract.__init__(self, A, S)
self.__coeff_gens = \
[ self._element_class(self, dict([(S.zero_element(), a)]),
self.monoid().filter_all() )
for a in A.gens() ]
def ngens(self) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_module import MonoidPowerSeriesModule_generic
sage: mps = MonoidPowerSeriesModule_generic(FreeModule(QQ,2), NNMonoid(False))
sage: mps.ngens()
2
"""
return len(self.__coeff_gens)
def gen(self, i = 0) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_module import MonoidPowerSeriesModule_generic
sage: mps = MonoidPowerSeriesModule_generic(FreeModule(QQ,2), NNMonoid(False))
sage: mps.gen()
Monoid power series in Module of monoid power series over NN
"""
return self.gens()[i]
def gens(self) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_module import MonoidPowerSeriesModule_generic
sage: mps = MonoidPowerSeriesModule_generic(FreeModule(QQ,2), NNMonoid(False))
sage: mps.gens()
[Monoid power series in Module of monoid power series over NN, Monoid power series in Module of monoid power series over NN]
"""
return self.__coeff_gens
def construction(self) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_module import MonoidPowerSeriesModule_generic
sage: mps = MonoidPowerSeriesModule_generic(FreeModule(QQ,2), NNMonoid(False))
sage: (f, a) = mps.construction()
sage: (f, a)
(MonoidPowerSeriesFunctor, Vector space of dimension 2 over Rational Field)
sage: f(a) == mps
True
"""
return MonoidPowerSeriesFunctor(self.monoid()), self.coefficient_domain()
def zero_element(self) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_module import MonoidPowerSeriesModule_generic
sage: mps = MonoidPowerSeriesModule_generic(FreeModule(QQ,2), NNMonoid(False))
sage: h = mps.zero_element()
"""
return self(0)
def _element_constructor_(self, x) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_module import MonoidPowerSeriesModule_generic
sage: mps = MonoidPowerSeriesModule_generic(FreeModule(QQ,2), NNMonoid(False))
sage: h = mps(0) # indirect doctest
sage: h = mps(int(0)) # indirect doctest
"""
if isinstance(x, int) and x == 0 :
return self._element_class( self, dict(),
self.monoid().filter_all() )
if isinstance(x, Element) and x.is_zero() :
P = x.parent()
if self.base_ring().base_ring().has_coerce_map_from(P) :
return self._element_class( self, dict(),
self.monoid().filter_all() )
return MonoidPowerSeriesAmbient_abstract._element_constructor_(self, x)
def _repr_(self) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_module import MonoidPowerSeriesModule_generic
sage: MonoidPowerSeriesModule_generic(FreeModule(QQ,2), NNMonoid(False))
Module of monoid power series over NN
"""
return "Module of monoid power series over " + self.monoid()._repr_()
def _latex_(self) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_module import MonoidPowerSeriesModule_generic
sage: latex(MonoidPowerSeriesModule_generic(FreeModule(QQ,2), NNMonoid(False)))
Module of monoid power series over $\NN$
"""
return "Module of monoid power series over " + self.monoid()._latex_()
###############################################################################
###############################################################################
###############################################################################
#===============================================================================
# EquivariantMonoidPowerSeriesModule
#===============================================================================
def EquivariantMonoidPowerSeriesModule(O, C, R) :
"""
Return the globally unique module of equivariant monoid power
over the monoid with action `O` with coefficients in the codomain `R`
with a representation and a set of virtual characters `C`.
INPUT:
- `O` -- A monoid with an action of a group; As implemented in
:class:~`fourier_expansion_framework.monoidpowerseries.NNMonoid`.
- `C` -- A monoid of characters; As implemented in ::class:~`fourier_expansion_framework.monoidpowerseries.CharacterMonoid_class`.
- `R` -- A representation on a module; As implemented
in :class:~`fourier_expansion_framework.monoidpowerseries.TrivialRepresentation`.
EXAMPLES::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_module import EquivariantMonoidPowerSeriesModule
sage: emps = EquivariantMonoidPowerSeriesModule(NNMonoid(True), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", FreeModule(QQ, 2)))
sage: emps is EquivariantMonoidPowerSeriesModule(NNMonoid(True), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", FreeModule(QQ, 2)))
True
"""
## TODO: Implement optional checking of the relation (*)
if O.group() != C.group() :
raise ValueError, "The action on S and the characters must have the same group"
if R.base_ring() != C.codomain() :
if C.codomain().has_coerce_map_from(R.base_ring()) :
K = C.codomain()
R = R.base_extend(K)
elif R.base_ring().has_coerce_map_from(C.codomain()) :
K = R.base_ring()
else :
from sage.categories.pushout import pushout
try :
K = pushout(C.codomain(), R.base_ring())
R = R.base_extend(K)
except :
raise ValueError, "character codomain and representation base ring have no common extension"
global _equivariantmonoidpowerseries_module_cache
key = (O, C, R)
try :
return _equivariantmonoidpowerseries_module_cache[key]
except KeyError :
P = EquivariantMonoidPowerSeriesModule_generic(O, C, R)
_equivariantmonoidpowerseries_module_cache[key] = P
return P
#===============================================================================
# EquivariantMonoidPowerSeriesModule_generic
#===============================================================================
class EquivariantMonoidPowerSeriesModule_generic ( EquivariantMonoidPowerSeriesAmbient_abstract, Module ) :
"""
Given some module `A`, a monoid `S` filtered over some originated
net `\Lambda` such that all induced submonoids are finite, a group `G`, a
semigroup `C` with a map `c \rightarrow \mathrm{Hom}(G, Aut_K(A))`, a
homomorphism `\phi : G -> Aut(S)` and a homomorphism `\eta : G -> C`, where
`K` is the base ring of `A`.
Suppose for every `c, c'` in `C`, and `g` in `G`, and `a, a'` in `A` we have
`(c c') (g) (a a') = c(g)(a) c'(g)(a')`.
Set `R = B[C][S]`. Then the projective limit of
`R / R_\lambda` for `\lambda \in \Lambda \rightarrow \infinity` is a
`K`-module.
The set of generators is the set of generators of the underlying
monoidal power series module and does not take into account the
group action
"""
def __init__(self, O, C, R) :
"""
INPUT:
- `O` -- A monoid with an action of a group; As implemented in
:class:~`fourier_expansion_framework.monoidpowerseries.NNMonoid`.
- `C` -- A monoid of characters; As implemented in ::class:~`fourier_expansion_framework.monoidpowerseries.CharacterMonoid_class`.
- `R` -- A representation on a module; As implemented
in :class:~`fourier_expansion_framework.monoidpowerseries.TrivialRepresentation`.
EXAMPLES::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_module import EquivariantMonoidPowerSeriesModule
sage: emps = EquivariantMonoidPowerSeriesModule_generic(NNMonoid(True), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", FreeModule(QQ, 2))) # indirect doctest
"""
# If the representation O respects the monoid structure of S
# the base ring should be the associated power series ring.
if O.is_monoid_action() :
Module.__init__(self, EquivariantMonoidPowerSeriesRing(O,C,TrivialRepresentation(R.group(), R.base_ring())))
else :
Module.__init__(self, R.codomain())
EquivariantMonoidPowerSeriesAmbient_abstract.__init__(self, O, C, R)
self.__coeff_gens = \
[self._element_class( self,
dict([( C.one_element(), dict([(self.monoid().zero_element(), a)]) )]),
self.monoid().filter_all() )
for a in self.coefficient_domain().gens()]
def ngens(self) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_module import EquivariantMonoidPowerSeriesModule
sage: emps = EquivariantMonoidPowerSeriesModule_generic(NNMonoid(True), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", FreeModule(QQ, 2)))
sage: emps.ngens()
2
"""
return len(self.__coeff_gens)
def gen(self, i = 0) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_module import EquivariantMonoidPowerSeriesModule
sage: emps = EquivariantMonoidPowerSeriesModule_generic(NNMonoid(True), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", FreeModule(QQ, 2)))
sage: emps.gen()
Equivariant monoid power series in Module of equivariant monoid power series over NN
"""
return self.gens()[i]
def gens(self) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_module import EquivariantMonoidPowerSeriesModule
sage: emps = EquivariantMonoidPowerSeriesModule_generic(NNMonoid(True), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", FreeModule(QQ, 2)))
sage: emps.gens()
[Equivariant monoid power series in Module of equivariant monoid power series over NN, Equivariant monoid power series in Module of equivariant monoid power series over NN]
"""
return self.__coeff_gens
def construction(self) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_module import EquivariantMonoidPowerSeriesModule_generic
sage: emps = EquivariantMonoidPowerSeriesModule_generic(NNMonoid(True), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", FreeModule(QQ, 2)))
sage: (f, a) = emps.construction()
sage: (f, a)
(EquivariantMonoidPowerSeriesFunctor, Rational Field)
sage: f(a) == emps
True
"""
return EquivariantMonoidPowerSeriesFunctor(self.action(), self.characters(), self.representation()), \
self.coefficient_domain().base_ring()
def zero_element(self) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_module import EquivariantMonoidPowerSeriesModule
sage: emps = EquivariantMonoidPowerSeriesModule_generic(NNMonoid(True), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", FreeModule(QQ, 2)))
sage: h = emps.zero_element()
"""
return self(0)
def _element_constructor_(self, x) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_module import EquivariantMonoidPowerSeriesModule
sage: emps = EquivariantMonoidPowerSeriesModule_generic(NNMonoid(True), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", FreeModule(QQ, 2)))
sage: h = emps(0) # indirect doctest
sage: h = emps(int(0)) # indirect doctest
"""
if isinstance(x, int) and x == 0 :
return self._element_class( self,
dict( [(self.characters().one_element(), dict())] ),
self.action().filter_all() )
elif isinstance(x, Element) and x.is_zero() :
P = x.parent()
if self.action().is_monoid_action() and \
self.base_ring().base_ring().has_coerce_map_from(P) or \
not self.action().is_monoid_action() and \
self.base_ring().has_coerce_map_from(P) :
return self._element_class( self,
dict( [(self.characters().one_element(), dict())] ),
self.action().filter_all() )
return EquivariantMonoidPowerSeriesAmbient_abstract._element_constructor_(self, x)
def _repr_(self) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_module import EquivariantMonoidPowerSeriesModule
sage: EquivariantMonoidPowerSeriesModule_generic(NNMonoid(True), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", FreeModule(QQ, 2)))
Module of equivariant monoid power series over NN
"""
return "Module of equivariant monoid power series over " + self.monoid()._repr_()
def _latex_(self) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_module import EquivariantMonoidPowerSeriesModule
sage: latex( EquivariantMonoidPowerSeriesModule_generic(NNMonoid(True), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", FreeModule(QQ, 2))) )
Module of equivariant monoid power series over $\NN$
"""
return "Module of equivariant monoid power series over " + self.monoid()._latex_()
| Python |
"""
Ambients of monoid power series and ambients of equivariant monoid power series.
AUTHOR :
-- Martin Raum (2010 - 02 - 10) Initial version
"""
#===============================================================================
#
# Copyright (C) 2010 Martin Raum
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 3
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, see <http://www.gnu.org/licenses/>.
#
#===============================================================================
from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import MonoidPowerSeries, EquivariantMonoidPowerSeries
from sage.rings.all import Integer
from sage.structure.element import Element
#===============================================================================
# MonoidPowerSeriesAmbient_abstract
#===============================================================================
class MonoidPowerSeriesAmbient_abstract :
"""
Given some `K` module or algebra `A` and a monoid `S` filtered over
a net `\Lambda` construct a module or ring of monoid power series.
Set `R = B[S]`. Then the projective limit of `R / R_\lambda` for
`\lambda \in \Lambda \rightarrow \infty` considered as a
`K` module or algebra is implemented by this class.
"""
def __init__(self, A, S) :
"""
INPUT:
- `A` -- A ring or module.
- `S` -- A monoid as implemented in :class:~`from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids.NNMonoid`.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ambient import MonoidPowerSeriesAmbient_abstract
sage: mps = MonoidPowerSeriesAmbient_abstract(QQ, NNMonoid(False))
"""
self.__monoid = S
self._set_multiply_function()
self.__coefficient_domain = A
if not hasattr(self, "_element_class") :
self._element_class = MonoidPowerSeries
def is_exact(self) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import MonoidPowerSeriesRing
sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
sage: mps.is_exact()
False
"""
return False
def monoid(self) :
"""
Return the index monoid of ``self``.
OUTPUT:
A monoid.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ambient import MonoidPowerSeriesAmbient_abstract
sage: mps = MonoidPowerSeriesAmbient_abstract(QQ, NNMonoid(False))
sage: mps.monoid()
NN
"""
return self.__monoid
def coefficient_domain(self) :
"""
The coefficient domain of ``self``.
OUTPUT:
A ring or module.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ambient import MonoidPowerSeriesAmbient_abstract
sage: mps = MonoidPowerSeriesAmbient_abstract(QQ, NNMonoid(False))
sage: mps.coefficient_domain()
Rational Field
sage: mps = MonoidPowerSeriesAmbient_abstract(FreeModule(ZZ, 3), NNMonoid(False))
sage: mps.coefficient_domain()
Ambient free module of rank 3 over the principal ideal domain Integer Ring
"""
return self.__coefficient_domain
def _multiply_function(self) :
"""
Return the currect multiply function.
The standard implementation of elements asks its parent to
provide a multiplication function, which has the following signature:
multiply function INPUT:
- `k` -- Element of the index monoid; An index.
- ``lcoeffs`` -- A dictionary; Coefficient dictionary of the left factor.
- ``rcoeffs`` -- A dictionary; Coefficient dictionary of the right factor.
- ``null`` -- An element of a ring or module; An initialized zero object
of the coefficient domain.
multiply function OUTPUT:
A ring element. The `k`-th coefficent of the product ``left * right``.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import MonoidPowerSeriesRing
sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
sage: h = mps._multiply_function()
"""
return self.__multiply_function
def _set_multiply_function(self, f = None) :
"""
Set the multiply function that is decribed in :meth:~`._multiply_function`.
If `f` is ``None`` an iteration over the decompositions in the
monoid is used.
INPUT:
- `f` -- A function or ``None`` (default: ``None``).
OUTPUT:
``None``.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import MonoidPowerSeriesRing
sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
sage: e = MonoidPowerSeries( mps, { 4 : 1, 5 : 2}, mps.monoid().filter_all() )
sage: h = e * e # indirect doctest
sage: h = lambda : None
sage: mps._set_multiply_function(h)
sage: h == mps._multiply_function()
True
"""
if not f is None :
self.__multiply_function = f
return
def mul(s, lcoeffs, rcoeffs, res) :
for s1, s2 in self.__monoid.decompositions(s) :
try :
v1 = lcoeffs[s1]
v2 = rcoeffs[s2]
except KeyError :
continue
res += v1 * v2
return res
#! def mul
self.__multiply_function = mul
def _coerce_map_from_(self, other) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import MonoidPowerSeriesRing
sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
sage: mps.has_coerce_map_from( MonoidPowerSeriesRing(ZZ, NNMonoid(False)) ) # indirect doctest
True
"""
if isinstance(other, MonoidPowerSeriesAmbient_abstract) :
if self.monoid() == other.monoid() and \
self.coefficient_domain().has_coerce_map_from(other.coefficient_domain()) :
from sage.structure.coerce_maps import CallableConvertMap
return CallableConvertMap(other, self, self._element_constructor_)
def _element_constructor_(self, x) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import MonoidPowerSeriesRing
sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
sage: h = mps(dict()) # indirect doctest
sage: h = mps(h) # indirect doctest
"""
if isinstance(x, dict) :
return self._element_class(self, x, self.monoid().filter_all())
if isinstance(x, Element) :
P = x.parent()
if P is self :
return x
elif isinstance(P, MonoidPowerSeriesAmbient_abstract) :
if self.coefficient_domain() is P.coefficient_domain() :
return self._element_class( self,
x.coefficients(), x.precision() )
else :
coefficient_domain = self.coefficient_domain()
return self._element_class( self,
dict( (k,coefficient_domain(c)) for (k,c) in x.coefficients().iteritems() ),
x.precision() )
raise (TypeError, "Cannot construct an element of %s" % (x))
def __cmp__(self, other) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ambient import MonoidPowerSeriesAmbient_abstract
sage: mps = MonoidPowerSeriesAmbient_abstract(QQ, NNMonoid(False))
sage: mps2 = MonoidPowerSeriesAmbient_abstract(ZZ, NNMonoid(False))
sage: mps == MonoidPowerSeriesAmbient_abstract(QQ, NNMonoid(False))
True
sage: mps == mps2
False
"""
c = cmp(type(self), type(other))
if c == 0 :
c = cmp(self.coefficient_domain(), other.coefficient_domain())
if c == 0 :
c = cmp(self.monoid(), other.monoid())
return c
###############################################################################
###############################################################################
###############################################################################
#===============================================================================
# EquivariantMonoidPowerSeriesAmbient_abstract
#===============================================================================
class EquivariantMonoidPowerSeriesAmbient_abstract :
"""
Given some ring or module `A`, a monoid `S` filtered over some originated
net `\Lambda` such that all induced submonoids are finite, a group `G`, a
semigroup `C` with a map `c \rightarrow \mathrm{Hom}(G, Aut_K(A))`, a
homomorphism `\phi : G -> Aut(S)` and a homomorphism `\eta : G -> C`, where
`K` is the base ring of `A`.
Suppose for every `c, c'` in `C`, and `g` in `G`, and `a, a'` in `A` we have
`(c c') (g) (a a') = c(g)(a) c'(g)(a')`.
Set `R = B[C][S]`. Then the projective limit of
`R / R_\lambda` for `\lambda \in \Lambda \rightarrow \infinity` is a
`K`-algebra or -module.
"""
def __init__(self, O, C, R) :
"""
INPUT:
- `O` -- A monoid with an action of a group; As implemented in
:class:~`fourier_expansion_framework.monoidpowerseries.NNMonoid`.
- `C` -- A monoid of characters; As implemented in ::class:~`fourier_expansion_framework.monoidpowerseries.CharacterMonoid_class`.
- `R` -- A representation on an algebra or module; As implemented
in :class:~`fourier_expansion_framework.monoidpowerseries.TrivialRepresentation`.
EXAMPLES::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import EquivariantMonoidPowerSeriesRing
sage: emps = EquivariantMonoidPowerSeriesRing(NNMonoid(True), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", QQ)) # indirect doctest
"""
self.__action = O
self.__characters = C
self.__representation = R
self.__coefficient_domain = R.codomain()
self.__monoid = O.monoid()
self._set_reduction_function()
self._set_character_eval_function()
self._set_apply_function()
self._set_multiply_function()
if not hasattr(self, "_element_class") :
self._element_class = EquivariantMonoidPowerSeries
def is_exact(self) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import EquivariantMonoidPowerSeriesRing
sage: emps = EquivariantMonoidPowerSeriesRing(NNMonoid(True), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", QQ))
sage: emps.is_exact()
False
"""
return False
def coefficient_domain(self) :
"""
The domain of coefficients.
OUTPUT:
Either a ring or a module.
EXAMPLES::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import EquivariantMonoidPowerSeriesRing
sage: emps = EquivariantMonoidPowerSeriesRing(NNMonoid(True), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", QQ))
sage: emps.coefficient_domain() == QQ
True
"""
return self.__coefficient_domain
def group(self) :
"""
The group acting on the index monoid.
OUTPUT:
Of arbitrary type.
NOTE:
The framework might change at a later time such that this
function returns a group.
EXAMPLES::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import EquivariantMonoidPowerSeriesRing
sage: emps = EquivariantMonoidPowerSeriesRing(NNMonoid(True), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", QQ))
sage: emps.group()
'1'
"""
return self.__action.group()
def monoid(self) :
"""
The index monoid.
OUTPUT:
A monoid as implemented in :class:~`fourier_expansion_framework.monoidpowerseries.NNMonoid`.
EXAMPLES::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import EquivariantMonoidPowerSeriesRing
sage: emps = EquivariantMonoidPowerSeriesRing(NNMonoid(True), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", QQ))
sage: emps.monoid()
NN
"""
return self.__action.monoid()
def action(self) :
"""
The index monoid with the action of a group.
OUTPUT:
A monoid with action as implemented in :class:~`fourier_expansion_framework.monoidpowerseries.NNMonoid`.
EXAMPLES::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import EquivariantMonoidPowerSeriesRing
sage: emps = EquivariantMonoidPowerSeriesRing(NNMonoid(True), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", QQ))
sage: emps.action()
NN with action
"""
return self.__action
def characters(self) :
"""
The monoid of characters associated to the monoid index' group.
OUTPUT:
A monoid as implemented in :class:~`fourier_expansion_framework.monoidpowerseries.CharacterMonoid_class`.
EXAMPLES::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import EquivariantMonoidPowerSeriesRing
sage: emps = EquivariantMonoidPowerSeriesRing(NNMonoid(True), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", QQ))
sage: emps.characters()
Character monoid over Trivial monoid
"""
return self.__characters
def representation(self) :
"""
The representation on the coefficient domain.
OUTPUT:
A representation as implemented in :class:~`fourier_expansion_framework.monoidpowerseries.TrivialRepresentation`.
EXAMPLES::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import EquivariantMonoidPowerSeriesRing
sage: emps = EquivariantMonoidPowerSeriesRing(NNMonoid(True), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", QQ))
sage: emps.representation()
Trivial representation of 1 on Rational Field
"""
return self.__representation
def _reduction_function(self) :
"""
The reduction function accepts an index `s`. It returns the pair
reduction `(rs = g^-1 s, g)` of `s` with a group element `g`.
OUTPUT:
A function.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import EquivariantMonoidPowerSeriesRing
sage: emps = EquivariantMonoidPowerSeriesRing(NNMonoid(True), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", QQ))
sage: red_function = emps._reduction_function()
sage: red_function(2)
(2, 1)
"""
return self.__reduction_function
def _set_reduction_function(self, f = None) :
"""
Set the reduction function, explained in :class:~`._reduction_function`.
If `f` is ``None`` the reduction function of the action is used.
INPUT:
- `f` -- A function or ``None`` (default: ``None``).
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import EquivariantMonoidPowerSeriesRing
sage: emps = EquivariantMonoidPowerSeriesRing(NNMonoid(True), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", QQ))
sage: h = lambda : None
sage: emps._set_reduction_function(h)
sage: h == emps._reduction_function()
True
sage: emps._set_reduction_function() ## This is important since emps is globally unique
"""
if not f is None :
self.__reduction_function = f
return
self.__reduction_function = self.__action._reduction_function()
def _character_eval_function(self) :
"""
The character evaluation function. It accepts a character `c` and
a group element `g` and returns `c(g)`.
OUTPUT:
A function.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import EquivariantMonoidPowerSeriesRing
sage: emps = EquivariantMonoidPowerSeriesRing(NNMonoid(True), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", QQ))
sage: eval_func = emps._character_eval_function()
sage: eval_func(emps.characters().one_element(), 1)
1
"""
return self.__character_eval_function
def _set_character_eval_function(self, f = None) :
"""
Set the character evaluation function. If `f` is ``None``, the
implementation of the character monoid is used.
INPUT:
- `f` -- A function or ``None`` (default: ``None``).
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import EquivariantMonoidPowerSeriesRing
sage: emps = EquivariantMonoidPowerSeriesRing(NNMonoid(True), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", QQ))
sage: h = lambda c,g: 1
sage: emps._set_character_eval_function(h)
sage: h == emps._character_eval_function()
True
sage: emps._set_character_eval_function() ## This is important since emps is globally unique
"""
if not f is None :
self.__character_eval_function = f
return
self.__character_eval_function = self.__characters._eval_function()
def _apply_function(self) :
"""
The apply function. It applies a group element `g` to an element `v`
of the coefficient domain, the base space of the representation.
OUTPUT:
A function.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import EquivariantMonoidPowerSeriesRing
sage: emps = EquivariantMonoidPowerSeriesRing(NNMonoid(True), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", QQ))
sage: app_func = emps._apply_function()
sage: app_func(1, 1/2)
1/2
"""
return self.__apply_function
def _set_apply_function(self, f = None) :
"""
Set the apply function. If `f` is ``None``, the implementation of
the representation is used.
INPUT:
- `f` -- A function or ``None`` (default: ``None``).
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import EquivariantMonoidPowerSeriesRing
sage: emps = EquivariantMonoidPowerSeriesRing(NNMonoid(True), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", QQ))
sage: h = lambda : None
sage: emps._set_apply_function(h)
sage: h == emps._apply_function()
True
sage: emps._set_apply_function() ## This is important since emps is globally unique
"""
if not f is None :
self.__apply_function = f
return
self.__apply_function = self.__representation._apply_function()
def _multiply_function(self) :
"""
The standard implementation of elements of this ring will ask its
parent to provide multplication function, which has the
following signature:
multiply function INPUT :
- `k` -- An index.
- ``lcoeffs`` -- A dictionary; The coefficient dictionary of the left factor.
- ``rcoeffs`` -- A dictionary; The coefficient dictionary of the right factor.
- ``lch`` -- A character; The character of the left factor.
- ``rch`` -- A character; The character of the right factor.
- ``null`` -- A ring or module element; TA initialized zero object of
the coefficient domain.
multiply function OUTPUT :
A ring or module element. The `k`-th coefficent of the product
``left * right``, where the power series transform with character
``lch`` and ``rch`` respectively under the action of the power series'
symmetry group.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import EquivariantMonoidPowerSeriesRing
sage: emps = EquivariantMonoidPowerSeriesRing(NNMonoid(True), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", QQ))
sage: h = emps._multiply_function()
sage: e = emps( {emps.characters().one_element() : {4 : 3, 5 : 3} } )
sage: (e * e).coefficients() # indirect doctest
{8: 9, 9: 18, 10: 9}
"""
return self.__multiply_function
def _set_multiply_function(self, f = None) :
"""
Set the multiply function. If `f` is ``None`` an iteration over the
decompositions in the monoid is used.
INPUT:
- `f` -- A function or ``None`` (default: ``None``).
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import EquivariantMonoidPowerSeriesRing
sage: emps = EquivariantMonoidPowerSeriesRing(NNMonoid(True), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", QQ))
sage: h = lambda : None
sage: emps._set_multiply_function(h)
sage: h == emps._multiply_function()
True
"""
if not f is None :
self.__multiply_function = f
return
def mul(s, lcoeffs, rcoeffs, cl, cr, res) :
reduction = self._reduction_function()
apply = self._apply_function()
character_ev = self._character_eval_function()
rs, g = reduction(s)
for s1, s2 in self.__monoid.decompositions(rs) :
rs1, g1 = reduction(s1)
rs2, g2 = reduction(s2)
try :
v1 = lcoeffs[rs1]
v2 = rcoeffs[rs2]
except KeyError :
continue
v1 = apply(g1, v1)
v2 = apply(g2, v2)
res += (character_ev(g1, cl) * character_ev(g2, cr)) * v1 * v2
return character_ev(g, cl*cr) * apply(g, res)
#! def mul
self.__multiply_function = mul
def _coerce_map_from_(self, other) :
"""
TODO:
This is a stub. The dream is that representations know about
compatible coercions and so would actions and characters. Then
every equivariant monoid power series ring would be a functorial
construction in all three parameters (The functor would then be
applied to a representation within a universe of representations).
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import EquivariantMonoidPowerSeriesRing
sage: emps = EquivariantMonoidPowerSeriesRing(NNMonoid(True), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", QQ))
sage: emps.has_coerce_map_from( EquivariantMonoidPowerSeriesRing(NNMonoid(True), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", ZZ)) ) # indirect doctest
True
"""
if isinstance(other, EquivariantMonoidPowerSeriesAmbient_abstract) :
if self.action() == other.action() and \
self.characters() == other.characters() :
if self.representation().extends(other.representation()) :
from sage.structure.coerce_maps import CallableConvertMap
return CallableConvertMap(other, self, self._element_constructor_)
def _element_constructor_(self, x) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import MonoidPowerSeriesRing, EquivariantMonoidPowerSeriesRing
sage: emps = EquivariantMonoidPowerSeriesRing(NNMonoid(True), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", QQ))
sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
sage: h = emps(dict()) # indirect doctest
sage: h = emps(1)
sage: h = emps(h)
sage: h = emps(mps(1))
"""
if isinstance(x, Element) :
P = x.parent()
if P is self :
return x
elif isinstance(P, EquivariantMonoidPowerSeriesAmbient_abstract) :
if self.coefficient_domain() is P.coefficient_domain() :
return self._element_class( self,
x.coefficients(True), x.precision() )
else :
coefficient_domain = self.coefficient_domain()
return self._element_class( self,
dict( (ch, dict( (k,coefficient_domain(c)) for (k,c) in coeffs.iteritems()) )
for (ch, coeffs) in x.coefficients(True).iteritems() ),
x.precision() )
elif isinstance(P, MonoidPowerSeriesAmbient_abstract) :
if self.coefficient_domain() is P.coefficient_domain() :
return self._element_class(
self, dict([(self.__characters.one_element(),
x.coefficients())]),
self.action().filter(x.precision()),
symmetrise = True )
else :
return self._element_class(
self, dict([(self.__characters.one_element(),
dict( (k,coefficient_domain(c)) for (k,c) in x.coefficients().iteritems()) )]),
self.action().filter(x.precision()),
symmetrise = True )
elif isinstance(x, dict) :
if len(x) != 0 :
try :
if x.keys()[0].parent() is self.__characters :
return self._element_class( self,
x, self.action().filter_all() )
except AttributeError :
pass
return self._element_class( self,
dict([(self.__characters.one_element(), x)]),
self.action().filter_all() )
raise TypeError, "can't convert %s into %s" % (x, self)
def __cmp__(self, other) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ambient import EquivariantMonoidPowerSeriesAmbient_abstract
sage: emps = EquivariantMonoidPowerSeriesAmbient_abstract(NNMonoid(True), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", QQ))
sage: emps == EquivariantMonoidPowerSeriesAmbient_abstract(NNMonoid(True), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", QQ))
True
sage: emps2 = EquivariantMonoidPowerSeriesAmbient_abstract(NNMonoid(True), TrivialCharacterMonoid("1", ZZ), TrivialRepresentation("1", ZZ))
sage: emps == emps2
False
"""
c = cmp(type(self), type(other))
if c == 0 :
c = cmp(self.action(), other.action())
if c == 0 :
c = cmp(self.representation(), other.representation())
if c == 0 :
c = cmp(self.characters(), other.characters())
return c
| Python |
from monoidpowerseries_ring import MonoidPowerSeriesRing, \
EquivariantMonoidPowerSeriesRing
from monoidpowerseries_module import MonoidPowerSeriesModule, \
EquivariantMonoidPowerSeriesModule
from monoidpowerseries_element import MonoidPowerSeries, EquivariantMonoidPowerSeries | Python |
"""
Finite dimensional submodules of a ring or module of graded expansions.
AUTHOR :
-- Martin Raum (2009 - 07 - 27) Initial version
"""
#===============================================================================
#
# Copyright (C) 2009 Martin Raum
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 3
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, see <http://www.gnu.org/licenses/>.
#
#===============================================================================
from psage.modform.fourier_expansion_framework.gradedexpansions.expansion_lazy_evaluation import LazyFourierExpansionEvaluation
from psage.modform.fourier_expansion_framework.gradedexpansions.expansion_module import ExpansionModule_abstract
from psage.modform.fourier_expansion_framework.gradedexpansions.expansion_module import ExpansionModule_generic, ExpansionModule_ambient_pid, \
ExpansionModule_submodule_pid, ExpansionModuleVector_generic
from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ambient import GradedExpansionAmbient_abstract
from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ambient import MonoidPowerSeriesAmbient_abstract
from sage.categories.pushout import pushout
from sage.interfaces.magma import magma
from sage.matrix.constructor import matrix
from sage.misc.cachefunc import cached_method
from sage.misc.flatten import flatten
from sage.misc.latex import latex
from sage.misc.misc import mul
from sage.misc.misc import union
from sage.modules.free_module import FreeModule, FreeModule_generic, \
FreeModule_ambient_pid, FreeModule_submodule_pid
from sage.modules.free_module import is_FreeModule
from sage.modules.free_module_element import FreeModuleElement_generic_dense
from sage.modules.free_module_element import vector
from sage.rings.arith import random_prime
from sage.rings.integer_ring import ZZ
from sage.rings.number_field.order import Order as NumberFieldOrder
from sage.rings.padics.factory import Qp
from sage.rings.principal_ideal_domain import PrincipalIdealDomain
from sage.rings.rational_field import QQ
from sage.rings.ring import Ring
from sage.structure.element import Element
from sage.structure.sequence import Sequence
#===============================================================================
# GradedExpansionSubmodule
#===============================================================================
def GradedExpansionSubmodule(arg1, arg2) :
"""
A submodule of either a graded ring, module or submodule.
INPUT (first possibility):
- ``arg1`` -- An instance of :class:~`fourier_expansion_framework.gradedexpansions.gradedexpansion_ambient.GradedExpansionAmbient_abstract`.
- ``arg2`` -- A tuple, list or sequence of elements of ``arg1``.
INPUT (second possibility):
- ``arg1`` -- An instance of :class:~`.GradedExpansionSubmodule_ambient_pid` or :class:~`.GradedExpansionSubmodule_submodule_pid`.
- ``arg2`` -- A tuple, list or sequence of elements of ``arg1``.
NOTE:
The base ring of the graded expansion ambient must be an integral domain.
OUTPUT:
An instance of :class:~`.GradedExpansionSubmodule_abstract`.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_module import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_module import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_submodule import *
sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
sage: ger = GradedExpansionRing_class(None, Sequence([MonoidPowerSeries(mps, {1 : 4, 2 : 3}, mps.monoid().filter_all()), MonoidPowerSeries(mps, {1 : 1, 2 : 3}, mps.monoid().filter_all()), MonoidPowerSeries(mps, {2 : 1, 3: 6, 4 : 9}, mps.monoid().filter_all())]), PolynomialRing(QQ, ['a', 'b', 'c']).ideal(0), DegreeGrading((1,2,3)))
sage: sm = GradedExpansionSubmodule(ger, [ger.0, ger.1])
sage: sm = GradedExpansionSubmodule(ger, (ger.0, ger.1))
sage: sm = GradedExpansionSubmodule(ger, Sequence([ger.0, ger.1]))
sage: sm2 = GradedExpansionSubmodule(sm, [sm.0])
sage: m = FreeModule(QQ, 3)
sage: mpsm = MonoidPowerSeriesModule(m, NNMonoid(False))
sage: mps = mpsm.base_ring()
sage: ger = GradedExpansionModule_class(None, Sequence([MonoidPowerSeries(mpsm, {1 : m([1,2,3]), 2 : m([3,-3,2])}, mpsm.monoid().filter(4)), MonoidPowerSeries(mpsm, {1 : m([2,-1,-1]), 2 : m([1,0,0])}, mpsm.monoid().filter(4))]), PolynomialRing(ZZ, ['a', 'b']).ideal(0), DegreeGrading((1,2)))
sage: sm = GradedExpansionSubmodule(ger, [ger.0])
"""
if isinstance(arg1, GradedExpansionAmbient_abstract) :
base_ring = arg1.relations().base_ring()
if base_ring.is_field() or \
isinstance(base_ring, PrincipalIdealDomain) or \
isinstance(base_ring, NumberFieldOrder) \
and base_ring.is_maximal() and base_ring.class_number() == 1 :
return GradedExpansionSubmodule_ambient_pid(arg1, arg2)
else :
return GradedExpansionSubmodule_generic(arg1, arg2, len(arg2))
elif isinstance(arg1, GradedExpansionSubmodule_ambient_pid) \
or isinstance(arg1, GradedExpansionSubmodule_submodule_pid) :
return GradedExpansionSubmodule_submodule_pid(arg1, arg2)
raise ValueError( "Cannot construct a new subspace from %s, %s" % (arg1, arg2) )
#===============================================================================
# GradedExpansionSubmodule_abstract
#===============================================================================
class GradedExpansionSubmodule_abstract ( ExpansionModule_abstract ) :
"""
Abstract implementation of a finite dimensional module of graded expansions
within an ambient.
SEE:
:class:~`fourier_expansion_framework.gradedexpansions.gradedexpansion_ambient.GradedExpansion_ambient`.
"""
def __init__(self, graded_ambient, basis, degree, **kwds) :
"""
INPUT:
- ``graded_ambient`` -- An instance of :class:~`fourier_expansion_framework.gradedexpansions.gradedexpansion_ambient.GradedExpansionAmbient_abstract`.
- ``basis`` -- A tuple, list or sequence of elements of the graded ambient.
- ``degree`` -- An integer; The degree of the module within its ambient module.
NOTE:
The base ring of the graded expansion ambient must be an integral domain.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_module import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_module import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_submodule import *
sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
sage: ger = GradedExpansionRing_class(None, Sequence([MonoidPowerSeries(mps, {1 : 4, 2 : 3}, mps.monoid().filter_all()), MonoidPowerSeries(mps, {1 : 1, 2 : 3}, mps.monoid().filter_all()), MonoidPowerSeries(mps, {2 : 1, 3: 6, 4 : 9}, mps.monoid().filter_all())]), PolynomialRing(QQ, ['a', 'b', 'c']).ideal(0), DegreeGrading((1,2,3)))
sage: sm = GradedExpansionSubmodule_abstract(ger, Sequence([ger.0, ger.1]), 3)
sage: sm = GradedExpansionSubmodule_abstract(ger, Sequence([ger.0, ger.1]), 2, no_expansion_init = True)
sage: m = FreeModule(QQ, 3)
sage: mpsm = MonoidPowerSeriesModule(m, NNMonoid(False))
sage: mps = mpsm.base_ring()
sage: ger = GradedExpansionModule_class(None, Sequence([MonoidPowerSeries(mpsm, {1 : m([1,2,3]), 2 : m([3,-3,2])}, mpsm.monoid().filter(4)), MonoidPowerSeries(mpsm, {1 : m([2,-1,-1]), 2 : m([1,0,0])}, mpsm.monoid().filter(4))]), PolynomialRing(ZZ, ['a', 'b']).ideal(0), DegreeGrading((1,2)))
sage: sm = GradedExpansionSubmodule_abstract(ger, [ger.0], 1)
"""
self.__graded_ambient = graded_ambient
self.__basis_in_graded_ambient = basis
if not "no_expansion_init" in kwds or not kwds["no_expansion_init"] :
if graded_ambient.fourier_expansion_precision().is_infinite() or isinstance(self.__graded_ambient.fourier_ring(), MonoidPowerSeriesAmbient_abstract) :
ExpansionModule_abstract.__init__(self, Sequence( map( lambda b: b.fourier_expansion(), basis ),
universe = graded_ambient.fourier_ring() ))
else :
ExpansionModule_abstract.__init__(self, Sequence( map( lambda b: LazyFourierExpansionEvaluation( graded_ambient.fourier_ring(), b,
graded_ambient.fourier_expansion_precision() ),
basis ),
universe = graded_ambient.fourier_ring(), check = False ))
def graded_ambient(self) :
"""
The graded ambientm, namely, the graded ring or module
``self`` is a submodule of.
OUTPUT:
An instance of :class:~`fourier_expansion_framework.gradedexpansions.gradedexpansion_ambient.GradedExpansionAmbient_abstract`.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_module import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_module import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_submodule import *
sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
sage: ger = GradedExpansionRing_class(None, Sequence([MonoidPowerSeries(mps, {1 : 4, 2 : 3}, mps.monoid().filter_all()), MonoidPowerSeries(mps, {1 : 1, 2 : 3}, mps.monoid().filter_all()), MonoidPowerSeries(mps, {2 : 1, 3: 6, 4 : 9}, mps.monoid().filter_all())]), PolynomialRing(QQ, ['a', 'b', 'c']).ideal(0), DegreeGrading((1,2,3)))
sage: sm = GradedExpansionSubmodule_abstract(ger, Sequence([ger.0, ger.1]), 3)
sage: sm.graded_ambient() is ger
True
"""
return self.__graded_ambient
def _basis_in_graded_ambient(self) :
"""
A basis for ``self`` in terms of elements of the graded ambient.
OUTPUT:
A sequence of elements of the graded ambient.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_module import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_module import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_submodule import *
sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
sage: ger = GradedExpansionRing_class(None, Sequence([MonoidPowerSeries(mps, {1 : 4, 2 : 3}, mps.monoid().filter_all()), MonoidPowerSeries(mps, {1 : 1, 2 : 3}, mps.monoid().filter_all()), MonoidPowerSeries(mps, {2 : 1, 3: 6, 4 : 9}, mps.monoid().filter_all())]), PolynomialRing(QQ, ['a', 'b', 'c']).ideal(0), DegreeGrading((1,2,3)))
sage: sm = GradedExpansionSubmodule_abstract(ger, Sequence([ger.0, ger.1]), 3)
sage: sm._basis_in_graded_ambient() == Sequence([ger.0, ger.1])
True
"""
return self.__basis_in_graded_ambient
@cached_method
def _reduced_basis_polynomials(self, coerce_to = None) :
"""
A list of reduced polynomials associated to the basis of ``self``
within the graded ambient. If coerce_to is not None, these elements
will first be coerced into ``coerce_to`` and the resulting polynomials
will be returned.
INPUT:
- ``coerce_to`` -- A graded ambient or ``None`` (default: ``None``);
See the discription above.
OUTPUT:
A Sequence of polynomials.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_module import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_module import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_submodule import *
sage: K.<rho> = CyclotomicField(6)
sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
sage: P.<a, b, c> = PolynomialRing(K)
sage: ger = GradedExpansionRing_class(None, Sequence([MonoidPowerSeries(mps, {1 : 4, 2 : 3}, mps.monoid().filter_all()), MonoidPowerSeries(mps, {1 : 1, 2 : 3}, mps.monoid().filter_all()), MonoidPowerSeries(mps, {2 : 1, 3: 6, 4 : 9}, mps.monoid().filter_all())]), PolynomialRing(QQ, ['a', 'b', 'c']).ideal(0), DegreeGrading((1,2,3)))
sage: ger2 = GradedExpansionRing_class(None, Sequence([MonoidPowerSeries(mps, {1 : 4, 2 : 3}, mps.monoid().filter_all()), MonoidPowerSeries(mps, {1 : 1, 2 : 3}, mps.monoid().filter_all()), MonoidPowerSeries(mps, {2 : 1, 3: 6, 4 : 9}, mps.monoid().filter_all())]), P.ideal(a - b), DegreeGrading((1,2,3)))
sage: sm = GradedExpansionSubmodule_abstract(ger, Sequence([ger.0, ger.1]), 3)
sage: sm._reduced_basis_polynomials()
[a, b]
We need to introduce a workaround for coercions as long as graded expansion ambients do not
support coercion from one to another. Since the doctests to not allow for class definitions,
we hack an instance of an arbitrary Python class.
::
sage: from htmllib import HTMLParser
sage: coerce_workaround = HTMLParser('')
sage: setattr(coerce_workaround, '__call__', lambda e : ger2(P(e.polynomial())))
sage: setattr(coerce_workaround, 'relations', lambda : ger2.relations())
sage: sm._reduced_basis_polynomials(coerce_to = coerce_workaround)[0].parent().base_ring()
Cyclotomic Field of order 6 and degree 2
"""
if coerce_to is None :
coerced_basis = self.__basis_in_graded_ambient
relations = self.graded_ambient().relations()
else :
coerced_basis = map(coerce_to, self.__basis_in_graded_ambient)
relations = coerce_to.relations()
return Sequence( [ relations.reduce(b.polynomial())
for b in coerced_basis ],
universe = relations.ring() )
@cached_method
def _non_zero_monomials(self, coerce_to = None) :
"""
A list of monomials which occur in the reduced polynomials
associated with the basis of ``self``.
INPUT:
- ``coerce_to`` -- A graded ambient or ``None`` (default: ``None``);
Will be forwarded to :meth:~`._reduced_basis_polynomials`.
OUTPUT:
A sequence of monomials.
SEE::
:meth:~`._reduced_basis_polynomials`.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_module import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_module import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_submodule import *
sage: K.<rho> = CyclotomicField(6)
sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
sage: P.<a, b, c> = PolynomialRing(K)
sage: ger = GradedExpansionRing_class(None, Sequence([MonoidPowerSeries(mps, {1 : 4, 2 : 3}, mps.monoid().filter_all()), MonoidPowerSeries(mps, {1 : 1, 2 : 3}, mps.monoid().filter_all()), MonoidPowerSeries(mps, {2 : 1, 3: 6, 4 : 9}, mps.monoid().filter_all())]), PolynomialRing(QQ, ['a', 'b', 'c']).ideal(0), DegreeGrading((1,2,3)))
sage: ger2 = GradedExpansionRing_class(None, Sequence([MonoidPowerSeries(mps, {1 : 4, 2 : 3}, mps.monoid().filter_all()), MonoidPowerSeries(mps, {1 : 1, 2 : 3}, mps.monoid().filter_all()), MonoidPowerSeries(mps, {2 : 1, 3: 6, 4 : 9}, mps.monoid().filter_all())]), P.ideal(a - b), DegreeGrading((1,2,3)))
sage: sm = GradedExpansionSubmodule_abstract(ger, Sequence([ger.0, ger.1]), 3)
sage: sm._non_zero_monomials()
[a, b]
sage: from htmllib import HTMLParser
sage: coerce_workaround = HTMLParser('')
sage: setattr(coerce_workaround, '__call__', lambda e : ger2(P(e.polynomial())))
sage: setattr(coerce_workaround, 'relations', lambda : ger2.relations())
sage: sm._non_zero_monomials(coerce_to = coerce_workaround)
[b]
"""
red_basis = self._reduced_basis_polynomials(coerce_to = coerce_to)
return Sequence( reduce(union, [set(b.monomials()) for b in red_basis], set()),
universe = red_basis.universe() )
@cached_method
def _monomial_homomorphism(self, coerce_to = None) :
"""
A homomorphism that maps the underlying module to a vector space
where each component corresponds to a coefficient of the polynomial
associated to elements of ``self`` within the graded ambient or
``coerce_to``.
INPUT:
- ``coerce_to`` -- A graded ambient or ``None`` (default: ``None``);
Will be forwarded to :meth:~`._reduced_basis_polynomials`.
OUTPUT:
A morphism from ``self`` to a vector space.
NOTE:
The homomorphism is defined over a fraction field of the base ring
of the monomials.
SEE:
:meth:~`._non_zero_monomials` and :meth:~`._reduced_basis_polynomials`.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_module import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_module import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_submodule import *
sage: K.<rho> = CyclotomicField(6)
sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
sage: P.<a, b, c> = PolynomialRing(K)
sage: ger = GradedExpansionRing_class(None, Sequence([MonoidPowerSeries(mps, {1 : 4, 2 : 3}, mps.monoid().filter_all()), MonoidPowerSeries(mps, {1 : 1, 2 : 3}, mps.monoid().filter_all()), MonoidPowerSeries(mps, {2 : 1, 3: 6, 4 : 9}, mps.monoid().filter_all())]), PolynomialRing(QQ, ['a', 'b', 'c']).ideal(0), DegreeGrading((1,2,3)))
sage: ger2 = GradedExpansionRing_class(None, Sequence([MonoidPowerSeries(mps, {1 : 4, 2 : 3}, mps.monoid().filter_all()), MonoidPowerSeries(mps, {1 : 1, 2 : 3}, mps.monoid().filter_all()), MonoidPowerSeries(mps, {2 : 1, 3: 6, 4 : 9}, mps.monoid().filter_all())]), P.ideal(a - b), DegreeGrading((1,2,3)))
sage: sm = GradedExpansionSubmodule_ambient_pid(ger, Sequence([ger.0, ger.1]), 3)
sage: sm._monomial_homomorphism()
Free module morphism defined by the matrix
[1 0]
[0 1]
Domain: Submodule of Graded expansion ring with generators a, b, c
Codomain: Vector space of dimension 2 over Rational Field
sage: from htmllib import HTMLParser
sage: coerce_workaround = HTMLParser('')
sage: setattr(coerce_workaround, '__call__', lambda e : ger2(P(e.polynomial())))
sage: setattr(coerce_workaround, 'relations', lambda : ger2.relations())
sage: sm._monomial_homomorphism(coerce_to = coerce_workaround)
Free module morphism defined by the matrix
[1]
[1]
Domain: Submodule of Graded expansion ring with generators a, b, c
Codomain: Vector space of dimension 1 over Cyclotomic Field of order 6 ...
"""
reduced_basis = self._reduced_basis_polynomials(coerce_to = coerce_to)
all_mons = self._non_zero_monomials(coerce_to = coerce_to)
codomain = FreeModule(all_mons.universe().base_ring().fraction_field(), len(all_mons))
basis_images = [ codomain([b.monomial_coefficient(m) for m in all_mons])
for b in reduced_basis ]
return self.hom(basis_images)
def _ambient_element_to_monomial_coefficients_generator(self, x, reduce = False, coerce_basis_to = None) :
"""
Given an element `x` of the graded ambient ring or space return a generator
corresponding to the image of `x` with respect to the morphism returned
by :meth:~`._monomial_homomorphism`.
INPUT:
- `x` -- An element of the graded ambient.
- ``reduce`` -- A boolean (default: ``False``); If ``True`` the polynomial
attached to `x` will be reduced.
- ``coerce_basis_to`` -- A graded ambient or ``None`` (default: ``None``);
If not ``None`` the basis of ``self`` and `x` will be
coerced before determining the monomials.
OUTPUT:
A generator over elements in the monomials' base ring.
SEE:
:meth:~`._monomial_homomorphism`.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_module import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_module import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_submodule import *
sage: K.<rho> = CyclotomicField(6)
sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
sage: P.<a, b, c> = PolynomialRing(K)
sage: ger = GradedExpansionRing_class(None, Sequence([MonoidPowerSeries(mps, {1 : 4, 2 : 3}, mps.monoid().filter_all()), MonoidPowerSeries(mps, {1 : 1, 2 : 3}, mps.monoid().filter_all()), MonoidPowerSeries(mps, {2 : 1, 3: 6, 4 : 9}, mps.monoid().filter_all())]), PolynomialRing(QQ, ['a', 'b', 'c']).ideal(0), DegreeGrading((1,2,3)))
sage: ger2 = GradedExpansionRing_class(None, Sequence([MonoidPowerSeries(mps, {1 : 4, 2 : 3}, mps.monoid().filter_all()), MonoidPowerSeries(mps, {1 : 1, 2 : 3}, mps.monoid().filter_all()), MonoidPowerSeries(mps, {2 : 1, 3: 6, 4 : 9}, mps.monoid().filter_all())]), P.ideal(a - b), DegreeGrading((1,2,3)))
sage: sm = GradedExpansionSubmodule_ambient_pid(ger, Sequence([ger.0, ger.1]), 3)
sage: list( sm._ambient_element_to_monomial_coefficients_generator(ger.2) )
[0, 0]
sage: from htmllib import HTMLParser
sage: coerce_workaround = HTMLParser('')
sage: setattr(coerce_workaround, '__call__', lambda e : ger2(P(e.polynomial())))
sage: setattr(coerce_workaround, 'relations', lambda : ger2.relations())
sage: list( sm._ambient_element_to_monomial_coefficients_generator(ger.2, coerce_basis_to = coerce_workaround) )
[0]
sage: list( sm._ambient_element_to_monomial_coefficients_generator(ger.1, reduce = True, coerce_basis_to = coerce_workaround) )
[1]
"""
if not coerce_basis_to is None :
x = coerce_basis_to(x)
if reduce :
x = x._reduce_polynomial()
else :
x = x.polynomial()
return ( x.monomial_coefficient(m)
for m in self._non_zero_monomials(coerce_to = coerce_basis_to) )
def coordinates(self, x, in_base_ring = True, force_ambigous = False) :
"""
The coordinates in ``self`` of an element either of the following:
- The graded ambient,
- An element of a submodule,
- An expansion in the parent of the basis' expansions.
INPUT:
- `x` -- Either of the types listed above.
- ``in_base_ring`` -- A boolean (default: ``True``); If ``True``
enforce the result to be definied over the
base ring of ``self``.
- ``force_ambigous`` -- A boolean (default: ``False``); If ``True``
also return the solutions that are not unique.
OUTPUT:
A list of elements in the base ring or and extension of it.
NOTE:
If the Fourier expansion of `x` lakes sufficient precision the
expansions associated to ``self`` will be truncated.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_module import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_module import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_submodule import *
sage: K.<rho> = CyclotomicField(6)
sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
sage: ger = GradedExpansionRing_class(None, Sequence([MonoidPowerSeries(mps, {1 : 4, 2 : 3}, mps.monoid().filter_all()), MonoidPowerSeries(mps, {1 : 1, 2 : 3}, mps.monoid().filter_all()), MonoidPowerSeries(mps, {2 : 1, 3: 6, 4 : 9}, mps.monoid().filter_all())]), PolynomialRing(QQ, ['a', 'b', 'c']).ideal(0), DegreeGrading((1,2,3)))
sage: ger2 = GradedExpansionRing_class(None, Sequence([MonoidPowerSeries(mps, {1 : 4, 2 : 3}, mps.monoid().filter_all()), MonoidPowerSeries(mps, {1 : 1, 2 : 3}, mps.monoid().filter_all()), MonoidPowerSeries(mps, {2 : 1, 3: 6, 4 : 9}, mps.monoid().filter_all())]), PolynomialRing(K, ['a', 'b', 'c']).ideal(0), DegreeGrading((1,2,3)))
sage: sm = GradedExpansionSubmodule_ambient_pid(ger, Sequence([ger.0, ger.1]))
sage: sm2 = GradedExpansionSubmodule_ambient_pid(ger, Sequence([ger.0, ger.2]))
sage: sm3 = GradedExpansionSubmodule_ambient_pid(ger2, Sequence([ger2.0, ger2.2]))
sage: sm.coordinates(ger.2)
Traceback (most recent call last):
...
ArithmeticError: Graded expansion c is not contained in this space.
sage: sm.coordinates(sm2.0)
[1, 0]
sage: sm.coordinates(sm2.1)
Traceback (most recent call last):
...
ArithmeticError: Graded expansion c is not contained in this space.
sage: sm.coordinates(sm3.0)
Traceback (most recent call last):
...
ArithmeticError: No coordinates for (1, 0).
"""
if isinstance(x, Element) :
P = x.parent()
if P is self :
if self.ambient_module() is self :
return x.list()
else :
return list(self.coordinate_vector(x))
if self.graded_ambient().has_coerce_map_from(P) :
if not P is self.graded_ambient() :
x = self.graded_ambient()(x)
#x = x.polynomial()
if not set(x._reduce_polynomial().monomials()).issubset(set(self._non_zero_monomials())) :
raise ArithmeticError( "%s is not contained in this space." % (x,) )
mon_matrix = self._monomial_homomorphism().matrix().transpose()
x_mon_vector = vector( self.base_ring().fraction_field(),
self._ambient_element_to_monomial_coefficients_generator(x, True) )
## TODO: use linbox
try :
coords = magma(mon_matrix.transpose()).Solution(magma(matrix(x_mon_vector))).sage()
coords = coords.row(0)
except TypeError, msg :
if "Runtime error in 'Solution': No solution exists" in msg :
raise ArithmeticError( "%s is not contained in this space." % (x,) )
try :
coords = mon_matrix.solve_right(x_mon_vector)
except ValueError :
raise ArithmeticError( "%s is not contained in this space." % (x,) )
try :
# we used the base graded_ambient's fraction field, so convert it
return [self.base_ring()(c) for c in coords]
except TypeError :
if in_base_ring :
raise ArithmeticError( "%s is not contained in this space." % (x,) )
else :
return coords.list()
#! elif self.graded_ambient().has_coerce_map_from(P) :
elif P.has_coerce_map_from(self.graded_ambient()) :
#x = x.polynomial()
mon_matrix = self._monomial_homomorphism().matrix().transpose()
mon_matrix = matrix(P.base_ring().fraction_field(), mon_matrix)
x_mon_vector = vector( P.base_ring().fraction_field(),
self._ambient_element_to_monomial_coefficients_generator(x, True, P) )
try :
coords = mon_matrix.solve_right(x_mon_vector)
except ValueError :
raise ArithmeticError( "%s is not contained in the image of this space." % (x,) )
try :
# we used the base graded_ambient's fraction field, so convert it
return [self.base_ring()(c) for c in coords]
except TypeError :
if in_base_ring :
raise ArithmeticError( "%s is not contained in the image of this space." % (x,) )
else :
return coords.list()
#! elif P.has_coerce_map_from(self.graded_ambient()) :
#! if isinstance(x, (tuple, Element)) :
return ExpansionModule_abstract.coordinates(self, x, in_base_ring, force_ambigous)
def _graded_expansion_submodule_to_graded_ambient_(self, x) :
"""
The element `x` of ``self`` as an element of the graded ambient ring or space.
INPUT:
- `x` -- An element of self.
OUTPUT:
An element of the graded ambient.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_module import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_module import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_submodule import *
sage: K.<rho> = CyclotomicField(6)
sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
sage: P.<a, b, c> = PolynomialRing(K)
sage: ger = GradedExpansionRing_class(None, Sequence([MonoidPowerSeries(mps, {1 : 4, 2 : 3}, mps.monoid().filter_all()), MonoidPowerSeries(mps, {1 : 1, 2 : 3}, mps.monoid().filter_all()), MonoidPowerSeries(mps, {2 : 1, 3: 6, 4 : 9}, mps.monoid().filter_all())]), PolynomialRing(QQ, ['a', 'b', 'c']).ideal(0), DegreeGrading((1,2,3)))
sage: ger2 = GradedExpansionRing_class(None, Sequence([MonoidPowerSeries(mps, {1 : 4, 2 : 3}, mps.monoid().filter_all()), MonoidPowerSeries(mps, {1 : 1, 2 : 3}, mps.monoid().filter_all()), MonoidPowerSeries(mps, {2 : 1, 3: 6, 4 : 9}, mps.monoid().filter_all())]), P.ideal(a - b), DegreeGrading((1,2,3)))
sage: sm = GradedExpansionSubmodule_ambient_pid(ger, Sequence([ger.0, ger.1]))
sage: sm._graded_expansion_submodule_to_graded_ambient_(2*sm.0 + 3*sm.1)
Graded expansion 2*a + 3*b
"""
return sum( map(mul, self.coordinates(x), self._basis_in_graded_ambient()) )
def _repr_(self) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_module import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_module import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_submodule import *
sage: K.<rho> = CyclotomicField(6)
sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
sage: P.<a, b, c> = PolynomialRing(K)
sage: ger = GradedExpansionRing_class(None, Sequence([MonoidPowerSeries(mps, {1 : 4, 2 : 3}, mps.monoid().filter_all()), MonoidPowerSeries(mps, {1 : 1, 2 : 3}, mps.monoid().filter_all()), MonoidPowerSeries(mps, {2 : 1, 3: 6, 4 : 9}, mps.monoid().filter_all())]), PolynomialRing(QQ, ['a', 'b', 'c']).ideal(0), DegreeGrading((1,2,3)))
sage: ger2 = GradedExpansionRing_class(None, Sequence([MonoidPowerSeries(mps, {1 : 4, 2 : 3}, mps.monoid().filter_all()), MonoidPowerSeries(mps, {1 : 1, 2 : 3}, mps.monoid().filter_all()), MonoidPowerSeries(mps, {2 : 1, 3: 6, 4 : 9}, mps.monoid().filter_all())]), P.ideal(a - b), DegreeGrading((1,2,3)))
sage: GradedExpansionSubmodule_ambient_pid(ger, Sequence([ger.0, ger.1]))
Submodule of Graded expansion ring with generators a, b, c
"""
return "Submodule of %s" % (self.__graded_ambient,)
def _latex_(self) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_module import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_module import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_submodule import *
sage: K.<rho> = CyclotomicField(6)
sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
sage: P.<a, b, c> = PolynomialRing(K)
sage: ger = GradedExpansionRing_class(None, Sequence([MonoidPowerSeries(mps, {1 : 4, 2 : 3}, mps.monoid().filter_all()), MonoidPowerSeries(mps, {1 : 1, 2 : 3}, mps.monoid().filter_all()), MonoidPowerSeries(mps, {2 : 1, 3: 6, 4 : 9}, mps.monoid().filter_all())]), PolynomialRing(QQ, ['a', 'b', 'c']).ideal(0), DegreeGrading((1,2,3)))
sage: ger2 = GradedExpansionRing_class(None, Sequence([MonoidPowerSeries(mps, {1 : 4, 2 : 3}, mps.monoid().filter_all()), MonoidPowerSeries(mps, {1 : 1, 2 : 3}, mps.monoid().filter_all()), MonoidPowerSeries(mps, {2 : 1, 3: 6, 4 : 9}, mps.monoid().filter_all())]), P.ideal(a - b), DegreeGrading((1,2,3)))
sage: latex( GradedExpansionSubmodule_ambient_pid(ger, Sequence([ger.0, ger.1])) )
Submodule of Graded expansion ring with generators a, b, c
"""
return "Submodule of %s" % (latex(self.__graded_ambient),)
#===============================================================================
# GradedExpansionSubmodule_generic
#===============================================================================
class GradedExpansionSubmodule_generic ( GradedExpansionSubmodule_abstract, ExpansionModule_generic ) :
"""
A finite dimensional module of graded expansions within an ambient.
SEE:
:class:~`fourier_expansion_framework.gradedexpansions.gradedexpansion_ambient.GradedExpansion_ambient`.
"""
def __init__(self, graded_ambient, basis, degree, **kwds) :
"""
INPUT:
- ``graded_ambient`` -- An instance of :class:~`fourier_expansion_framework.gradedexpansions.gradedexpansion_ambient.GradedExpansionAmbient_abstract`.
- ``basis`` -- A tuple, list or sequence of elements of the graded ambient.
- ``degree`` -- An integer; The degree of the module within its ambient module.
NOTE:
The base ring of the graded expansion ambient must be an integral domain.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_module import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_module import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_submodule import *
sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
sage: ger = GradedExpansionRing_class(None, Sequence([MonoidPowerSeries(mps, {1 : 4, 2 : 3}, mps.monoid().filter_all()), MonoidPowerSeries(mps, {1 : 1, 2 : 3}, mps.monoid().filter_all()), MonoidPowerSeries(mps, {2 : 1, 3: 6, 4 : 9}, mps.monoid().filter_all())]), PolynomialRing(QQ, ['a', 'b', 'c']).ideal(0), DegreeGrading((1,2,3)))
sage: sm = GradedExpansionSubmodule_generic(ger, Sequence([ger.0, ger.1]), 3)
sage: sm = GradedExpansionSubmodule_generic(ger, Sequence([ger.0, ger.1]), 2, _element_class = GradedExpansionSubmoduleVector_generic, no_expansion_init = True)
"""
if not hasattr(self, '_element_class') :
if '_element_class' in kwds :
self._element_class = kwds['_element_class']
else :
self._element_class = GradedExpansionSubmoduleVector_generic
GradedExpansionSubmodule_abstract.__init__(self, graded_ambient, basis, degree)
ExpansionModule_generic.__init__(self, self._abstract_basis(), degree, **kwds)
def change_ring(self, R):
"""
Return the ambient module of graded expansions over `R` with the same basis as ``self``.
INPUT:
- `R` -- A ring.
OUTPUT:
An instance of :class:~`.GradedExpansionSubmodule_generic`.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_module import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_module import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_submodule import *
sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
sage: ger = GradedExpansionRing_class(None, Sequence([MonoidPowerSeries(mps, {1 : 4, 2 : 3}, mps.monoid().filter_all()), MonoidPowerSeries(mps, {1 : 1, 2 : 3}, mps.monoid().filter_all()), MonoidPowerSeries(mps, {2 : 1, 3: 6, 4 : 9}, mps.monoid().filter_all())]), PolynomialRing(QQ, ['a', 'b', 'c']).ideal(0), DegreeGrading((1,2,3)))
sage: sm = GradedExpansionSubmodule_generic(ger, Sequence([ger.0, ger.1]), 3)
sage: sm.change_ring(QQ) is sm
True
sage: sm.change_ring(PolynomialRing(QQ, 'x'))
Traceback (most recent call last):
...
ValueError: Associated expansion of graded ambient not defined over Univariate Polynomial Ring in x over Rational Field.
"""
if self.base_ring() == R:
return self
raise ValueError( "Associated expansion of graded ambient not defined over %s." % R )
def basis(self) :
"""
A basis of ``self``.
OUTPUT:
A list of elements of ``self``.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_module import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_module import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_submodule import *
sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
sage: ger = GradedExpansionRing_class(None, Sequence([MonoidPowerSeries(mps, {1 : 4, 2 : 3}, mps.monoid().filter_all()), MonoidPowerSeries(mps, {1 : 1, 2 : 3}, mps.monoid().filter_all()), MonoidPowerSeries(mps, {2 : 1, 3: 6, 4 : 9}, mps.monoid().filter_all())]), PolynomialRing(QQ, ['a', 'b', 'c']).ideal(0), DegreeGrading((1,2,3)))
sage: sm = GradedExpansionSubmodule_generic(ger, Sequence([ger.0, ger.1]), 3)
sage: sm.basis()
Traceback (most recent call last):
...
NotImplementedError
"""
raise NotImplementedError
def hom(self, other) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_module import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_module import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_submodule import *
sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
sage: ger = GradedExpansionRing_class(None, Sequence([MonoidPowerSeries(mps, {1 : 4, 2 : 3}, mps.monoid().filter_all()), MonoidPowerSeries(mps, {1 : 1, 2 : 3}, mps.monoid().filter_all()), MonoidPowerSeries(mps, {2 : 1, 3: 6, 4 : 9}, mps.monoid().filter_all())]), PolynomialRing(QQ, ['a', 'b', 'c']).ideal(0), DegreeGrading((1,2,3)))
sage: sm = GradedExpansionSubmodule_generic(ger, Sequence([ger.0, ger.1]), 3)
sage: m = FreeModule(QQ, 2)
sage: sm.hom([m([1,0]),m([1,1])])
Free module morphism defined by the matrix
[1 0]
[1 1]
Domain: Submodule of Graded expansion ring with generators a, b, c
Codomain: Vector space of dimension 2 over Rational Field
sage: sm.hom(sm)
Traceback (most recent call last):
...
NotImplementedError
"""
if isinstance(other, GradedExpansionSubmodule_abstract) and \
self.graded_ambient() == other.graded_ambient() :
raise NotImplementedError
else :
images = other
return FreeModule_generic.hom(self, images)
#===============================================================================
# _span
# This will be used in GradedExpansionSubmodule_ambient_pid and
# GradedExpansionSubmodule_submodule_pid
#===============================================================================
def _span( self, gens, base_ring = None, check = True, already_echelonized = False ) :
"""
The submodule of graded expansions spanned by ``gens``.
INPUT:
- ``gens`` -- A list, tuple or sequence of module elements.
- ``base_ring`` -- A ring or ``None`` (default: ``None``); If ``None``
the base ring of ``self`` will be used.
- ``check`` -- A boolean (default: ``True``); If ``True`` check
whether the generators are appropriately coerced.
- ``already_echelonized`` -- A boolean (default: ``False``); If ``True``
the generators are already in echelon form
with respect to the ambient's basis.
OUTPUT:
An instance of :class:~`.GradedExpansionSubmodule_submodule_pid`.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_module import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_module import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_submodule import *
sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
sage: ger = GradedExpansionRing_class(None, Sequence([MonoidPowerSeries(mps, {1 : 4, 2 : 3}, mps.monoid().filter_all()), MonoidPowerSeries(mps, {1 : 1, 2 : 3}, mps.monoid().filter_all()), MonoidPowerSeries(mps, {2 : 1, 3: 6, 4 : 9}, mps.monoid().filter_all())]), PolynomialRing(QQ, ['a', 'b', 'c']).ideal(0), DegreeGrading((1,2,3)))
sage: sm = GradedExpansionSubmodule_ambient_pid(ger, Sequence([ger.0, ger.1]))
sage: sms = sm.span([sm.0])
sage: sms = sm.span([sm.0], base_ring = PolynomialRing(QQ, 'x'))
Traceback (most recent call last):
...
ValueError: Associated expansion of graded ambient not defined over Univariate Polynomial Ring in x over Rational Field.
"""
if is_FreeModule(gens):
gens = gens.gens()
if not isinstance(gens, (list, tuple, Sequence)):
raise TypeError, "Argument gens (= %s) must be a list, tuple, or sequence."%gens
if base_ring is None or base_ring == self.base_ring():
gens = Sequence(gens, check = check, universe = self.ambient_module())
return GradedExpansionSubmodule_submodule_pid( self.ambient_module(), gens )
else:
try:
M = self.change_ring(base_ring)
except TypeError:
raise ValueError, "Argument base_ring (= %s) is not compatible " % (base_ring,) + \
"with the base field (= %s)." % (self.base_field(),)
try:
return M.span(gens)
except TypeError:
raise ValueError, "Argument gens (= %s) is not compatible " % (gens,) + \
"with base_ring (= %s)." % (base_ring,)
#===============================================================================
# GradedExpansionSubmodule_ambient_pid
#===============================================================================
class GradedExpansionSubmodule_ambient_pid ( GradedExpansionSubmodule_abstract, ExpansionModule_ambient_pid ) :
"""
An ambient module of graded expansions expansions over a principal ideal domain.
"""
def __init__(self, graded_ambient, basis, _element_class = None, **kwds) :
"""
INPUT:
- ``graded_ambient`` -- An instance of :class:~`fourier_expansion_framework.gradedexpansions.gradedexpansion_ambient.GradedExpansionAmbient_abstract`.
- ``basis`` -- A list or sequence of (equivariant) monoid power series.
- ``element_class`` -- A type or ``None`` (default: ``None``); The element class
attached to ``self``. If ``None`` :class:~`.GradedExpansionSubmoduleVector_generic`
will be used.
- ``kwds`` -- Will be forwarded to :class:~`fourier_expansion_module.gradedexpansions.expansion_module.ExpansionModule_ambient_pid`
and :class:~`.GradedExpansionSubmodule_abstract`.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_module import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_module import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_submodule import *
sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
sage: ger = GradedExpansionRing_class(None, Sequence([MonoidPowerSeries(mps, {1 : 4, 2 : 3}, mps.monoid().filter_all()), MonoidPowerSeries(mps, {1 : 1, 2 : 3}, mps.monoid().filter_all()), MonoidPowerSeries(mps, {2 : 1, 3: 6, 4 : 9}, mps.monoid().filter_all())]), PolynomialRing(QQ, ['a', 'b', 'c']).ideal(0), DegreeGrading((1,2,3)))
sage: sm = GradedExpansionSubmodule_ambient_pid(ger, Sequence([ger.0, ger.1]))
sage: sm = GradedExpansionSubmodule_ambient_pid(ger, Sequence([ger.0, ger.1]), _element_class = GradedExpansionSubmoduleVector_generic, no_expansion_init = True)
Traceback (most recent call last):
...
AttributeError: 'GradedExpansionSubmodule_ambient_pid' object has no attribute '_ExpansionModule_abstract__abstract_basis'
"""
if not hasattr(self, '_element_class') :
if not _element_class is None :
self._element_class = _element_class
else :
self._element_class = GradedExpansionSubmoduleVector_generic
GradedExpansionSubmodule_abstract.__init__(self, graded_ambient, basis, len(basis), **kwds)
ExpansionModule_ambient_pid.__init__(self, self._abstract_basis(), **kwds)
global _span
span = _span
def change_ring(self, R):
"""
Return the ambient module of graded expansions over `R` with the
same basis as ``self``.
INPUT:
- `R` -- A ring.
OUTPUT:
An instance of :class:~`.GradedExpansionSubmodule_ambient_pid`.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_module import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_module import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_submodule import *
sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
sage: ger = GradedExpansionRing_class(None, Sequence([MonoidPowerSeries(mps, {1 : 4, 2 : 3}, mps.monoid().filter_all()), MonoidPowerSeries(mps, {1 : 1, 2 : 3}, mps.monoid().filter_all()), MonoidPowerSeries(mps, {2 : 1, 3: 6, 4 : 9}, mps.monoid().filter_all())]), PolynomialRing(QQ, ['a', 'b', 'c']).ideal(0), DegreeGrading((1,2,3)))
sage: sm = GradedExpansionSubmodule_generic(ger, Sequence([ger.0, ger.1]), 3)
sage: sm.change_ring(QQ) is sm
True
sage: sm.change_ring(PolynomialRing(QQ, 'x'))
Traceback (most recent call last):
...
ValueError: Associated expansion of graded ambient not defined over Univariate Polynomial Ring in x over Rational Field.
"""
if self.base_ring() == R:
return self
raise ValueError( "Associated expansion of graded ambient not defined over %s." % R )
def hom(self, other) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_module import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_module import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_submodule import *
sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
sage: ger = GradedExpansionRing_class(None, Sequence([MonoidPowerSeries(mps, {1 : 4, 2 : 3}, mps.monoid().filter_all()), MonoidPowerSeries(mps, {1 : 1, 2 : 3}, mps.monoid().filter_all()), MonoidPowerSeries(mps, {2 : 1, 3: 6, 4 : 9}, mps.monoid().filter_all())]), PolynomialRing(QQ, ['a', 'b', 'c']).ideal(0), DegreeGrading((1,2,3)))
sage: sm = GradedExpansionSubmodule_ambient_pid(ger, Sequence([ger.0, ger.1]))
sage: sm2 = GradedExpansionSubmodule_ambient_pid(ger, Sequence([ger.0, ger.2, ger.1]))
sage: m = FreeModule(QQ, 2)
sage: sm.hom(sm2)
Free module morphism defined by the matrix
[1 0 0]
[0 0 1]
Domain: Submodule of Graded expansion ring with generators a, b, c
Codomain: Submodule of Graded expansion ring with generators a, b, c
sage: sm.hom([m([1,0]),m([1,1])])
Free module morphism defined by the matrix
[1 0]
[1 1]
Domain: Submodule of Graded expansion ring with generators a, b, c
Codomain: Vector space of dimension 2 over Rational Field
"""
if isinstance(other, GradedExpansionSubmodule_abstract) and \
self.graded_ambient() == other.graded_ambient() :
images = [other(b) for b in self._basis_in_graded_ambient()]
else :
images = other
return FreeModule_ambient_pid.hom(self, images)
#===============================================================================
# GradedExpansionSubmodule_submodule_pid
#===============================================================================
class GradedExpansionSubmodule_submodule_pid ( GradedExpansionSubmodule_abstract, ExpansionModule_submodule_pid ) :
"""
A submodule of another module of graded expansions over a principal ideal domain.
"""
def __init__(self, ambient, gens, element_class = None, **kwds) :
"""
INPUT:
- ``ambient`` -- An instance of :class:~`.GradedExpansionSubmodule_submodule_pid` :class:~`.GradedExpansionSubmodule_submodule_pid` or .
- ``gens`` -- A tuple, list or sequence of elements of ``ambient``.
- ``element_class`` -- A type or ``None`` (default: ``None``); The element class
attached to ``self``. If ``None`` :class:~`.GradedExpansionSubmoduleVector_generic`
will be used.
- ``kwds`` -- Will be forwarded to :class:~`fourier_expansion_module.gradedexpansions.expansion_module.ExpansionModule_submodule_pid`
and :class:~`.GradedExpansionSubmodule_abstract`.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_module import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_module import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_submodule import *
sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
sage: ger = GradedExpansionRing_class(None, Sequence([MonoidPowerSeries(mps, {1 : 4, 2 : 3}, mps.monoid().filter_all()), MonoidPowerSeries(mps, {1 : 1, 2 : 3}, mps.monoid().filter_all()), MonoidPowerSeries(mps, {2 : 1, 3: 6, 4 : 9}, mps.monoid().filter_all())]), PolynomialRing(QQ, ['a', 'b', 'c']).ideal(0), DegreeGrading((1,2,3)))
sage: sm = GradedExpansionSubmodule_ambient_pid(ger, Sequence([ger.0, ger.1]))
sage: sms = GradedExpansionSubmodule_submodule_pid(sm, [sm.0, sm.1])
sage: sms = GradedExpansionSubmodule_submodule_pid(sm, [sm.0, sm.1], _element_class = GradedExpansionSubmoduleVector_generic, no_expansion_init = True)
"""
if not hasattr(self, '_element_class') :
if not element_class is None :
self._element_class = element_class
else :
self._element_class = GradedExpansionSubmoduleVector_generic
GradedExpansionSubmodule_abstract.__init__( self, ambient.graded_ambient(),
[ambient.graded_ambient()(g) for g in gens], ambient.dimension(),
**kwds )
ExpansionModule_submodule_pid.__init__(self, ambient, gens, **kwds)
global _span
span = _span
def change_ring(self, R):
"""
Return the ambient module of graded expansions over `R` with the
same basis as ``self``.
INPUT:
- `R` -- A ring.
OUTPUT:
An instance of :class:~`.GradedExpansionSubmodule_ambient_pid`.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_module import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_module import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_submodule import *
sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
sage: ger = GradedExpansionRing_class(None, Sequence([MonoidPowerSeries(mps, {1 : 4, 2 : 3}, mps.monoid().filter_all()), MonoidPowerSeries(mps, {1 : 1, 2 : 3}, mps.monoid().filter_all()), MonoidPowerSeries(mps, {2 : 1, 3: 6, 4 : 9}, mps.monoid().filter_all())]), PolynomialRing(QQ, ['a', 'b', 'c']).ideal(0), DegreeGrading((1,2,3)))
sage: sm = GradedExpansionSubmodule_ambient_pid(ger, Sequence([ger.0, ger.1]))
sage: sms = GradedExpansionSubmodule_submodule_pid(sm, [sm.0, sm.1])
sage: sms.change_ring(QQ) is sms
True
sage: sms.change_ring(PolynomialRing(QQ, 'x'))
Traceback (most recent call last):
...
ValueError: Associated expansion of graded ambient not defined over Univariate Polynomial Ring in x over Rational Field.
"""
if self.base_ring() == R:
return self
raise ValueError( "Associated expansion of graded ambient not defined over %s." % R )
def hom(self, other) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_module import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_module import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_submodule import *
sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
sage: ger = GradedExpansionRing_class(None, Sequence([MonoidPowerSeries(mps, {1 : 4, 2 : 3}, mps.monoid().filter_all()), MonoidPowerSeries(mps, {1 : 1, 2 : 3}, mps.monoid().filter_all()), MonoidPowerSeries(mps, {2 : 1, 3: 6, 4 : 9}, mps.monoid().filter_all())]), PolynomialRing(QQ, ['a', 'b', 'c']).ideal(0), DegreeGrading((1,2,3)))
sage: sm = GradedExpansionSubmodule_ambient_pid(ger, Sequence([ger.0, ger.1]))
sage: sms = GradedExpansionSubmodule_submodule_pid(sm, [sm.0, sm.1])
sage: sms2 = GradedExpansionSubmodule_submodule_pid(sm, [sm.0, sm.0 + sm.1])
sage: m = FreeModule(QQ, 2)
sage: sms.hom(sms2)
Free module morphism defined by the matrix
[1 0]
[0 1]
Domain: Submodule of Graded expansion ring with generators a, b, c
Codomain: Submodule of Graded expansion ring with generators a, b, c
sage: sms.hom([m([1,0]),m([1,1])])
Free module morphism defined by the matrix
[1 0]
[1 1]
Domain: Submodule of Graded expansion ring with generators a, b, c
Codomain: Vector space of dimension 2 over Rational Field
"""
if isinstance(other, GradedExpansionSubmodule_abstract) and \
self.graded_ambient() == other.graded_ambient() :
images = [other(b) for b in self._basis_in_graded_ambient()]
else :
images = other
return FreeModule_submodule_pid.hom(self, images)
#===============================================================================
# GradedExpansionSubmoduleVector_generic
#===============================================================================
class GradedExpansionSubmoduleVector_generic ( ExpansionModuleVector_generic ) :
"""
A generic implementation of an element in a module of graded expansions.
"""
def __copy__(self) :
"""
Return a copy of ``self``.
OUTPUT:
An instance of :class:~`.GradedExpansionSubmoduleVector_generic`.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_module import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_module import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_submodule import *
sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
sage: ger = GradedExpansionRing_class(None, Sequence([MonoidPowerSeries(mps, {1 : 4, 2 : 3}, mps.monoid().filter_all()), MonoidPowerSeries(mps, {1 : 1, 2 : 3}, mps.monoid().filter_all()), MonoidPowerSeries(mps, {2 : 1, 3: 6, 4 : 9}, mps.monoid().filter_all())]), PolynomialRing(QQ, ['a', 'b', 'c']).ideal(0), DegreeGrading((1,2,3)))
sage: sm = GradedExpansionSubmodule_ambient_pid(ger, Sequence([ger.0, ger.1]))
sage: h = GradedExpansionSubmoduleVector_generic(sm, [1,0])
sage: copy(h)
(1, 0)
"""
return GradedExpansionSubmoduleVector_generic( self.parent(), self.list(), coerce = False, copy = True )
def polynomial(self) :
"""
Return the polynomial associated to ``self`` in the graded ambient
of its parent.
OUTPUT:
A polynomial in the polynomial ring attached to the graded ambient.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_module import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_module import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_submodule import *
sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
sage: ger = GradedExpansionRing_class(None, Sequence([MonoidPowerSeries(mps, {1 : 4, 2 : 3}, mps.monoid().filter_all()), MonoidPowerSeries(mps, {1 : 1, 2 : 3}, mps.monoid().filter_all()), MonoidPowerSeries(mps, {2 : 1, 3: 6, 4 : 9}, mps.monoid().filter_all())]), PolynomialRing(QQ, ['a', 'b', 'c']).ideal(0), DegreeGrading((1,2,3)))
sage: sm = GradedExpansionSubmodule_ambient_pid(ger, Sequence([ger.0, ger.1]))
sage: h = GradedExpansionSubmoduleVector_generic(sm, [1,0])
sage: h.polynomial()
a
"""
return sum( self[k]*self.parent()._basis_in_graded_ambient()[k].polynomial()
for k in xrange(self.parent().rank()) )
| Python |
r"""
Interface for elements which provide a Fourier expansion.
AUTHOR :
-- Martin Raum (2009 - 08 - 03) Initial version
"""
#===============================================================================
#
# Copyright (C) 2009 Martin Raum
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 3
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, see <http://www.gnu.org/licenses/>.
#
#===============================================================================
class FourierExpansionWrapper :
"""
Abstract class for elements, which do not represent Fourier
expansions on their own, but encapsulate one.
SEE:
:class:~`fourier_expansion_framework.gradedexpansions.GradedExpansion_class`.
"""
def fourier_expansion(self, cache = True) :
"""
The Fourier expansion which is associated with ``self``.
INPUT:
- ``cache`` -- A boolean (default: ``True``); If ``True`` the return value
will be cached.
OUTPUT:
A (equivariant) monoid power series.
NOTE:
The parent has to implement the function ``_fourier_expansion_of_element``.
TESTS::
sage: from psage.modform.fourier_expansion_framework.gradedexpansions import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: emps = EquivariantMonoidPowerSeriesRing(NNMonoid(True), TrivialCharacterMonoid("1", ZZ), TrivialRepresentation("1", ZZ))
sage: em = ExpansionModule(Sequence([emps.one_element().truncate(3), emps.one_element(), emps.one_element()]))
sage: h = em([1,2,-3])
sage: fe = h.fourier_expansion()
"""
try :
return self.__fourier_expansion
except AttributeError :
if cache :
self.__fourier_expansion = \
self.parent()._fourier_expansion_of_element(self)
return self.__fourier_expansion
else :
return self.parent()._fourier_expansion_of_element(self)
def _set_fourier_expansion(self, expansion ) :
"""
Set the cache for the Fourier expansion to an given monoid power series.
INPUT:
- ``expansion`` -- A (equivariant) monoid power series.
OUTPUT:
``None``
TESTS::
sage: from psage.modform.fourier_expansion_framework.gradedexpansions import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: emps = EquivariantMonoidPowerSeriesRing(NNMonoid(True), TrivialCharacterMonoid("1", ZZ), TrivialRepresentation("1", ZZ))
sage: em = ExpansionModule(Sequence([emps.one_element().truncate(3), emps.one_element(), emps.one_element()]))
sage: h = em([1,2,5])
sage: fe = h.fourier_expansion()
sage: h = em([1,2,0])
sage: h._set_fourier_expansion(fe)
sage: h.fourier_expansion() == fe
True
"""
self.__fourier_expansion = expansion
| Python |
r"""
Gradings of a polynomial quotient ring.
AUTHOR :
-- Martin Raum (2009 - 07 - 27) Initial version
"""
#===============================================================================
#
# Copyright (C) 2009 Martin Raum
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 3
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, see <http://www.gnu.org/licenses/>.
#
#===============================================================================
from operator import mul
from operator import xor
from sage.misc.latex import latex
from sage.modules.free_module import FreeModule
from sage.rings.infinity import infinity
from sage.rings.integer import Integer
from sage.rings.integer_ring import ZZ
from sage.rings.polynomial.all import is_Polynomial, is_MPolynomial
from sage.structure.all import Sequence
from sage.structure.sage_object import SageObject
class Grading_abstract ( SageObject ) :
"""
A common interface for monomial gradings of polynomial rings
`R[x_1, .., x_n]`.
"""
def ngens(self) :
"""
The number of generators of the polynomial ring.
OUTPUT:
An integer.
TESTS::
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import *
sage: Grading_abstract().ngens()
Traceback (most recent call last):
...
NotImplementedError
"""
raise NotImplementedError
def gen(self, i) :
"""
The grading associated to the `i`-th generator of the polynomial ring.
INPUT:
- `i` -- An integer.
OUTPUT:
A grading index.
TESTS::
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import *
sage: Grading_abstract().gen(1)
Traceback (most recent call last):
...
NotImplementedError
"""
raise NotImplementedError
def gens(self) :
"""
The gradings of the generators of the polynomial ring.
OUTPUT:
A tuple of grading indices.
TESTS::
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import *
sage: Grading_abstract().gens()
Traceback (most recent call last):
...
NotImplementedError
"""
raise NotImplementedError
def index(self, x) :
"""
The grading value of `x` with respect to this grading.
INPUT:
- `x` -- A tuple of length `n`.
OUTPUT:
A grading index.
TESTS::
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import *
sage: Grading_abstract().index((1))
Traceback (most recent call last):
...
NotImplementedError
"""
raise NotImplementedError
def basis(self, index, vars = None) :
"""
All monomials that are have given grading index involving only the
given variables.
INPUT:
- ``index`` -- A grading index.
- ``vars`` -- A list of integers from `0` to `n - 1` or ``None``
(default: ``None``); If ``None`` all variables
will be considered.
OUTPUT:
A list of tuples of integers, each of which has length `n`.
TESTS::
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import *
sage: Grading_abstract().basis(1)
Traceback (most recent call last):
...
NotImplementedError
"""
raise NotImplementedError
def subgrading(self, gens) :
"""
The grading of same type for the ring with only the variables given by
``gens``.
INPUT:
- ``gens`` - A list of integers.
OUTPUT:
An instance of :class:~`.Grading_abstract`.
TESTS::
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import *
sage: Grading_abstract().subgrading([1,2])
Traceback (most recent call last):
...
NotImplementedError
"""
raise NotImplementedError
def __contains__(self, x) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import *
sage: 1 in Grading_abstract()
Traceback (most recent call last):
...
NotImplementedError
"""
raise NotImplementedError
def _repr_(self) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import *
sage: Grading_abstract()
A grading
"""
return "A grading"
def _latex_(self) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import *
sage: latex( Grading_abstract() )
A grading
"""
return "A grading"
#===============================================================================
# DegreeGrading
#===============================================================================
class DegreeGrading( Grading_abstract ) :
"""
This class implements a monomial grading for a polynomial ring
`R[x_1, .., x_n]`.
"""
def __init__( self, degrees ) :
"""
INPUT:
- ``degrees`` -- A list or tuple of `n` positive integers.
TESTS::
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import *
sage: g = DegreeGrading((1,2))
sage: g = DegreeGrading([5,2,3])
"""
self.__degrees = tuple(degrees)
self.__module = FreeModule(ZZ, len(degrees))
self.__module_basis = self.__module.basis()
def ngens(self) :
"""
The number of generators of the polynomial ring.
OUTPUT:
An integer.
TESTS::
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import *
sage: DegreeGrading((1,2)).ngens()
2
sage: DegreeGrading([5,2,3]).ngens()
3
"""
return len(self.__degrees)
def gen(self, i) :
"""
The number of generators of the polynomial ring.
OUTPUT:
An integer.
TESTS::
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import *
sage: DegreeGrading([5,2,3]).gen(0)
5
sage: DegreeGrading([5,2,3]).gen(3)
Traceback (most recent call last):
...
ValueError: Generator 3 does not exist.
"""
if i < len(self.__degrees) :
return self.__degrees[i]
raise ValueError("Generator %s does not exist." % (i,))
def gens(self) :
"""
The gradings of the generators of the polynomial ring.
OUTPUT:
A tuple of integers.
TESTS::
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import *
sage: DegreeGrading((1,2)).gens()
(1, 2)
sage: DegreeGrading([5,2,3]).gens()
(5, 2, 3)
"""
return self.__degrees
def index(self, x) :
"""
The grading value of `x` with respect to this grading.
INPUT:
- `x` -- A tuple of length `n`.
OUTPUT:
An integer.
TESTS::
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import *
sage: g = DegreeGrading([5,2,3])
sage: g.index((2,4,5))
33
sage: g.index((2,3))
Traceback (most recent call last):
...
ValueError: Tuple must have length 3.
"""
## TODO: We shouldn't need this.
#if len(x) == 0 : return infinity
if len(x) != len(self.__degrees) :
raise ValueError( "Tuple must have length %s." % (len(self.__degrees),))
return sum( map(mul, x, self.__degrees) )
def basis(self, index, vars = None) :
"""
All monomials that are have given grading index involving only the
given variables.
INPUT:
- ``index`` -- A grading index.
- ``vars`` -- A list of integers from `0` to `n - 1` or ``None``
(default: ``None``); If ``None`` all variables
will be considered.
OUTPUT:
A list of elements in `\Z^n`.
TESTS::
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import *
sage: g = DegreeGrading([5,2,3])
sage: g.basis(2)
[(0, 1, 0)]
sage: g.basis(10, vars = [0])
[(2, 0, 0)]
sage: g.basis(20, vars = [1,2])
[(0, 10, 0), (0, 7, 2), (0, 4, 4), (0, 1, 6)]
sage: g.basis(-1)
[]
sage: g.basis(0)
[(0, 0, 0)]
"""
if index < 0 :
return []
elif index == 0 :
return [self.__module.zero_vector()]
if vars == None :
vars = [m for (m,d) in enumerate(self.__degrees) if d <= index]
if len(vars) == 0 :
return []
res = [ self.__module_basis[vars[0]] + m
for m in self.basis(index - self.__degrees[vars[0]], vars) ]
res += self.basis(index, vars[1:])
return res
def subgrading(self, gens) :
"""
The grading of same type for the ring with only the variables given by
``gens``.
INPUT:
- ``gens`` - A list of integers.
OUTPUT:
An instance of :class:~`.DegreeGrading`.
TESTS::
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import *
sage: g = DegreeGrading([5,2,3])
sage: g.subgrading([2])
Degree grading (3,)
sage: g.subgrading([])
Degree grading ()
"""
return DegreeGrading([self.__degrees[i] for i in gens])
def __contains__(self, x) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import *
sage: g = DegreeGrading([5,2,3])
sage: 5 in g
True
sage: "t" in g
False
"""
return isinstance(x, (int, Integer))
def __cmp__(self, other) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import *
sage: g = DegreeGrading([5,2,3])
sage: g == DegreeGrading([5,2,3])
True
sage: g == DegreeGrading((2,4))
False
"""
c = cmp(type(self), type(other))
if c == 0 :
c = cmp(self.__degrees, other.__degrees)
return c
def __hash__(self) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import *
sage: hash( DegreeGrading([5,2,3]) )
-1302562269 # 32-bit
7573306103633312291 # 64-bit
"""
return hash(self.__degrees)
def _repr_(self) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import *
sage: DegreeGrading([5,2,3])
Degree grading (5, 2, 3)
"""
return "Degree grading %s" % str(self.__degrees)
def _latex_(self) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import *
sage: latex( DegreeGrading([5,2,3]) )
Degree grading $\left(5, 2, 3\right)$
"""
return "Degree grading $%s$" % latex(self.__degrees)
class TrivialGrading ( Grading_abstract ) :
"""
A grading for a polynomial ring `R[x_1, .., x_n]` assigning to every
element the same, arbitrary index.
"""
def __init__(self, nmb_generators, index) :
"""
INPUT:
- ``nmb_generators`` -- A positive integer; The number `n` of
variables of the graded polynomial ring.
- ``index`` -- An arbitrary object; The index assigned to
all monomials.
TESTS::
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import *
sage: g = TrivialGrading( 3, "t" )
sage: g = TrivialGrading( 3, None )
"""
self.__ngens = nmb_generators
self.__index = index
def ngens(self) :
"""
The number of generators of the polynomial ring.
OUTPUT:
An integer.
TESTS::
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import *
sage: TrivialGrading( 3, "t" ).ngens()
3
"""
return self.__ngens
def gen(self, i) :
"""
The number of generators of the polynomial ring.
OUTPUT:
An arbitrary object.
TESTS::
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import *
sage: TrivialGrading( 3, "t" ).gen(2)
't'
sage: TrivialGrading( 3, "t" ).gen(3)
Traceback (most recent call last):
...
ValueError: Generator 3 does not exist.
"""
if i < self.__ngens :
return self.__index
raise ValueError("Generator %s does not exist." % (i,))
def gens(self) :
"""
The gradings of the generators of the polynomial ring.
OUTPUT:
A tuple of objects of arbitrary but equal type.
TESTS::
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import *
sage: TrivialGrading( 3, "t" ).gens()
('t', 't', 't')
"""
return tuple(self.__ngens*[self.__index])
def index(self, x) :
"""
The grading value of `x` with respect to this grading.
INPUT:
- `x` -- A tuple of length `n`.
OUTPUT:
A grading index.
TESTS::
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import *
sage: TrivialGrading( 3, "t" ).index((1,0,1))
't'
sage: TrivialGrading( 3, "t" ).index((1,0))
Traceback (most recent call last):
...
ValueError: Tuple must have length 3.
"""
if len(x) != self.__ngens :
raise ValueError( "Tuple must have length %s." % (self.__ngens,))
return self.__index
def basis(self, index, vars = None) :
"""
All degree one monomials that are have given grading index involving only the
given variables.
INPUT:
- ``index`` -- A grading index.
- ``vars`` -- A list of integers from `0` to `n - 1` or ``None``
(default: ``None``); If ``None`` all variables
will be considered.
OUTPUT:
A list of tuples of integers, each of which has length `n`.
TESTS::
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import *
sage: TrivialGrading( 3, "t" ).basis('t')
[(1, 0, 0), (0, 1, 0), (0, 0, 1)]
sage: TrivialGrading( 3, "t" ).basis( None )
[]
"""
if index == self.__index :
if vars is None :
vars = range(self.__ngens)
return [ tuple(i*[0] + [1] + (self.__ngens - i - 1)*[0])
for i in vars ]
else :
return []
def subgrading(self, gens) :
"""
The grading of same type for the ring with only the variables given by
``gens``.
INPUT:
- ``gens`` - A list of integers.
OUTPUT:
An instance of :class:~`.TrivialGrading`.
TESTS::
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import *
sage: TrivialGrading( 3, "t" ).subgrading([1,2])
Trivial grading on 2 generators with index 't'
sage: TrivialGrading( 3, "t" ).subgrading([])
Trivial grading on 0 generators with index 't'
"""
return TrivialGrading(len(gens), self.__index)
def __contains__(self, x) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import *
sage: g = TrivialGrading( 3, "t" )
sage: "t" in g
True
sage: (1,2,1) in g
False
sage: None in g
False
"""
return x == self.__index
def __cmp__(self, other) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import *
sage: g = TrivialGrading( 3, "t" )
sage: g == TrivialGrading( 3, "t" )
True
sage: g == TrivialGrading( 2, "t" )
False
sage: g == TrivialGrading( 3, None )
False
"""
c = cmp(type(self), type(other))
if c == 0 :
c = cmp(self.__ngens, other.__ngens)
if c == 0 :
c = cmp(self.__index, other.__index)
return c
def __hash__(self) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import *
sage: hash( TrivialGrading( 3, "t" ) )
1963142774 # 32-bit
14848044662 # 64-bit
"""
return reduce(xor, map(hash, [self.__ngens, self.__index]))
def _repr_(self) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import *
sage: TrivialGrading( 3, "t" )
Trivial grading on 3 generators with index 't'
"""
return "Trivial grading on %s generators with index %s" \
% (self.__ngens, repr(self.__index))
def _latex_(self) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import *
sage: latex( TrivialGrading( 3, "t" ) )
Trivial grading on $3$ generators with index $\texttt{t}$
"""
return "Trivial grading on $%s$ generators with index $%s$" \
% (latex(self.__ngens), latex(self.__index))
| Python |
"""
Functors for ring and modules of graded expansions.
AUTHOR :
-- Martin Raum (2009 - 07 - 27) Initial version
"""
#===============================================================================
#
# Copyright (C) 2009 Martin Raum
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 3
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, see <http://www.gnu.org/licenses/>.
#
#===============================================================================
from itertools import groupby, dropwhile
from sage.algebras.algebra import Algebra
from sage.categories.morphism import Morphism
from sage.categories.pushout import ConstructionFunctor, pushout
from sage.categories.rings import Rings
from sage.misc.misc import prod
from sage.modules.module import Module
from sage.rings.integer import Integer
from sage.structure.sequence import Sequence
import operator
#===============================================================================
# GradedExpansionFunctor
#===============================================================================
class GradedExpansionFunctor ( ConstructionFunctor ) :
"""
Constructing a graded expansion ring or module from a base ring.
"""
rank = 10
def __init__( self, base_ring_generators, generators,
relations, grading, all_relations = True, reduce_before_evaluating = True ) :
"""
INPUT:
- ``base_ring_generators`` -- A sequence of (equivariant) monoid power series with
coefficient domain the base ring of the coefficient
domain of the generators or ``None``.
- ``generators`` -- A sequence of (equivariant) monoid power series; The generators
of the ambient over the ring generated by the base ring
generators.
- ``relations`` -- An ideal in a polynomial ring with ``len(base_ring_generators) + len(generators)``
variables.
- ``grading`` -- A grading deriving from :class:~`fourier_expansion_framework.gradedexpansions.gradedexpansion_grading`;
A grading for the polynomial ring of the relations.
- ``all_relations`` -- A boolean (default: ``True``); If ``True`` the relations given
for the polynomial ring are all relations that the Fourier
expansion have.
- ``reduce_before_evaluating`` -- A boolean (default: ``True``); If ``True`` any monomial
will be Groebner reduced before the Fourier expansion
is calculated.
NOTE:
The grading must respect the relations of the generators.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_functor import *
sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
sage: funct = GradedExpansionFunctor(Sequence([MonoidPowerSeries(mps, {1: 1}, mps.monoid().filter(4))]), Sequence([MonoidPowerSeries(mps, {1: 1, 2: 3}, mps.monoid().filter(4))]), PolynomialRing(QQ, ['a', 'b']).ideal(0), DegreeGrading((1,2)))
"""
if grading.ngens() != relations.ring().ngens() :
raise ValueError( "Grading must have the same number of variables as the relations' polynomial ring." )
self.__relations = relations
self.__grading = grading
self.__all_relations = all_relations
self.__reduce_before_evaluating = reduce_before_evaluating
self.__gen_expansions = Sequence(generators)
if base_ring_generators is None :
self.__base_gen_expansions = Sequence([], universe = self.__gen_expansions.universe().base_ring())
else :
self.__base_gen_expansions = Sequence(base_ring_generators)
if len(self.__base_gen_expansions) == 0 :
scalar_ring = self.__gen_expansions.universe().base_ring()
if self.__gen_expansions.universe().coefficient_domain() != self.__gen_expansions.universe().base_ring() :
scalar_ring = self.__gen_expansions.universe().base_ring().base_ring()
else :
scalar_ring = self.__gen_expansions.universe().base_ring()
else :
scalar_ring = self.__base_gen_expansions.universe().base_ring()
if not relations.base_ring().has_coerce_map_from(scalar_ring) :
raise ValueError( "The generators must be defined over the base ring of relations" )
if not isinstance(self.__gen_expansions.universe(), Algebra) and \
not isinstance(self.__gen_expansions.universe(), Module) :
raise TypeError( "The generators' universe must be an algebra or a module" )
ConstructionFunctor.__init__( self, Rings(), Rings() )
def __call__(self, R) :
"""
The graded expansion ring with the given generators over the base
ring `R`.
INPUT:
- `R` -- A ring.
OUTPUT:
An instance of :class:~`fourier_expansion_framework.gradedexpansions.gradedexpansion_ambient.GradedExpansion_abstract`.
NOTE:
The ring of Fourier expansions given by the generators associated
with this functor must admit a base extension to `R`.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_module import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_functor import *
sage: K.<rho> = CyclotomicField(6)
sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
sage: funct = GradedExpansionFunctor(Sequence([MonoidPowerSeries(mps, {1: 1}, mps.monoid().filter(4))]), Sequence([MonoidPowerSeries(mps, {1: 1, 2: 3}, mps.monoid().filter(4))]), PolynomialRing(QQ, ['a', 'b']).ideal(0), DegreeGrading((1,2)))
sage: funct(K)
Graded expansion ring with generators b
sage: m = FreeModule(QQ, 3)
sage: mpsm = MonoidPowerSeriesModule(m, NNMonoid(False))
sage: mps = mpsm.base_ring()
sage: funct = GradedExpansionFunctor(None, Sequence([MonoidPowerSeries(mpsm, {1 : m([1,2,3]), 2 : m([3,-3,2])}, mpsm.monoid().filter(4)), MonoidPowerSeries(mpsm, {1 : m([2,-1,-1]), 2 : m([1,0,0])}, mpsm.monoid().filter(4))]), PolynomialRing(QQ, ['a', 'b']).ideal(0), DegreeGrading((1,2)))
sage: funct(K)
Graded expansion module with generators a, b
"""
from gradedexpansion_ring import GradedExpansionRing_class
from gradedexpansion_module import GradedExpansionModule_class
R = pushout(self.__relations.ring(), R)
rel = R.ideal(self.__relations.gens())
if isinstance(self.__gen_expansions.universe(), Algebra) :
return GradedExpansionRing_class( self.__base_gen_expansions, self.__gen_expansions,
rel, self.__grading, self.__all_relations, self.__reduce_before_evaluating )
elif isinstance(self.__gen_expansions.universe(), Module) :
return GradedExpansionModule_class( self.__base_gen_expansions, self.__gen_expansions,
rel, self.__grading, self.__all_relations, self.__reduce_before_evaluating )
raise RuntimeError( "The generators' universe must be an algebra or a module." )
def __cmp__(self, other) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_functor import *
sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
sage: funct = GradedExpansionFunctor(Sequence([MonoidPowerSeries(mps, {1: 1}, mps.monoid().filter(4))]), Sequence([MonoidPowerSeries(mps, {1: 1, 2: 3}, mps.monoid().filter(4))]), PolynomialRing(QQ, ['a', 'b']).ideal(0), DegreeGrading((1,2)))
sage: funct == GradedExpansionFunctor(Sequence([MonoidPowerSeries(mps, {1: 1}, mps.monoid().filter(4))]), Sequence([MonoidPowerSeries(mps, {1: 1, 2: 3}, mps.monoid().filter(4))]), PolynomialRing(QQ, ['a', 'b']).ideal(0), DegreeGrading((1,2)))
True
sage: funct == GradedExpansionFunctor(None, Sequence([MonoidPowerSeries(mps, {1 : 4, 2 : 3}, mps.monoid().filter(4)), MonoidPowerSeries(mps, {1 : 1, 2 : 3}, mps.monoid().filter(4))]), PolynomialRing(QQ, ['a', 'b']).ideal(0), DegreeGrading((1,3)))
False
sage: P.<a,b> = PolynomialRing(QQ)
sage: funct == GradedExpansionFunctor(None, Sequence([MonoidPowerSeries(mps, {1 : 4, 2 : 3}, mps.monoid().filter(4)), MonoidPowerSeries(mps, {1 : 1, 2 : 3}, mps.monoid().filter(4))]), P.ideal(a^2 - b), DegreeGrading((1,2)))
False
sage: funct == GradedExpansionFunctor(None, Sequence([MonoidPowerSeries(mps, {1 : 4, 2 : 3}, mps.monoid().filter(4)), MonoidPowerSeries(mps, {1 : 1, 2 : 4}, mps.monoid().filter(4))]), PolynomialRing(QQ, ['a', 'b']).ideal(0), DegreeGrading((1,2)))
False
sage: funct == GradedExpansionFunctor(Sequence([MonoidPowerSeries(mps, {1 : 4}, mps.monoid().filter(4))]), Sequence([MonoidPowerSeries(mps, {1 : 4, 2 : 3}, mps.monoid().filter(4)), MonoidPowerSeries(mps, {1 : 1, 2 : 3}, mps.monoid().filter(4))]), PolynomialRing(QQ, ['a', 'b', 'c']).ideal(0), DegreeGrading((1,2,2)))
False
"""
c = cmp(type(self), type(other))
if c == 0 :
c = cmp(self.__relations, other.__relations)
if c == 0 :
c = cmp(self.__all_relations, other.__all_relations)
if c == 0 :
c = cmp(self.__grading, other.__grading)
if c == 0 :
c = cmp(self.__base_gen_expansions, other.__base_gen_expansions)
if c == 0 :
c = cmp(self.__gen_expansions, other.__gen_expansions)
return c
def merge(self, other) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_functor import *
sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
sage: funct = GradedExpansionFunctor(Sequence([MonoidPowerSeries(mps, {1: 1}, mps.monoid().filter(4))]), Sequence([MonoidPowerSeries(mps, {1: 1, 2: 3}, mps.monoid().filter(4))]), PolynomialRing(QQ, ['a', 'b']).ideal(0), DegreeGrading((1,2)))
sage: funct.merge(funct) is None
False
sage: funct2 = GradedExpansionFunctor(Sequence([MonoidPowerSeries(mps, {1: 1}, mps.monoid().filter(4))]), Sequence([MonoidPowerSeries(mps, {1: 1, 2: 3}, mps.monoid().filter(4))]), PolynomialRing(QQ, ['a', 'b']).ideal(0), DegreeGrading((3,2)))
sage: funct.merge(funct2) is None
True
sage: funct2 = GradedExpansionFunctor(Sequence([MonoidPowerSeries(mps, {1: 1}, mps.monoid().filter(4))]), Sequence([MonoidPowerSeries(mps, {1: 1, 2: 2}, mps.monoid().filter(4))]), PolynomialRing(QQ, ['a', 'b']).ideal(0), DegreeGrading((1,2)))
sage: funct.merge(funct2) is None
True
sage: K.<rho> = CyclotomicField(6)
sage: funct2 = GradedExpansionFunctor(Sequence([MonoidPowerSeries(mps, {1: 1}, mps.monoid().filter(4))]), Sequence([MonoidPowerSeries(mps, {1: 1, 2: 3}, mps.monoid().filter(4))]), PolynomialRing(K, ['a', 'b']).ideal(0), DegreeGrading((1,2)))
sage: funct2.merge(funct) is None
False
"""
#TODO: Implement merging of base rings
if self == other :
return self
if self.__all_relations != other.__all_relations or \
self.__grading != other.__grading or \
self.__base_gen_expansions != other.__base_gen_expansions or \
self.__gen_expansions != other.__gen_expansions :
return None
if self.__relations.ring().has_coerce_map_from(other.__relations.ring()) and \
self.__relations == self.__relations.ring().ideal(other.__relations.gens()) :
return self
return None
#===============================================================================
# GradedExpansionBaseringInjection
#===============================================================================
class GradedExpansionBaseringInjection ( Morphism ) :
"""
The injection of the base ring into a ring of graded expansions.
"""
def __init__(self, domain, codomain ) :
"""
INPUT:
- ``domain`` -- A ring.
- ``codomain`` -- A ring of graded expansions.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_functor import *
sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
sage: ger = GradedExpansionRing_class(None, Sequence([MonoidPowerSeries(mps, {1: 1}, mps.monoid().filter(4)), MonoidPowerSeries(mps, {1: 1, 2: 3}, mps.monoid().filter(4))]), PolynomialRing(QQ, ['a', 'b']).ideal(0), DegreeGrading((1,2)))
sage: GradedExpansionBaseringInjection(QQ, ger)
Base ring injection of Graded expansion ring with generators a, b morphism:
From: Rational Field
To: Graded expansion ring with generators a, b
"""
Morphism.__init__(self, domain, codomain)
self._repr_type_str = "Base ring injection of %s" % (codomain,)
def _call_(self, x) :
"""
INPUT:
- `x` -- An element of the domain.
OUTPUT:
An element of the codomain.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_functor import *
sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
sage: ger = GradedExpansionRing_class(Sequence([MonoidPowerSeries(mps, {1: 1}, mps.monoid().filter(4))]), Sequence([MonoidPowerSeries(mps, {1: 1, 2: 3}, mps.monoid().filter(4))]), PolynomialRing(QQ, ['a', 'b']).ideal(0), DegreeGrading((1,2)))
sage: inj = GradedExpansionBaseringInjection(ger.base_ring(), ger)
sage: inj(ger.base_ring()(2))
Graded expansion 2
"""
return self.codomain()._element_constructor_(x)
def _call_with_args(self, x, *args, **kwds):
"""
INPUT:
- `x` -- An element of the domain.
- `args`` -- Will be forwarded to the codomain's element constructor.
- ``kwds`` -- Will be forwarded to the codomain's element constructor.
OUTPUT:
An element of the codomain.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_functor import *
sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
sage: ger = GradedExpansionRing_class(Sequence([MonoidPowerSeries(mps, {1: 1}, mps.monoid().filter(4))]), Sequence([MonoidPowerSeries(mps, {1: 1, 2: 3}, mps.monoid().filter(4))]), PolynomialRing(QQ, ['a', 'b']).ideal(0), DegreeGrading((1,2)))
sage: inj = GradedExpansionBaseringInjection(ger.base_ring(), ger)
sage: h = inj(ger.base_ring()(0))
"""
return self.codomain()._element_constructor_(x, *args, **kwds)
#===============================================================================
# GradedExpansionEvaluationHomomorphism
#===============================================================================
class GradedExpansionEvaluationHomomorphism ( Morphism ) :
"""
The evaluation of a polynomial by substituting the Fourier expansions
attached to a ring or module of graded expansions.
"""
def __init__(self, relations, base_ring_images, images, codomain, reduce = True) :
"""
INPUT:
- ``relations`` -- An ideal in a polynomial ring.
- ``base_ring_images`` -- A list or sequence of elements of a ring of (equivariant)
monoid power series.
- ``images`` -- A list or sequence of monoid power series.
- ``codomain`` -- An ambient of (equivariant) monoid power series.
- ``reduce`` -- A boolean (default: ``True``); If ``True`` polynomials will
be reduced before the substitution is carried out.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_functor import *
sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
sage: ev = GradedExpansionEvaluationHomomorphism(PolynomialRing(QQ, ['a', 'b']).ideal(0), Sequence([MonoidPowerSeries(mps, {1 : 1}, mps.monoid().filter(2))]), Sequence([MonoidPowerSeries(mps, {1 : 1, 2 : 3}, mps.monoid().filter(4))]), mps, False)
"""
self.__relations = relations
self.__base_ring_images = base_ring_images
self.__images = images
self.__reduce = reduce
Morphism.__init__(self, relations.ring(), codomain)
self._repr_type_str = "Evaluation homomorphism from %s to %s" % (relations.ring(), codomain)
def _call_with_args(self, x, *args, **kwds) :
"""
SEE:
:meth:~`._call_`.
NOTE:
``args`` and ``kwds`` will be ignored.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_functor import *
sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
sage: P.<a,b> = QQ[]
sage: ev = GradedExpansionEvaluationHomomorphism(P.ideal(0), Sequence([MonoidPowerSeries(mps, {1 : 1}, mps.monoid().filter(2))]), Sequence([MonoidPowerSeries(mps, {1 : 1, 2 : 3}, mps.monoid().filter(4))]), mps, False)
sage: h = ev(a, h = True)
"""
return self._call_(x)
def _call_(self, x) :
"""
INPUT:
- `x` -- A polynomial.
OUTPUT:
An element of the codomain.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_functor import *
sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
sage: P.<a,b> = QQ[]
sage: ev = GradedExpansionEvaluationHomomorphism(P.ideal(0), Sequence([MonoidPowerSeries(mps, {1 : 1}, mps.monoid().filter(2))]), Sequence([MonoidPowerSeries(mps, {1 : 1, 2 : 3}, mps.monoid().filter(4))]), mps, False)
sage: ev(a)
Monoid power series in Ring of monoid power series over NN
sage: ev = GradedExpansionEvaluationHomomorphism(P.ideal(a - b), Sequence([MonoidPowerSeries(mps, {1 : 1}, mps.monoid().filter(2))]), Sequence([MonoidPowerSeries(mps, {1 : 1, 2 : 3}, mps.monoid().filter(4))]), mps, True)
sage: ev(a - b).coefficients()
{0: 0}
"""
if self.__reduce :
x = self.__relations.reduce(x)
## Be careful not to directly substitute the elements of self.__images
## into the polynomial since they might be vectors, hence yielding
## an exception.
#=======================================================================
# if len(self.__base_ring_images) == 0 :
# parent = self.__images.universe()
# res = parent(0)
#
# for imexps,c in x.dict().iteritems() :
# if isinstance(imexps, int) :
# imexps = (imexps,)
# imexps = tuple(imexps)
#
# if imexps.count(0) == len(imexps) :
# res = res + c * parent(Integer(1))
# # this is the typical module case with an action
# # that does not respect the monoid structure
# elif imexps.count(0) == len(imexps) - 1 :
# i,e = dropwhile(lambda (_,e) : e == 0, enumerate(imexps)).next()
# if e == 1 :
# res = res + c * self.__images[i]
# else :
# res = res + c * self.__images[i]**e
# else :
# res = res + prod(map(operator.pow, self.__images, imexps))
#
# return res
#=======================================================================
expansion_ambient = self.__images.universe()
res = self.__images.universe().zero_element()
coeffs = x.dict()
xexps = groupby( sorted(x.exponents()),
lambda e: ([e] if isinstance(e, int) else list(e))[len(self.__base_ring_images):] )
for imexps, exps in xexps :
factor = self.__base_ring_images.universe().zero_element()
for e in exps :
factor = factor + coeffs[e] * prod(map( operator.pow, self.__base_ring_images,
([e] if isinstance(e,int) else e)[:len(self.__base_ring_images)] ))
imexps = tuple(imexps)
if imexps.count(0) == len(imexps) :
res = res + factor * expansion_ambient.one_element()
elif imexps.count(0) == len(imexps) - 1 :
i,e = dropwhile(lambda (_,e) : e == 0, enumerate(imexps)).next()
# this is the typical module case with an action
# that does not respect the monoid structure
if e == 1 :
res = res + factor * self.__images[i]
else :
res = res + factor * self.__images[i]**e
else :
res = res + factor * prod(map(operator.pow, self.__images, imexps))
return res
| Python |
"""
Ambients of elements with Fourier expansion and partially known relations.
AUTHOR :
-- Martin Raum (2010 - 03 - 10) Initial version
"""
#===============================================================================
#
# Copyright (C) 2010 Martin Raum
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 3
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, see <http://www.gnu.org/licenses/>.
#
#===============================================================================
from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_functor import \
GradedExpansionFunctor, GradedExpansionEvaluationHomomorphism
from operator import xor
from sage.misc.cachefunc import cached_method
from sage.misc.flatten import flatten
from sage.misc.misc import prod
from sage.rings.all import Integer
from sage.structure.element import Element
from sage.structure.parent import Parent
from sage.structure.sequence import Sequence
## late import in GradedExpansionAmbient_abstract
GradedExpansionSubmodule = None
GradedExpansionSubmodule_abstract = None
#===============================================================================
# GradedExpansionAmbient_abstract
#===============================================================================
class GradedExpansionAmbient_abstract :
"""
A ring of graded expansions. This is a polynomial ring with relations
and a mapping to an (equivariant) monoid power series. These should
respect the given relations, but there can me more relations of the
Fourier expansions that are stored for the polynomial ring.
"""
def __init__ ( self, base_ring_generators, generators, relations,
grading, all_relations = True, reduce_before_evaluating = True) :
"""
INPUT:
- ``base_ring_generators`` -- A sequence of (equivariant) monoid power series with
coefficient domain the base ring of the coefficient
domain of the generators or ``None``.
- ``generators`` -- A sequence of (equivariant) monoid power series; The generators
of the ambient over the ring generated by the base ring
generators.
- ``relations`` -- An ideal in a polynomial ring with ``len(base_ring_generators) + len(generators)``
variables.
- ``grading`` -- A grading deriving from :class:~`fourier_expansion_framework.gradedexpansions.gradedexpansion_grading`;
A grading for the polynomial ring of the relations.
- ``all_relations`` -- A boolean (default: ``True``); If ``True`` the relations given
for the polynomial ring are all relations that the Fourier
expansion have.
- ``reduce_before_evaluating`` -- A boolean (default: ``True``); If ``True`` any monomial
will be Groebner reduced before the Fourier expansion
is calculated.
NOTE:
The grading must respect the relations of the generators.
EXAMPLES::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
sage: ger = GradedExpansionRing_class(None, Sequence([mps(1)]), PolynomialRing(ZZ, 'a').ideal(0), DegreeGrading((1,))) # indirect doctest
sage: ger = GradedExpansionRing_class(Sequence([MonoidPowerSeries(mps, {1 : 1}, mps.monoid().filter(2))]), Sequence([MonoidPowerSeries(mps, {1 : 1, 2 : 3}, mps.monoid().filter(4))]), PolynomialRing(ZZ, ['a', 'b']).ideal(0), DegreeGrading((1,2))) # indirect doctest
sage: ger = GradedExpansionRing_class(Sequence([MonoidPowerSeries(mps, {1 : 1}, mps.monoid().filter(2))]), Sequence([MonoidPowerSeries(mps, {1 : 1, 2 : 3}, mps.monoid().filter(4))]), PolynomialRing(ZZ, ['a', 'b']).ideal(0), DegreeGrading((1,2)), all_relations = False) # indirect doctest
sage: ger = GradedExpansionRing_class(Sequence([MonoidPowerSeries(mps, {1 : 1}, mps.monoid().filter(2))]), Sequence([MonoidPowerSeries(mps, {1 : 1, 2 : 3}, mps.monoid().filter(4))]), PolynomialRing(ZZ, ['a', 'b']).ideal(0), DegreeGrading((1,2)), reduce_before_evaluating = False) # indirect doctest
"""
global GradedExpansionSubmodule, GradedExpansionSubmodule_abstract
from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_submodule import GradedExpansionSubmodule
from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_submodule import GradedExpansionSubmodule_abstract
self.__relations = relations
self.__all_relations = all_relations
self.__grading = grading
if base_ring_generators is None :
base_ring_generators = Sequence([], universe = generators.universe().base_ring())
self.__base_gens = \
tuple([ self.base_ring()._element_class( self.base_ring(), self.base_ring().relations().ring()(g) )
for g in self.__relations.ring().gens()[:len(base_ring_generators)]])
self.__gens = \
tuple([ self._element_class( self, g )
for g in self.__relations.ring().gens()[len(base_ring_generators):] ])
# We expect the base ring generators to either admit coercion
# into the universe of the generators or to act on it from the left
self.__base_gen_expansions = base_ring_generators
self.__gen_expansions = generators
self.__evaluation_hom = GradedExpansionEvaluationHomomorphism( self.__relations, self.__base_gen_expansions,
self.__gen_expansions, self.__gen_expansions.universe(),
reduce_before_evaluating )
self.__graded_submodules = dict()
def ngens(self) :
"""
The number of generators of ``self`` over the base expansion ring.
OUTPUT:
An integer.
EXAMPLES::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
sage: ger = GradedExpansionRing_class(None, Sequence([mps(1)]), PolynomialRing(ZZ, 'a').ideal(0), DegreeGrading((1,)))
sage: ger.ngens()
1
"""
return len(self.__gens)
def gen(self, i = 0) :
"""
The `i`-th generator of ``self`` over the base expansion ring.
INPUT:
- `i` -- An integer.
OUTPUT:
An instance of :class:~`fourier_expansion_framework.gradedexpansions.gradedexpansion_element.GradedExpansion_abstract`.
EXAMPLES::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
sage: ger = GradedExpansionRing_class(None, Sequence([mps(1)]), PolynomialRing(ZZ, 'a').ideal(0), DegreeGrading((1,)))
sage: ger.gen(0)
Graded expansion a
"""
return self.__gens[i]
def gens(self) :
"""
The generators of ``self`` over the base expansion ring.
OUTPUT:
A tuple of instances of :class:~`fourier_expansion_framework.gradedexpansions.gradedexpansion_element.GradedExpansion_abstract`.
EXAMPLES::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
sage: ger = GradedExpansionRing_class(None, Sequence([mps(1)]), PolynomialRing(ZZ, 'a').ideal(0), DegreeGrading((1,)))
sage: ger.gens()
(Graded expansion a,)
"""
return self.__gens
def nbasegens(self) :
"""
Number of generators of the base expansion ring.
OUTPUT:
An integer.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
sage: ger = GradedExpansionRing_class(None, Sequence([mps(1)]), PolynomialRing(ZZ, 'a').ideal(0), DegreeGrading((1,)))
sage: ger.nbasegens()
0
sage: ger = GradedExpansionRing_class(Sequence([MonoidPowerSeries(mps, {1 : 1}, mps.monoid().filter(2))]), Sequence([MonoidPowerSeries(mps, {1 : 1, 2 : 3}, mps.monoid().filter(4))]), PolynomialRing(ZZ, ['a', 'b']).ideal(0), DegreeGrading((1,2)))
sage: ger.nbasegens()
1
"""
return len(self.__base_gens)
def basegen(self, i) :
"""
The `i`-th generator of the base expansion ring.
INPUT:
- `i` -- An integer.
OUTPUT:
An instance of :class:~`fourier_expansion_framework.gradedexpansions.gradedexpansion_element.GradedExpansion_abstract`.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
sage: ger = GradedExpansionRing_class(None, Sequence([mps(1)]), PolynomialRing(ZZ, 'a').ideal(0), DegreeGrading((1,)))
sage: ger = GradedExpansionRing_class(Sequence([MonoidPowerSeries(mps, {1 : 1}, mps.monoid().filter(2))]), Sequence([MonoidPowerSeries(mps, {1 : 1, 2 : 3}, mps.monoid().filter(4))]), PolynomialRing(ZZ, ['a', 'b']).ideal(0), DegreeGrading((1,2)))
sage: ger.basegen(0)
Graded expansion a
"""
return self.__base_gens[i]
def basegens(self) :
"""
The generators of the base expansion ring.
OUTPUT:
A tuple of instances of :class:~`fourier_expansion_framework.gradedexpansions.gradedexpansion_element.GradedExpansion_abstract`.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
sage: ger = GradedExpansionRing_class(Sequence([MonoidPowerSeries(mps, {1 : 1}, mps.monoid().filter(2))]), Sequence([MonoidPowerSeries(mps, {1 : 1, 2 : 3}, mps.monoid().filter(4))]), PolynomialRing(ZZ, ['a', 'b']).ideal(0), DegreeGrading((1,2)))
sage: ger.basegens()
(Graded expansion a,)
"""
return self.__base_gens
def is_field(self) :
"""
OUTPUT:
A boolean.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
sage: ger = GradedExpansionRing_class(None, Sequence([mps(1)]), PolynomialRing(ZZ, 'a').ideal(0), DegreeGrading((1,)))
sage: ger.is_field()
False
"""
## Never delete this. It is called during intialisation of deriving classes
## over number fields and and causes coercion to fail.
return False
def grading(self) :
"""
The grading imposed on this ring.
OUTPUT:
An isntance of :class:~`fourier_expansion_framework.gradedexpansions.gradedexpansion_grading`.
EXAMPLES::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
sage: ger = GradedExpansionRing_class(Sequence([MonoidPowerSeries(mps, {1 : 1}, mps.monoid().filter(2))]), Sequence([MonoidPowerSeries(mps, {1 : 1, 2 : 3}, mps.monoid().filter(4))]), PolynomialRing(ZZ, ['a', 'b']).ideal(0), DegreeGrading((1,2)))
sage: ger.grading() == DegreeGrading((1,2))
True
"""
return self.__grading
def relations(self) :
"""
The relation of the generators of this ring with in the underlying
polynomial ring.
OUTPUT:
An ideal in a polynomial ring.
SEE:
all_relations_known
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
sage: ger = GradedExpansionRing_class(None, Sequence([mps(1)]), PolynomialRing(ZZ, 'a').ideal(0), DegreeGrading((1,)))
sage: ger.relations()
Principal ideal (0) of Univariate Polynomial Ring in a over Integer Ring
sage: P.<a,b,c> = PolynomialRing(ZZ)
sage: ger = GradedExpansionRing_class(Sequence([MonoidPowerSeries(mps, {1 : 1}, mps.monoid().filter(2))]), Sequence([MonoidPowerSeries(mps, {1 : 1, 2 : 3}, mps.monoid().filter(4))]), P.ideal(a*b - c), DegreeGrading((1,2)))
sage: ger.relations()
Ideal (a*b - c) of Multivariate Polynomial Ring in a, b, c over Integer Ring
"""
return self.__relations
def all_relations_known(self) :
"""
If ``True`` is returned any relation of the Fourier expansions associated
with elements of this ring - thought of as expansions with
infinite precision - implies that the relation is also contained
in ``self.relations()``.
OUTPUT:
A boolean.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
sage: ger = GradedExpansionRing_class(None, Sequence([mps(1)]), PolynomialRing(ZZ, 'a').ideal(0), DegreeGrading((1,)))
sage: ger.all_relations_known()
True
sage: ger = GradedExpansionRing_class(Sequence([MonoidPowerSeries(mps, {1 : 1}, mps.monoid().filter(2))]), Sequence([MonoidPowerSeries(mps, {1 : 1, 2 : 3}, mps.monoid().filter(4))]), PolynomialRing(ZZ, ['a', 'b']).ideal(0), DegreeGrading((1,2)), all_relations = False)
sage: ger.all_relations_known()
False
"""
return self.__all_relations
def has_relation_free_generators(self) :
"""
If ``True`` is returned, there are no relations of the Fourier
expansions - thought of as expansions with infinite precision.
OUTPUT:
A boolean.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
sage: ger = GradedExpansionRing_class(None, Sequence([mps(1)]), PolynomialRing(ZZ, 'a').ideal(0), DegreeGrading((1,))) # indirect doctest
sage: ger.has_relation_free_generators()
True
sage: ger = GradedExpansionRing_class(Sequence([MonoidPowerSeries(mps, {1 : 1}, mps.monoid().filter(2))]), Sequence([MonoidPowerSeries(mps, {1 : 1, 2 : 3}, mps.monoid().filter(4))]), PolynomialRing(ZZ, ['a', 'b']).ideal(0), DegreeGrading((1,2)), all_relations = False)
sage: ger.has_relation_free_generators()
False
sage: P.<a,b,c> = PolynomialRing(ZZ)
sage: ger = GradedExpansionRing_class(Sequence([MonoidPowerSeries(mps, {1 : 1}, mps.monoid().filter(2))]), Sequence([MonoidPowerSeries(mps, {1 : 1, 2 : 3}, mps.monoid().filter(4))]), P.ideal(a*b - c), DegreeGrading((1,2)))
sage: ger.has_relation_free_generators()
False
"""
return self.__all_relations and self.__relations.is_zero()
def _generator_expansions(self) :
"""
The generators' Fourier expansion within a common parent.
OUTPUT:
A sequence of of (equivariant) monoid power series.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
sage: ger = GradedExpansionRing_class(None, Sequence([mps(1)]), PolynomialRing(ZZ, 'a').ideal(0), DegreeGrading((1,)))
sage: ger._generator_expansions().universe()
Ring of monoid power series over NN
sage: ger._generator_expansions()[0].coefficients()
{0: 1}
"""
return self.__gen_expansions
def _base_generator_expansions(self) :
"""
The Fourier expansions of the generators of the base expansion ring.
OUTPUT:
A sequence of of (equivariant) monoid power series.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
sage: ger = GradedExpansionRing_class(None, Sequence([mps(1)]), PolynomialRing(ZZ, 'a').ideal(0), DegreeGrading((1,)))
sage: ger._base_generator_expansions().universe()
Rational Field
sage: ger = GradedExpansionRing_class(Sequence([MonoidPowerSeries(mps, {1 : 1}, mps.monoid().filter(2))]), Sequence([MonoidPowerSeries(mps, {1 : 1, 2 : 3}, mps.monoid().filter(4))]), PolynomialRing(ZZ, ['a', 'b']).ideal(0), DegreeGrading((1,2)))
sage: ger._base_generator_expansions()
[Monoid power series in Ring of monoid power series over NN]
"""
return self.__base_gen_expansions
@cached_method
def fourier_expansion_precision(self) :
"""
A precision which is obtained by all expansions of any element.
OUTPUT:
A filter for the Fourier expansion ambient's monoid or action.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
sage: ger = GradedExpansionRing_class(None, Sequence([mps(1)]), PolynomialRing(ZZ, 'a').ideal(0), DegreeGrading((1,)))
sage: ger.fourier_expansion_precision()
Filtered NN up to +Infinity
sage: ger = GradedExpansionRing_class(Sequence([MonoidPowerSeries(mps, {1 : 1}, mps.monoid().filter(2))]), Sequence([MonoidPowerSeries(mps, {1 : 1, 2 : 3}, mps.monoid().filter(4))]), PolynomialRing(ZZ, ['a', 'b']).ideal(0), DegreeGrading((1,2)))
sage: ger.fourier_expansion_precision()
Filtered NN up to 2
"""
return min([ g.precision() for g in self.__gen_expansions + self.__base_gen_expansions])
@cached_method
def fourier_ring(self) :
"""
The ring that Fourier expansions of all elements of this
ring will be contained in.
OUTPUT:
An ambient of (equivariant) monoid power series.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
sage: mps = MonoidPowerSeriesRing(ZZ, NNMonoid(False))
sage: ger = GradedExpansionRing_class(None, Sequence([mps(1)]), PolynomialRing(QQ, 'a').ideal(0), DegreeGrading((1,)))
sage: ger.fourier_ring()
Ring of monoid power series over NN
sage: ger = GradedExpansionRing_class(Sequence([MonoidPowerSeries(mps, {1 : 1}, mps.monoid().filter(2))]), Sequence([MonoidPowerSeries(mps, {1 : 1, 2 : 3}, mps.monoid().filter(4))]), PolynomialRing(ZZ, ['a', 'b']).ideal(0), DegreeGrading((1,2)))
sage: ger.fourier_ring()
Ring of monoid power series over NN
"""
if self.__gen_expansions.universe().base_ring() == self.base_ring() :
return self.__gen_expansions.universe()
else :
from sage.categories.pushout import pushout
if self.nbasegens() == 0 :
scalar_ring = self.base_ring()
else :
scalar_ring = self.base_ring().base_ring()
return pushout(self.__gen_expansions.universe(), scalar_ring)
#===========================================================================
# def precision(self) :
# """
# Return the minimal precision of any fourier expansion in this ring.
# """
# return min([g.precision() for g in self._generator_expansions()])
#===========================================================================
def _set_evaluation_hom(self, hom) :
"""
Set the homomorphism that maps every polynomial in the underlying
polynomial ring to its expansion.
INPUT:
- ``hom`` -- A morphism with domain a polynomial ring and
domain an ambient of (equivariant) monoid power series.
OUTPUT:
``None``.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
sage: ger = GradedExpansionRing_class(None, Sequence([mps(1)]), PolynomialRing(ZZ, 'a').ideal(0), DegreeGrading((1,)))
sage: ger2 = GradedExpansionRing_class(None, Sequence([mps(2)]), PolynomialRing(ZZ, 'a').ideal(0), DegreeGrading((1,)))
sage: ger2._set_evaluation_hom(ger._GradedExpansionAmbient_abstract__evaluation_hom)
sage: ger2.0.fourier_expansion().coefficients()
{0: 1}
"""
self.__evaluation_hom = hom
def _fourier_expansion_of_element(self, e) :
"""
The Fourier expansion of an element `e`.
INPUT:
- `e` -- An element of the ``self``.
OUTPUT:
A (equivariant) monoid power series.
SEE:
:class:~`.fourier_expansion_framework.gradedexpansions.fourierexpansionwrapper.FourierExpansionWrapper`.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
sage: ger = GradedExpansionRing_class(Sequence([MonoidPowerSeries(mps, {1 : 1}, mps.monoid().filter(2))]), Sequence([MonoidPowerSeries(mps, {1 : 1, 2 : 3}, mps.monoid().filter(4))]), PolynomialRing(QQ, ['a', 'b']).ideal(0), DegreeGrading((1,2)))
sage: ger.0.fourier_expansion() # indirect doctest
Monoid power series in Ring of monoid power series over NN
sage: (ger.basegens()[0]^2 * 2*ger.0).fourier_expansion() # indirect doctest
Monoid power series in Ring of monoid power series over NN
sage: (ger.basegens()[0] + 5*ger.0).fourier_expansion() # indirect doctest
Monoid power series in Ring of monoid power series over NN
"""
return self.__evaluation_hom(e.polynomial())
#===============================================================================
# def graded_submodules_are_free(self) :
# """
# If ``True`` is returned, there are no relations within the module
# formed by the Fourier expansions - thought of as expansions with
# infinite precision - for a fixed grading value.
#
# OUTPUT:
# A boolean.
#
# TESTS::
# sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
# sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
# sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
# sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
# sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
# sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
# sage: ger = GradedExpansionRing_class(None, Sequence([mps(1)]), PolynomialRing(ZZ, 'a').ideal(0), DegreeGrading((1,)))
# sage: ger.graded_submodules_are_free()
# False
# """
# return False
#===============================================================================
def _graded_monoms(self, index) :
"""
Return all monoms in the generators that have a given grading index.
INPUT:
- ``index`` -- A grading values.
OUTPUT:
A list of elements of ``self``.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
sage: ger = GradedExpansionRing_class(None, Sequence([MonoidPowerSeries(mps, {1 : 4, 2 : 3}, mps.monoid().filter(4)), MonoidPowerSeries(mps, {1 : 1, 2 : 3}, mps.monoid().filter(4))]), PolynomialRing(ZZ, ['a', 'b']).ideal(0), DegreeGrading((1,2)))
sage: GradedExpansionAmbient_abstract._graded_monoms(ger, 3)
Traceback (most recent call last):
...
NotImplementedError
"""
raise NotImplementedError
def graded_submodule(self, indices, **kwds) :
"""
The submodule which contains all elements of given
grading values.
INPUT:
- ``indices`` -- A list or tuple of grading values or a single grading value.
- ``**kwds`` -- A dictionary of keywords; They will be passed to the
submodule constructor.
OUTPUT:
An instance of :class:~`fourier_expansion_framework.gradedexpansions.gradedexpansion_submodule.GradedExpansionSubmodule_abstract`.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_module import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_module import *
sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
sage: ger = GradedExpansionRing_class(None, Sequence([MonoidPowerSeries(mps, {1 : 4, 2 : 3}, mps.monoid().filter(4)), MonoidPowerSeries(mps, {1 : 1, 2 : 3}, mps.monoid().filter(4))]), PolynomialRing(ZZ, ['a', 'b']).ideal(0), DegreeGrading((1,2)))
sage: sm = ger.graded_submodule(2)
sage: ger = GradedExpansionRing_class(None, Sequence([MonoidPowerSeries(mps, {1 : 4, 2 : 3}, mps.monoid().filter_all()), MonoidPowerSeries(mps, {1 : 1, 2 : 3}, mps.monoid().filter_all())]), PolynomialRing(ZZ, ['a', 'b']).ideal(0), DegreeGrading((1,2)))
sage: sm = ger.graded_submodule(3)
sage: P.<a,b,c> = PolynomialRing(QQ)
sage: ger = GradedExpansionRing_class(None, Sequence([MonoidPowerSeries(mps, {1 : 4, 2 : 3}, mps.monoid().filter_all()), MonoidPowerSeries(mps, {1 : 1, 2 : 3}, mps.monoid().filter_all()), MonoidPowerSeries(mps, {2 : 1, 3: 6, 4 : 9}, mps.monoid().filter_all())]), P.ideal(b^2 - c), DegreeGrading((1,2)))
sage: sm = ger.graded_submodule(4)
sage: m = FreeModule(QQ, 3)
sage: mpsm = MonoidPowerSeriesModule(m, NNMonoid(False))
sage: mps = mpsm.base_ring()
sage: ger = GradedExpansionModule_class(None, Sequence([MonoidPowerSeries(mpsm, {1 : m([1,2,3]), 2 : m([3,-3,2])}, mpsm.monoid().filter(4)), MonoidPowerSeries(mpsm, {1 : m([2,-1,-1]), 2 : m([1,0,0])}, mpsm.monoid().filter(4))]), PolynomialRing(ZZ, ['a', 'b']).ideal(0), DegreeGrading((1,2)))
sage: ger.graded_submodule(4).rank()
0
"""
#=======================================================================
# if not self.graded_submodules_are_free() :
# raise ValueError( "Graded submodules of must be free." )
#=======================================================================
if indices in self.grading() :
indices = tuple([indices])
elif isinstance(indices, list) :
indices = tuple(indices)
elif not isinstance(indices, tuple) :
raise TypeError( "Wrong type of indices." )
try :
return self.__graded_submodules[indices]
except KeyError :
pass
module_gens = flatten(map(self._graded_monoms, indices), max_level = 1)
if self.has_relation_free_generators() :
basis = module_gens
else :
module_gens_poly = map(lambda g: g.polynomial(), module_gens)
basis = list()
I = self.relations().ring().zero_ideal()
for i,g in enumerate(module_gens_poly) :
rg = I.reduce(g)
if not rg.is_zero() :
I = I.ring().ideal([rg] + list(I.gens_reduced()))
basis.append(module_gens[i])
self.__graded_submodules[indices] = self._submodule(basis, grading_indices = indices, **kwds)
return self.__graded_submodules[indices]
def _submodule(self, arg, *args, **kwds) :
"""
Return a submodule of ``self``.
INPUT:
- `arg` -- A list of elements of ``self``.
OUTPUT:
An instance of :class:~`fourier_expansion_framework.gradedexpansions.gradedexpansion_submodule.GradedExpansionSubmodule_abstract`.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
sage: ger = GradedExpansionRing_class(None, Sequence([MonoidPowerSeries(mps, {1 : 4, 2 : 3}, mps.monoid().filter(4)), MonoidPowerSeries(mps, {1 : 1, 2 : 3}, mps.monoid().filter(4))]), PolynomialRing(ZZ, ['a', 'b']).ideal(0), DegreeGrading((1,2)))
sage: sm = ger.graded_submodule(2) # indirect doctest
"""
if isinstance(arg, list) :
return GradedExpansionSubmodule(self, arg)
else :
raise NotImplementedError
def __cmp__(self, other) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
sage: ger = GradedExpansionRing_class(None, Sequence([MonoidPowerSeries(mps, {1 : 4, 2 : 3}, mps.monoid().filter(4)), MonoidPowerSeries(mps, {1 : 1, 2 : 3}, mps.monoid().filter(4))]), PolynomialRing(QQ, ['a', 'b']).ideal(0), DegreeGrading((1,2)))
sage: ger == GradedExpansionRing_class(None, Sequence([MonoidPowerSeries(mps, {1 : 4, 2 : 3}, mps.monoid().filter(4)), MonoidPowerSeries(mps, {1 : 1, 2 : 3}, mps.monoid().filter(4))]), PolynomialRing(QQ, ['a', 'b']).ideal(0), DegreeGrading((1,2)))
True
sage: ger == GradedExpansionRing_class(None, Sequence([MonoidPowerSeries(mps, {1 : 4, 2 : 3}, mps.monoid().filter(4)), MonoidPowerSeries(mps, {1 : 1, 2 : 3}, mps.monoid().filter(4))]), PolynomialRing(QQ, ['a', 'b']).ideal(0), DegreeGrading((1,3)))
False
sage: P.<a,b> = PolynomialRing(QQ)
sage: ger == GradedExpansionRing_class(None, Sequence([MonoidPowerSeries(mps, {1 : 4, 2 : 3}, mps.monoid().filter(4)), MonoidPowerSeries(mps, {1 : 1, 2 : 3}, mps.monoid().filter(4))]), P.ideal(a^2 - b), DegreeGrading((1,2)))
False
sage: ger == GradedExpansionRing_class(None, Sequence([MonoidPowerSeries(mps, {1 : 4, 2 : 3}, mps.monoid().filter(4)), MonoidPowerSeries(mps, {1 : 1, 2 : 4}, mps.monoid().filter(4))]), PolynomialRing(QQ, ['a', 'b']).ideal(0), DegreeGrading((1,2)))
False
sage: ger == GradedExpansionRing_class(Sequence([MonoidPowerSeries(mps, {1 : 4}, mps.monoid().filter(4))]), Sequence([MonoidPowerSeries(mps, {1 : 4, 2 : 3}, mps.monoid().filter(4)), MonoidPowerSeries(mps, {1 : 1, 2 : 3}, mps.monoid().filter(4))]), PolynomialRing(QQ, ['a', 'b', 'c']).ideal(0), DegreeGrading((1,2,2)))
False
"""
c = cmp(type(self), type(other))
if c == 0 :
c = cmp(self.__relations, other.__relations)
if c == 0 :
c = cmp(self.__all_relations, other.__all_relations)
if c == 0 :
c = cmp(self.__grading, other.__grading)
if c == 0 :
c = cmp(self.__base_gen_expansions, other.__base_gen_expansions)
if c == 0 :
c = cmp(self.__gen_expansions, other.__gen_expansions)
return c
def construction(self) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
sage: ger = GradedExpansionRing_class(None, Sequence([MonoidPowerSeries(mps, {1 : 4, 2 : 3}, mps.monoid().filter(4)), MonoidPowerSeries(mps, {1 : 1, 2 : 3}, mps.monoid().filter(4))]), PolynomialRing(QQ, ['a', 'b']).ideal(0), DegreeGrading((1,2)))
sage: (F, A) = ger.construction()
sage: ger == F(A)
True
"""
return ( GradedExpansionFunctor(self.__base_gen_expansions, self.__gen_expansions,
self.__relations, self.__grading, self.__all_relations ), \
self.base_ring() )
def _element_constructor_(self, x) :
"""
INPUT:
- `x` -- An element of the underlying polynomial ring or
an element in a submodule of graded expansions.
OUTPUT:
An instance of the element class.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_module import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_module import *
sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
sage: ger = GradedExpansionRing_class(Sequence([MonoidPowerSeries(mps, {1: 1}, mps.monoid().filter(4))]), Sequence([MonoidPowerSeries(mps, {1: 1, 2: 3}, mps.monoid().filter(4))]), PolynomialRing(QQ, ['a', 'b']).ideal(0), DegreeGrading((1,2)))
sage: h = ger(PolynomialRing(QQ, ['a', 'b']).gen(0))
sage: sm = ger.graded_submodule(3)
sage: h = ger(sm.0)
sage: m = FreeModule(QQ, 3)
sage: mpsm = MonoidPowerSeriesModule(m, NNMonoid(False))
sage: mps = mpsm.base_ring()
sage: ger = GradedExpansionModule_class(Sequence([MonoidPowerSeries(mps, {1: 1}, mps.monoid().filter(4))]), Sequence([MonoidPowerSeries(mpsm, {1: m([1,1,1]), 2: m([1,3,-3])}, mpsm.monoid().filter(4))]), PolynomialRing(QQ, ['a', 'b']).ideal(0), DegreeGrading((1,2)))
sage: h = ger(PolynomialRing(QQ, ['a', 'b']).gen(1))
sage: sm = ger.graded_submodule(3)
sage: h = ger(sm.0)
"""
if isinstance(x, Element) :
P = x.parent()
if P is self.relations().ring() :
return self._element_class(self, x)
elif isinstance(P, GradedExpansionSubmodule_abstract) :
if self is P.graded_ambient() :
return P._graded_expansion_submodule_to_graded_ambient_(x)
elif self.has_coerce_map_from(P.graded_ambient()) :
return self(P.graded_ambient()(x))
## We cannot handle base extensions here, because we don't know anything
## about additional relations which may occur. So deriving classes have
## to care about this.
raise TypeError( "The element %s cannot be converted into %s," % (x, self) )
def __hash__(self) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
sage: ger = GradedExpansionRing_class(None, Sequence([MonoidPowerSeries(mps, {1 : 4, 2 : 3}, mps.monoid().filter(4)), MonoidPowerSeries(mps, {1 : 1, 2 : 3}, mps.monoid().filter(4))]), PolynomialRing(QQ, ['a', 'b']).ideal(0), DegreeGrading((1,2)))
sage: hash(ger)
921050467 # 32-bit
3906772531912514915 # 64-bit
"""
return reduce(xor, map(hash, [self.__grading, self.__relations,
self.__all_relations, self.__base_gens, self.__gens]) )
| Python |
"""
Elements wrapping a Fourier expansion which partially known relations.
AUTHOR :
-- Martin Raum (2009 - 07 - 27) Initial version
"""
#===============================================================================
#
# Copyright (C) 2009 Martin Raum
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 3
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, see <http://www.gnu.org/licenses/>.
#
#===============================================================================
from psage.modform.fourier_expansion_framework.gradedexpansions.fourierexpansionwrapper import FourierExpansionWrapper
from itertools import groupby
from sage.algebras.algebra_element import AlgebraElement
from sage.misc.all import prod
from sage.misc.latex import latex
from sage.modules.module_element import ModuleElement
from sage.rings.infinity import infinity
import operator
#===============================================================================
# GradedExpansion_abstract
#===============================================================================
class GradedExpansion_abstract ( FourierExpansionWrapper ) :
"""
An abstract graded expansion.
"""
def __init__(self, parent, polynomial) :
"""
INPUT:
- ``parent`` -- An instance of :class:~`fourier_expansion_framework.gradedexpansions.gradedexpansion_ambient.GradedExpansionAmbient_abstract`.
- ``polynomial`` -- A polynomial in the polynomial ring underlying the parent.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_element import *
sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
sage: P.<a,b> = QQ[]
sage: ger = GradedExpansionRing_class(Sequence([MonoidPowerSeries(mps, {1: 1}, mps.monoid().filter(4))]), Sequence([MonoidPowerSeries(mps, {1: 1, 2: 3}, mps.monoid().filter(4))]), P.ideal(0), DegreeGrading((1,2)))
sage: h = GradedExpansion_abstract(ger, P(0))
sage: h = GradedExpansion_abstract(ger, a*b)
"""
self.__polynomial = polynomial
def polynomial(self) :
"""
The underlying polynomial.
OUTPUT:
A polynomial in the polynomial ring underlying the parent.
NOTE:
This polynomial might change by elements of the parent's
relation ideal.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_element import *
sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
sage: P.<a,b> = QQ[]
sage: ger = GradedExpansionRing_class(Sequence([MonoidPowerSeries(mps, {1: 1}, mps.monoid().filter(4))]), Sequence([MonoidPowerSeries(mps, {1: 1, 2: 3}, mps.monoid().filter(4))]), P.ideal(0), DegreeGrading((1,2)))
sage: h = GradedExpansion_abstract(ger, a * b)
sage: h.polynomial()
a*b
"""
return self.__polynomial
def _reduce_polynomial(self, set_polynomial = True) :
"""
The Groebner reduced underlying polynomial.
INPUT:
- ``set_polynomial`` -- A boolean (default: ``True``); If ``True``
the underlying polynomial will be set to the
reduced polynomial.
OUTPUT:
A polynomial in the polynomial ring underlying the parent.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_element import *
sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
sage: P.<a,b> = QQ[]
sage: ger = GradedExpansionRing_class(Sequence([MonoidPowerSeries(mps, {1: 1}, mps.monoid().filter(4))]), Sequence([MonoidPowerSeries(mps, {1: 1, 2: 3}, mps.monoid().filter(4))]), P.ideal(a - b), DegreeGrading((1,2)))
sage: h = GradedExpansion_class(ger, a - b)
sage: h._reduce_polynomial(set_polynomial = False)
0
sage: h.polynomial()
a - b
sage: h._reduce_polynomial()
0
sage: h.polynomial()
0
"""
if set_polynomial :
self.__polynomial = self.parent().relations().reduce(self.__polynomial)
return self.__polynomial
else :
return self.parent().relations().reduce(self.__polynomial)
def homogeneous_components(self) :
"""
Split the underlying polynomial with respect to grading imposed on
the parent.
OUTPUT:
A dictionary with key the grading values and values the polynomials.
EXAMPLES::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_element import *
sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
sage: P.<a,b> = QQ[]
sage: ger = GradedExpansionRing_class(Sequence([MonoidPowerSeries(mps, {1: 1}, mps.monoid().filter(4))]), Sequence([MonoidPowerSeries(mps, {1: 1, 2: 3}, mps.monoid().filter(4))]), P.ideal(0), DegreeGrading((1,2)))
sage: h = GradedExpansion_class(ger, a - b)
sage: h.homogeneous_components()
{1: a, 2: -b}
TESTS::
sage: h = GradedExpansion_class(ger, P(0))
sage: h.homogeneous_components()
{}
"""
if self.__polynomial.is_zero() :
return dict()
components = dict()
grading = self.parent().grading().index
if self.__polynomial.parent().ngens() == 1 :
normalize = lambda e: (e,)
var = self.__polynomial.parent().gen(0)
monomial = lambda e: var**e
else :
normalize = lambda e: e
vars = self.__polynomial.parent().gens()
monomial = lambda e: prod( map(operator.pow, vars, e) )
for e in self.__polynomial.exponents() :
ne = normalize(e)
m = monomial(e)
try :
components[grading(ne)] = components[grading(ne)] + m * self.__polynomial[e]
except KeyError :
components[grading(ne)] = m * self.__polynomial[e]
return components
def exponents(self) :
"""
The exponents of the underlying polynomial.
OUTPUT:
A list of tuples.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_element import *
sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
sage: P.<a,b> = QQ[]
sage: ger = GradedExpansionRing_class(Sequence([MonoidPowerSeries(mps, {1: 1}, mps.monoid().filter(4))]), Sequence([MonoidPowerSeries(mps, {1: 1, 2: 3}, mps.monoid().filter(4))]), P.ideal(a - b), DegreeGrading((1,2)))
sage: h = GradedExpansion_abstract(ger, a - b)
sage: h.exponents()
[(1, 0), (0, 1)]
sage: P.<a> = QQ[]
sage: ger = GradedExpansionRing_class(None, Sequence([MonoidPowerSeries(mps, {1: 1, 2: 3}, mps.monoid().filter(4))]), P.ideal(0), DegreeGrading((1,)))
sage: h = GradedExpansion_abstract(ger, a)
sage: h.exponents()
[(1,)]
"""
if self.polynomial().parent().ngens() == 1 :
return map(lambda e: (e,), self.polynomial().exponents())
else :
return map(tuple, self.polynomial().exponents())
def grading_index(self) :
"""
If ``self`` is homogeneous, return the index of ``self`` with respect to
the grading imposed on the parent. Otherwise, a ``ValueError`` is raised.
OUTPUT:
A grading value.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_element import *
sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
sage: P.<a,b> = QQ[]
sage: ger = GradedExpansionRing_class(Sequence([MonoidPowerSeries(mps, {1: 1}, mps.monoid().filter(4))]), Sequence([MonoidPowerSeries(mps, {1: 1, 2: 3}, mps.monoid().filter(4))]), P.ideal(a - b), DegreeGrading((1,2)))
sage: h = GradedExpansion_class(ger, a^2)
sage: h.grading_index()
2
sage: h = GradedExpansion_class(ger, P(0))
sage: h.grading_index()
+Infinity
sage: h = GradedExpansion_class(ger, a - b)
sage: h.grading_index()
Traceback (most recent call last):
...
ValueError: No homogeneous weight.
"""
cps = self.homogeneous_components()
if len(cps) == 0 :
return infinity
elif len(cps) != 1 :
raise ValueError( "No homogeneous weight." )
return cps.keys()[0]
def _add_(left, right) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_element import *
sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
sage: P.<a,b> = QQ[]
sage: ger = GradedExpansionRing_class(Sequence([MonoidPowerSeries(mps, {1: 1}, mps.monoid().filter(4))]), Sequence([MonoidPowerSeries(mps, {1: 1, 2: 3}, mps.monoid().filter(4))]), P.ideal(a - b), DegreeGrading((1,2)))
sage: h = GradedExpansion_class(ger, a^2)
sage: l = GradedExpansion_class(ger, b)
sage: (h + l).polynomial()
a^2 + b
"""
return left.__class__( left.parent(),
left.polynomial() + right.polynomial() )
def _lmul_(self, c) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_element import *
sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
sage: P.<a,b> = QQ[]
sage: ger = GradedExpansionRing_class(Sequence([MonoidPowerSeries(mps, {1: 1}, mps.monoid().filter(4))]), Sequence([MonoidPowerSeries(mps, {1: 1, 2: 3}, mps.monoid().filter(4))]), P.ideal(a - b), DegreeGrading((1,2)))
sage: h = GradedExpansion_class(ger, a - b)
sage: (h*ger.base_ring()(4)).polynomial()
4*a - 4*b
"""
if self.parent().nbasegens() != 0 :
return self.__class__( self.parent(),
self.polynomial() * c.polynomial() )
else :
return self.__class__( self.parent(),
self.polynomial() * c )
def _rmul_(self, c) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_element import *
sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
sage: P.<a,b> = QQ[]
sage: ger = GradedExpansionRing_class(Sequence([MonoidPowerSeries(mps, {1: 1}, mps.monoid().filter(4))]), Sequence([MonoidPowerSeries(mps, {1: 1, 2: 3}, mps.monoid().filter(4))]), P.ideal(a - b), DegreeGrading((1,2)))
sage: h = GradedExpansion_class(ger, a^2)
sage: (ger.base_ring()(4) * h).polynomial()
4*a^2
"""
if self.parent().nbasegens() != 0 :
return self.__class__( self.parent(),
c.polynomial() * self.polynomial() )
else :
return self.__class__( self.parent(),
c * self.polynomial() )
def __cmp__(self, other) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_element import *
sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
sage: P.<a,b> = QQ[]
sage: ger = GradedExpansionRing_class(Sequence([MonoidPowerSeries(mps, {1: 1}, mps.monoid().filter(4))]), Sequence([MonoidPowerSeries(mps, {1: 1, 2: 3}, mps.monoid().filter(4))]), P.ideal(a - b), DegreeGrading((1,2)))
sage: h = GradedExpansion_class(ger, a^2)
sage: h == GradedExpansion_class(ger, a^2)
True
sage: h == GradedExpansion_class(ger, a - b)
False
sage: h = GradedExpansion_class(ger, P(0))
sage: h == GradedExpansion_class(ger, a - b)
True
sage: ger = GradedExpansionRing_class(Sequence([MonoidPowerSeries(mps, {1: 1}, mps.monoid().filter(4))]), Sequence([MonoidPowerSeries(mps, {1: 1, 2: 3}, mps.monoid().filter(4))]), P.ideal(0), DegreeGrading((1,2)))
sage: h = GradedExpansion_class(ger, a^2)
sage: h == GradedExpansion_class(ger, a^2)
True
sage: h = GradedExpansion_class(ger, P(0))
sage: h == GradedExpansion_class(ger, a - b)
False
sage: ger = GradedExpansionRing_class(Sequence([MonoidPowerSeries(mps, {1: 1}, mps.monoid().filter(4))]), Sequence([MonoidPowerSeries(mps, {1: 1, 2: 3}, mps.monoid().filter(4))]), P.ideal(a - b), DegreeGrading((1,2)), all_relations = False)
sage: h = GradedExpansion_class(ger, a^2)
sage: h == GradedExpansion_class(ger, a^2)
False
"""
c = cmp(type(self), type(other))
if c == 0 :
if self.parent().all_relations_known() :
if self.parent().has_relation_free_generators() :
c = cmp(self.polynomial(), other.polynomial())
else :
c = cmp(self.parent().relations().reduce(self.polynomial() - other.polynomial()), 0)
else :
c = 1
return c
#===============================================================================
# GradedExpansion_class
#===============================================================================
class GradedExpansion_class ( GradedExpansion_abstract, AlgebraElement ) :
"""
A graded expansion which is element of an algebra.
SEE:
:class:`fourier_expansion_framework.gradedexpansions.gradedexpansion_ring.GradedExpansionRing_class`.
"""
def __init__(self, parent, polynomial) :
"""
INPUT:
- ``parent`` -- An instance of :class:~`fourier_expansion_framework.gradedexpansions.gradedexpansion_ring.GradedExpansionRing_class`.
- ``polynomial`` -- A polynomial in the polynomial ring underlying the parent.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_element import *
sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
sage: P.<a,b> = QQ[]
sage: ger = GradedExpansionRing_class(Sequence([MonoidPowerSeries(mps, {1: 1}, mps.monoid().filter(4))]), Sequence([MonoidPowerSeries(mps, {1: 1, 2: 3}, mps.monoid().filter(4))]), P.ideal(a - b), DegreeGrading((1,2)))
sage: h = GradedExpansion_class(ger, a^2)
"""
AlgebraElement.__init__(self, parent)
GradedExpansion_abstract.__init__(self, parent, polynomial)
def _mul_(left, right) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_element import *
sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
sage: P.<a,b> = QQ[]
sage: ger = GradedExpansionRing_class(Sequence([MonoidPowerSeries(mps, {1: 1}, mps.monoid().filter(4))]), Sequence([MonoidPowerSeries(mps, {1: 1, 2: 3}, mps.monoid().filter(4))]), P.ideal(a - b), DegreeGrading((1,2)))
sage: h = GradedExpansion_class(ger, a^2)
sage: (h * h).polynomial()
a^4
"""
return left.__class__( left.parent(),
left.polynomial() * right.polynomial() )
def __hash__(self) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_element import *
sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
sage: P.<a,b> = QQ[]
sage: ger = GradedExpansionRing_class(Sequence([MonoidPowerSeries(mps, {1: 1}, mps.monoid().filter(4))]), Sequence([MonoidPowerSeries(mps, {1: 1, 2: 3}, mps.monoid().filter(4))]), P.ideal(a - b), DegreeGrading((1,2)))
sage: h = GradedExpansion_class(ger, a^2)
sage: hash(h)
-1239234133 # 32-bit
12415370528999851 # 64-bit
"""
return hash(self.polynomial())
def _repr_(self) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_element import *
sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
sage: P.<a,b> = QQ[]
sage: ger = GradedExpansionRing_class(Sequence([MonoidPowerSeries(mps, {1: 1}, mps.monoid().filter(4))]), Sequence([MonoidPowerSeries(mps, {1: 1, 2: 3}, mps.monoid().filter(4))]), P.ideal(a - b), DegreeGrading((1,2)))
sage: GradedExpansion_class(ger, a^2)
Graded expansion a^2
"""
return "Graded expansion %s" % (self.polynomial(),)
def _latex_(self) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_element import *
sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
sage: P.<a,b> = QQ[]
sage: ger = GradedExpansionRing_class(Sequence([MonoidPowerSeries(mps, {1: 1}, mps.monoid().filter(4))]), Sequence([MonoidPowerSeries(mps, {1: 1, 2: 3}, mps.monoid().filter(4))]), P.ideal(a - b), DegreeGrading((1,2)))
sage: latex( GradedExpansion_class(ger, a^2) )
Graded expansion a^{2}
"""
return "Graded expansion %s" % latex(self.polynomial())
class GradedExpansionVector_class ( GradedExpansion_abstract, ModuleElement ) :
"""
A graded expansion which is element of a module.
SEE:
:class:`fourier_expansion_framework.gradedexpansions.gradedexpansion_module.GradedExpansionModule_class`.
"""
def __init__(self, parent, polynomial) :
"""
INPUT:
- ``parent`` -- An instance of :class:~`fourier_expansion_framework.gradedexpansions.gradedexpansion_module.GradedExpansionModule_class`.
- ``polynomial`` -- A polynomial in the polynomial ring underlying the parent.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_module import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_module import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_element import *
sage: m = FreeModule(QQ, 3)
sage: mpsm = MonoidPowerSeriesModule(m, NNMonoid(False))
sage: mps = mpsm.base_ring()
sage: P.<a,b> = QQ[]
sage: ger = GradedExpansionModule_class(Sequence([MonoidPowerSeries(mps, {1: 1}, mps.monoid().filter(4))]), Sequence([MonoidPowerSeries(mpsm, {1: m([1,1,1]), 2: m([1,3,-3])}, mpsm.monoid().filter(4))]), P.ideal(0), DegreeGrading((1,2)))
sage: h = GradedExpansionVector_class(ger, a)
"""
ModuleElement.__init__(self, parent)
GradedExpansion_abstract.__init__(self, parent, polynomial)
def __hash__(self) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_module import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_module import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_element import *
sage: m = FreeModule(QQ, 3)
sage: mpsm = MonoidPowerSeriesModule(m, NNMonoid(False))
sage: mps = mpsm.base_ring()
sage: P.<a,b> = QQ[]
sage: ger = GradedExpansionModule_class(Sequence([MonoidPowerSeries(mps, {1: 1}, mps.monoid().filter(4))]), Sequence([MonoidPowerSeries(mpsm, {1: m([1,1,1]), 2: m([1,3,-3])}, mpsm.monoid().filter(4))]), P.ideal(0), DegreeGrading((1,2)))
sage: h = GradedExpansionVector_class(ger, a)
sage: hash(h)
-1239234136 # 32-bit
12415370528999848 # 64-bit
"""
return hash(self.polynomial())
def _repr_(self) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_module import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_module import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_element import *
sage: m = FreeModule(QQ, 3)
sage: mpsm = MonoidPowerSeriesModule(m, NNMonoid(False))
sage: mps = mpsm.base_ring()
sage: P.<a,b> = QQ[]
sage: ger = GradedExpansionModule_class(Sequence([MonoidPowerSeries(mps, {1: 1}, mps.monoid().filter(4))]), Sequence([MonoidPowerSeries(mpsm, {1: m([1,1,1]), 2: m([1,3,-3])}, mpsm.monoid().filter(4))]), P.ideal(0), DegreeGrading((1,2)))
sage: GradedExpansionVector_class(ger, a*b)
Graded expansion vector (a,)
"""
poly = self.polynomial()
exps = poly.exponents()
if poly.parent().ngens() == 1 :
exps = map(lambda e: (e,), exps)
exps = sorted(map(tuple, exps), reverse = True)
coefficient_monomials = poly.parent().gens()[:self.parent().nbasegens()]
exps = groupby(exps, lambda e: e[self.parent().nbasegens():])
vector_repr = [poly.parent()(0) for _ in range(self.parent().ngens())]
for v, es in exps :
if v.count(1) != 1 :
continue
ind = v.index(1)
c = 0
for e in es :
c += poly[e] * prod(map(operator.pow, coefficient_monomials, e[:self.parent().nbasegens()]))
vector_repr[ind] += c
return "Graded expansion vector %s" % (tuple(vector_repr),)
def _latex_(self) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_module import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_module import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_element import *
sage: m = FreeModule(QQ, 3)
sage: mpsm = MonoidPowerSeriesModule(m, NNMonoid(False))
sage: mps = mpsm.base_ring()
sage: P.<a,b> = QQ[]
sage: ger = GradedExpansionModule_class(Sequence([MonoidPowerSeries(mps, {1: 1}, mps.monoid().filter(4))]), Sequence([MonoidPowerSeries(mpsm, {1: m([1,1,1]), 2: m([1,3,-3])}, mpsm.monoid().filter(4))]), P.ideal(0), DegreeGrading((1,2)))
sage: latex( GradedExpansionVector_class(ger, a*b) )
Graded expansion vector \left(a\right)
"""
poly = self.polynomial()
exps = poly.exponents()
if poly.parent().ngens() == 1 :
exps = map(lambda e: (e,), exps)
exps = sorted(map(tuple, exps), reverse = True)
coefficient_monomials = poly.parent().gens()[:self.parent().nbasegens()]
exps = groupby(exps, lambda e: e[self.parent().nbasegens():])
vector_repr = [poly.parent()(0) for _ in range(self.parent().ngens())]
for v, es in exps :
if v.count(1) != 1 :
continue
ind = v.index(1)
c = 0
for e in es :
c += poly[e] * prod(map(operator.pow, coefficient_monomials, e[:self.parent().nbasegens()]))
vector_repr[ind] += c
return "Graded expansion vector %s" % (latex(tuple(vector_repr)),)
| Python |
"""
Modules of elements with Fourier expansion and partially known relations.
AUTHOR :
-- Martin Raum (2009 - 10 - 30) Initial version
"""
#===============================================================================
#
# Copyright (C) 2009 Martin Raum
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 3
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, see <http://www.gnu.org/licenses/>.
#
#===============================================================================
from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ambient import GradedExpansionAmbient_abstract
from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_element import GradedExpansionVector_class
from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import GradedExpansionRing_class
from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_submodule import GradedExpansionSubmodule_abstract
from sage.misc.flatten import flatten
from sage.misc.latex import latex
from sage.modules.module import Module
from sage.rings.all import Integer
from sage.rings.polynomial.polynomial_ring_constructor import PolynomialRing
from sage.structure.element import Element
import operator
#===============================================================================
# GradedExpansionModule_class
#===============================================================================
class GradedExpansionModule_class ( GradedExpansionAmbient_abstract, Module ) :
"""
A class for a module of vector valued graded expansions
over an ambient of graded expansions, that might also be trivial.
SEE:
:class:~`fourier_expansion_framework.gradedexpansions.gradedexpansion_ring.GradedExpansionRing_class`.
"""
def __init__ ( self, base_ring_generators, generators, relations,
grading, all_relations = True, reduce_before_evaluating = True ) :
"""
The degree one part of the monomials that correspond to generators over the
base expansion ring will serve as the coordinates of the elements.
INPUT:
- ``base_ring_generators`` -- A list of (equivariant) monoid power series with
coefficient domain the base ring of the coefficient
domain of the generators or ``None``.
- ``generators`` -- A list of (equivariant) monoid power series; The generators
of the ambient over the ring generated by the base ring
generators.
- ``relations`` -- An ideal in a polynomial ring with ``len(base_ring_generators) + len(generators)``
variables.
- ``grading`` -- A grading deriving from :class:~`fourier_expansion_framework.gradedexpansions.gradedexpansion_grading`;
A grading for the polynomial ring of the relations.
- ``all_relations`` -- A boolean (default: ``True``); If ``True`` the relations given
for the polynomial ring are all relations that the Fourier
expansion have.
- ``reduce_before_evaluating`` -- A boolean (default: ``True``); If ``True`` any monomial
will be Groebner reduced before the Fourier expansion
is calculated.
NOTE:
The grading must respect the relations of the generators.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_module import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_module import *
sage: m = FreeModule(QQ, 3)
sage: mpsm = MonoidPowerSeriesModule(m, NNMonoid(False))
sage: mps = mpsm.base_ring()
sage: ger = GradedExpansionModule_class(Sequence([MonoidPowerSeries(mps, {1: 1}, mps.monoid().filter(4))]), Sequence([MonoidPowerSeries(mpsm, {1: m([1,1,1]), 2: m([1,3,-3])}, mpsm.monoid().filter(4))]), PolynomialRing(QQ, ['a', 'b']).ideal(0), DegreeGrading((1,2)))
sage: ger.base_ring()
Graded expansion ring with generators a
"""
if not hasattr(self, '_element_class') :
self._element_class = GradedExpansionVector_class
if hasattr(self, "_extended_base_ring") :
Module.__init__(self, self._extended_base_ring)
elif base_ring_generators is None or len(base_ring_generators) == 0 :
Module.__init__(self, relations.base_ring())
else :
gb = filter( lambda p: all( all(a == 0 for a in list(e)[len(base_ring_generators):])
for e in p.exponents() ),
relations.groebner_basis() )
P = PolynomialRing( relations.base_ring(),
list(relations.ring().variable_names())[:len(base_ring_generators)] )
base_relations = P.ideal(gb)
R = GradedExpansionRing_class(None, base_ring_generators, base_relations,
grading.subgrading(xrange(len(base_ring_generators))), all_relations, reduce_before_evaluating)
Module.__init__(self, R)
GradedExpansionAmbient_abstract.__init__(self, base_ring_generators, generators, relations, grading, all_relations, reduce_before_evaluating)
self._populate_coercion_lists_(
convert_list = [self.relations().ring()],
convert_method_name = "_graded_expansion_submodule_to_graded_ambient_" )
def _graded_monoms(self, index) :
"""
Return all monoms in the generators that have a given grading index.
INPUT:
- ``index`` -- A grading values.
OUTPUT:
A list of elements of ``self``.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_module import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_module import *
sage: m = FreeModule(QQ, 3)
sage: mpsm = MonoidPowerSeriesModule(m, NNMonoid(False))
sage: mps = mpsm.base_ring()
sage: ger = GradedExpansionModule_class(None, Sequence([MonoidPowerSeries(mpsm, {1 : m([1,2,3]), 2 : m([3,-3,2])}, mpsm.monoid().filter(4)), MonoidPowerSeries(mpsm, {1 : m([2,-1,-1]), 2 : m([1,0,0])}, mpsm.monoid().filter(4))]), PolynomialRing(ZZ, ['a', 'b']).ideal(0), DegreeGrading((1,2)))
sage: ger._graded_monoms(2)
[Graded expansion vector (0, 1)]
sage: ger._graded_monoms(4)
[]
sage: ger = GradedExpansionModule_class(Sequence([MonoidPowerSeries(mps, {1 : 2}, mps.monoid().filter(4))]), Sequence([MonoidPowerSeries(mpsm, {1 : m([1,2,3]), 2 : m([3,-3,2])}, mpsm.monoid().filter(4)), MonoidPowerSeries(mpsm, {1 : m([2,-1,-1]), 2 : m([1,0,0])}, mpsm.monoid().filter(4))]), PolynomialRing(ZZ, ['a', 'b', 'c']).ideal(0), DegreeGrading((1,2,3)))
sage: ger._graded_monoms(3)
[Graded expansion vector (a, 0), Graded expansion vector (0, 1)]
"""
module_gens = self.grading().basis(index)
module_gens = filter(lambda e: sum(e[self.nbasegens():]) == 1, module_gens)
module_gens = [ filter( lambda e: e != 1,
[ mon**ex if ex > 1 else (mon if ex == 1 else 1)
for mon,ex in zip(self.basegens(), g[:self.nbasegens()]) + zip(self.gens(), g[self.nbasegens():]) ] )
for g in module_gens ]
return [ reduce(operator.mul, g) if len(g) > 1 else g[0] for g in module_gens ]
def _coerce_map_from_(self, other) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_module import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
sage: m = FreeModule(QQ, 3)
sage: mpsm = MonoidPowerSeriesModule(m, NNMonoid(False))
sage: mps = mpsm.base_ring()
sage: ger = GradedExpansionModule_class(Sequence([MonoidPowerSeries(mps, {1: 1}, mps.monoid().filter(4))]), Sequence([MonoidPowerSeries(mpsm, {1: m([1,1,1]), 2: m([1,3,-3])}, mpsm.monoid().filter(4))]), PolynomialRing(QQ, ['a', 'b']).ideal(0), DegreeGrading((1,2)))
sage: ger._coerce_map_from_(ZZ)
"""
if other is self.relations().ring() :
from sage.structure.coerce_maps import CallableConvertMap
return CallableConvertMap(other, self, self._element_constructor_)
if isinstance(other, GradedExpansionSubmodule_abstract) :
if other.graded_ambient() is self \
or self.has_coerce_map_from(other.graded_ambient()) :
from sage.structure.coerce_maps import CallableConvertMap
return CallableConvertMap(other, self, other._graded_expansion_submodule_to_graded_ambient_)
return Module._coerce_map_from_(self, other)
def _element_constructor_(self, x) :
"""
INPUT:
- `x` -- A zero integer, an element of the underlying polynomial ring or
an element in a submodule of graded expansions.
OUTPUT:
An instance of the element class.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_module import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
sage: m = FreeModule(QQ, 3)
sage: mpsm = MonoidPowerSeriesModule(m, NNMonoid(False))
sage: mps = mpsm.base_ring()
sage: ger = GradedExpansionModule_class(Sequence([MonoidPowerSeries(mps, {1: 1}, mps.monoid().filter(4))]), Sequence([MonoidPowerSeries(mpsm, {1: m([1,1,1]), 2: m([1,3,-3])}, mpsm.monoid().filter(4))]), PolynomialRing(QQ, ['a', 'b']).ideal(0), DegreeGrading((1,2)))
sage: h = ger(0)
"""
if isinstance(x, (int, Integer)) and x == 0 :
return self._element_class(self, self.relations().ring().zero())
P = x.parent()
if P is self.base_ring() :
if x == 0 :
return self._element_class(self, self.relations().ring().zero())
return GradedExpansionAmbient_abstract._element_constructor_(self, x)
def _repr_(self) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_module import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_module import *
sage: m = FreeModule(QQ, 3)
sage: mpsm = MonoidPowerSeriesModule(m, NNMonoid(False))
sage: mps = mpsm.base_ring()
sage: ger = GradedExpansionModule_class(Sequence([MonoidPowerSeries(mps, {1: 1}, mps.monoid().filter(4))]), Sequence([MonoidPowerSeries(mpsm, {1: m([1,1,1]), 2: m([1,3,-3])}, mpsm.monoid().filter(4))]), PolynomialRing(QQ, ['a', 'b']).ideal(0), DegreeGrading((1,2)))
sage: ger
Graded expansion module with generators b
"""
return "Graded expansion module with generators " \
+ ''.join(map(lambda e: repr(e.polynomial()) + ", ", self.gens()))[:-2]
def _latex_(self) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_module import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_module import *
sage: m = FreeModule(QQ, 3)
sage: mpsm = MonoidPowerSeriesModule(m, NNMonoid(False))
sage: mps = mpsm.base_ring()
sage: ger = GradedExpansionModule_class(Sequence([MonoidPowerSeries(mps, {1: 1}, mps.monoid().filter(4))]), Sequence([MonoidPowerSeries(mpsm, {1: m([1,1,1]), 2: m([1,3,-3])}, mpsm.monoid().filter(4))]), PolynomialRing(QQ, ['a', 'b']).ideal(0), DegreeGrading((1,2)))
sage: latex(ger)
Graded expansion module with generators b
"""
return "Graded expansion module with generators " \
+ ''.join(map(lambda e: latex(e.polynomial()) + ", ", self.gens()))[:-2]
| Python |
from expansion_module import ExpansionModule
from gradedexpansion_grading import DegreeGrading
| Python |
"""
Rings of elements with Fourier expansion and partially known relations.
AUTHOR :
-- Martin Raum (2009 - 07 - 27) Initial version
"""
#===============================================================================
#
# Copyright (C) 2009 Martin Raum
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 3
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, see <http://www.gnu.org/licenses/>.
#
#===============================================================================
from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ambient import GradedExpansionAmbient_abstract
from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_element import GradedExpansion_class
from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_functor import GradedExpansionBaseringInjection
from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_submodule import GradedExpansionSubmodule_abstract
from sage.algebras.algebra import Algebra
from sage.misc.flatten import flatten
from sage.misc.latex import latex
from sage.rings.all import Integer
from sage.rings.polynomial.polynomial_ring_constructor import PolynomialRing
from sage.structure.element import Element
import operator
#===============================================================================
# GradedExpansionRing_class
#===============================================================================
class GradedExpansionRing_class ( GradedExpansionAmbient_abstract, Algebra ) :
"""
A class for a ring of graded expansions over an ambient of graded expansions,
that might also be trivial.
That is, a polynomial ring with relations and a mapping to an (equivariant)
monoid power series.
"""
def __init__ ( self, base_ring_generators, generators,
relations, grading, all_relations = True, reduce_before_evaluating = True) :
"""
The degree one part of the monomials that correspond to generators over the
base expansion ring will serve as the coordinates of the elements.
INPUT:
- ``base_ring_generators`` -- A list of (equivariant) monoid power series with
coefficient domain the base ring of the coefficient
domain of the generators or ``None``.
- ``generators`` -- A list of (equivariant) monoid power series; The generators
of the ambient over the ring generated by the base ring
generators.
- ``relations`` -- An ideal in a polynomial ring with ``len(base_ring_generators) + len(generators)``
variables.
- ``grading`` -- A grading deriving from :class:~`fourier_expansion_framework.gradedexpansions.gradedexpansion_grading`;
A grading for the polynomial ring of the relations.
- ``all_relations`` -- A boolean (default: ``True``); If ``True`` the relations given
for the polynomial ring are all relations that the Fourier
expansion have.
- ``reduce_before_evaluating`` -- A boolean (default: ``True``); If ``True`` any monomial
will be Groebner reduced before the Fourier expansion
is calculated.
NOTE:
The grading must respect the relations of the generators.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
sage: ger = GradedExpansionRing_class(Sequence([MonoidPowerSeries(mps, {1: 1}, mps.monoid().filter(4))]), Sequence([MonoidPowerSeries(mps, {1: 1, 2: 3}, mps.monoid().filter(4))]), PolynomialRing(QQ, ['a', 'b']).ideal(0), DegreeGrading((1,2)))
sage: ger.base_ring()
Graded expansion ring with generators a
"""
if not hasattr(self, '_element_class') :
self._element_class = GradedExpansion_class
if hasattr(self, "_extended_base_ring") :
Algebra.__init__(self, self._extended_base_ring)
elif base_ring_generators is None or len(base_ring_generators) == 0 :
Algebra.__init__(self, relations.base_ring())
else :
gb = filter( lambda p: all( all(a == 0 for a in list(e)[len(base_ring_generators):])
for e in p.exponents() ),
relations.groebner_basis() )
P = PolynomialRing( relations.base_ring(),
list(relations.ring().variable_names())[:len(base_ring_generators)] )
base_relations = P.ideal(gb)
R = GradedExpansionRing_class(None, base_ring_generators, base_relations,
grading.subgrading(xrange(len(base_ring_generators))), all_relations, reduce_before_evaluating)
Algebra.__init__(self, R)
GradedExpansionAmbient_abstract.__init__(self, base_ring_generators, generators, relations, grading, all_relations, reduce_before_evaluating)
self._populate_coercion_lists_(
coerce_list = [GradedExpansionBaseringInjection(self.base_ring(), self)],
convert_list = [self.relations().ring()],
convert_method_name = "_graded_expansion_submodule_to_graded_ambient_" )
def _graded_monoms(self, index) :
"""
Return all monoms in the generators that have a given grading index.
INPUT:
- ``index`` -- A grading values.
OUTPUT:
A list of elements of ``self``.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
sage: ger = GradedExpansionRing_class(None, Sequence([MonoidPowerSeries(mps, {1 : 4, 2 : 3}, mps.monoid().filter(4)), MonoidPowerSeries(mps, {1 : 1, 2 : 3}, mps.monoid().filter(4))]), PolynomialRing(ZZ, ['a', 'b']).ideal(0), DegreeGrading((1,2)))
sage: ger._graded_monoms(3)
[Graded expansion a^3, Graded expansion a*b]
sage: ger = GradedExpansionRing_class(Sequence([MonoidPowerSeries(mps, {1 : 1}, mps.monoid().filter(4))]), Sequence([MonoidPowerSeries(mps, {1 : 4, 2 : 3}, mps.monoid().filter(4)), MonoidPowerSeries(mps, {1 : 1, 2 : 3}, mps.monoid().filter(4))]), PolynomialRing(QQ, ['a', 'b', 'c']).ideal(0), DegreeGrading((1,2,3)))
sage: ger._graded_monoms(3)
[Graded expansion a^3, Graded expansion a*b, Graded expansion c]
"""
module_gens = self.grading().basis(index)
module_gens = [ filter( lambda e: e != 1,
[ mon**ex if ex > 0 else 1
for mon,ex in zip(self.basegens(), g[:self.nbasegens()]) + zip(self.gens(), g[self.nbasegens():]) ] )
for g in module_gens ]
return [ self(reduce(operator.mul, g)) if len(g) > 1 else g[0] for g in module_gens ]
def _coerce_map_from_(self, other) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_module import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
sage: ger = GradedExpansionRing_class(Sequence([MonoidPowerSeries(mps, {1: 1}, mps.monoid().filter(4))]), Sequence([MonoidPowerSeries(mps, {1: 1, 2: 3}, mps.monoid().filter(4))]), PolynomialRing(QQ, ['a', 'b']).ideal(0), DegreeGrading((1,2)))
sage: ger._coerce_map_from_(ZZ)
"""
if other is self.relations().ring() :
from sage.structure.coerce_maps import CallableConvertMap
return CallableConvertMap(other, self, self._element_constructor_)
if isinstance(other, GradedExpansionSubmodule_abstract) :
if other.graded_ambient() is self \
or self.has_coerce_map_from(other.graded_ambient()) :
from sage.structure.coerce_maps import CallableConvertMap
return CallableConvertMap(other, self, other._graded_expansion_submodule_to_graded_ambient_)
return Algebra._coerce_map_from_(self, other)
def _element_constructor_(self, x) :
"""
INPUT:
- `x` -- An integer, an element of the underlying polynomial ring or
an element in a submodule of graded expansions.
OUTPUT:
An instance of the element class.
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_module import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
sage: ger = GradedExpansionRing_class(Sequence([MonoidPowerSeries(mps, {1: 1}, mps.monoid().filter(4))]), Sequence([MonoidPowerSeries(mps, {1: 1, 2: 3}, mps.monoid().filter(4))]), PolynomialRing(QQ, ['a', 'b']).ideal(0), DegreeGrading((1,2)))
sage: h = ger(1)
"""
if isinstance(x, (int, Integer)) :
return self._element_class(self, self.relations().ring()(x))
P = x.parent()
if P is self.relations().ring() :
return self._element_class(self, x)
elif self.relations().ring().has_coerce_map_from(P) :
return self._element_class(self, self.relations().ring()(x))
elif P is self.base_ring() and isinstance( self.base_ring(), GradedExpansionAmbient_abstract ) :
return self._element_class(self, self.relations().ring()(x.polynomial()))
return GradedExpansionAmbient_abstract._element_constructor_(self, x)
def _repr_(self) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
sage: ger = GradedExpansionRing_class(Sequence([MonoidPowerSeries(mps, {1: 1}, mps.monoid().filter(4))]), Sequence([MonoidPowerSeries(mps, {1: 1, 2: 3}, mps.monoid().filter(4))]), PolynomialRing(QQ, ['a', 'b']).ideal(0), DegreeGrading((1,2)))
sage: ger
Graded expansion ring with generators b
"""
return "Graded expansion ring with generators "\
+ ''.join(map(lambda e: repr(e.polynomial()) + ", ", self.gens()))[:-2]
def _latex_(self) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
sage: ger = GradedExpansionRing_class(Sequence([MonoidPowerSeries(mps, {1: 1}, mps.monoid().filter(4))]), Sequence([MonoidPowerSeries(mps, {1: 1, 2: 3}, mps.monoid().filter(4))]), PolynomialRing(QQ, ['a', 'b']).ideal(0), DegreeGrading((1,2)))
sage: latex(ger)
Graded expansion ring with generators b
"""
return "Graded expansion ring with generators "\
+ ''.join(map(lambda e: latex(e.polynomial()) + ", ", self.gens()))[:-2]
| Python |
"""
Module abstractly spanned by Fourier expansions.
AUTHOR :
-- Martin Raum (2010 - 05 - 15) Initial version
"""
#===============================================================================
#
# Copyright (C) 2010 Martin Raum
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 3
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, see <http://www.gnu.org/licenses/>.
#
#===============================================================================
from psage.modform.fourier_expansion_framework.gradedexpansions.expansion_lazy_evaluation import LazyFourierExpansionEvaluation
from psage.modform.fourier_expansion_framework.gradedexpansions.fourierexpansionwrapper import FourierExpansionWrapper
from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import EquivariantMonoidPowerSeriesAmbient_abstract, MonoidPowerSeriesAmbient_abstract
from sage.categories.pushout import pushout
from sage.interfaces.magma import magma
from sage.matrix.constructor import matrix
from sage.misc.cachefunc import cached_method
from sage.misc.flatten import flatten
from sage.misc.latex import latex
from sage.misc.misc import union
from sage.modules.free_module import FreeModule, FreeModule_generic, \
FreeModule_ambient_pid, FreeModule_submodule_pid
from sage.modules.free_module import is_FreeModule
from sage.modules.free_module_element import FreeModuleElement_generic_dense
from sage.modules.free_module_element import vector
from sage.rings.arith import random_prime
from sage.rings.integer_ring import ZZ
from sage.rings.number_field.order import Order
from sage.rings.padics.factory import Qp
from sage.rings.principal_ideal_domain import PrincipalIdealDomain
from sage.rings.rational_field import QQ
from sage.rings.ring import Ring
from sage.structure.element import Element
from sage.structure.sequence import Sequence
import itertools
#===============================================================================
# ExpansionModule
#===============================================================================
def ExpansionModule(forms) :
"""
Construct a module of over the forms' base ring of rank ``len(forms)``
with underlying expansions associated to.
INPUT:
- ``forms`` -- A sequence or nonempty list of (equivariant) monoid power series.
OUTPUT:
An instance of :class:~`.ExpansionModule_abstract`.
EXAMPLES::
sage: from psage.modform.fourier_expansion_framework.gradedexpansions import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: emps = EquivariantMonoidPowerSeriesRing(NNMonoid(True), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", QQ))
sage: m = FreeModule(QQ, 3)
sage: empsm = EquivariantMonoidPowerSeriesModule(NNMonoid(True), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", m))
sage: em = ExpansionModule([emps.one_element(), emps.one_element()])
sage: em = ExpansionModule([empsm.zero_element(), empsm.zero_element()])
sage: mps = MonoidPowerSeriesRing(ZZ, NNMonoid())
sage: em = ExpansionModule([mps.one_element()])
sage: mpsm = MonoidPowerSeriesModule(m, NNMonoid())
sage: em = ExpansionModule([mpsm.zero_element()])
TESTS::
sage: em = ExpansionModule(Sequence([], universe = emps))
sage: em = ExpansionModule(Sequence([], universe = empsm))
sage: h = EquivariantMonoidPowerSeries(emps, {emps.characters().one_element(): {1: 1, 3: 2}}, emps.action().filter_all())
sage: hv = EquivariantMonoidPowerSeries(empsm, {empsm.characters().one_element(): {1: m([1,0,0]), 2: m([0,0,1])}}, empsm.action().filter_all())
sage: em = ExpansionModule([emps.one_element(), h, h^2])
sage: em = ExpansionModule([empsm.zero_element(), hv, hv * h])
sage: em = ExpansionModule([])
Traceback (most recent call last):
...
ValueError: Empty modules must be constructed with a universe.
sage: em = ExpansionModule(Sequence([], universe = m))
Traceback (most recent call last):
...
ValueError: Common parent of all forms must be a monoid power series ring or module.
sage: qa = QuaternionAlgebra(QQ, -1, -1)
sage: em = ExpansionModule(Sequence([], universe = EquivariantMonoidPowerSeriesRing(NNMonoid(True), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", qa)) ))
Traceback (most recent call last):
...
TypeError: The forms' base ring must be a commutative ring.
"""
if not isinstance(forms, Sequence) :
forms = Sequence(forms)
if len(forms) == 0 :
raise ValueError( "Empty modules must be constructed with a universe." )
if not isinstance(forms.universe(), (MonoidPowerSeriesAmbient_abstract,
EquivariantMonoidPowerSeriesAmbient_abstract)) :
raise ValueError( "Common parent of all forms must be a monoid power series ring or module." )
if isinstance(forms.universe(), EquivariantMonoidPowerSeriesAmbient_abstract) \
and forms.universe().representation().base_ring() == forms.universe().representation().codomain() :
base_ring = forms.universe().base_ring()
elif isinstance(forms.universe(), MonoidPowerSeriesAmbient_abstract) \
and isinstance(forms.universe().coefficient_domain(), Ring) :
base_ring = forms.universe().base_ring()
else :
base_ring = forms.universe().base_ring().base_ring()
if not base_ring.is_commutative():
raise TypeError( "The forms' base ring must be a commutative ring." )
if base_ring.is_field() \
or isinstance(base_ring, PrincipalIdealDomain) \
or ( isinstance(base_ring, Order) \
and base_ring.is_maximal() and base_ring.class_number() == 1 ) :
return ExpansionModule_ambient_pid(forms)
else :
return ExpansionModule_generic(forms)
#===============================================================================
# ExpansionModule_abstract
#===============================================================================
class ExpansionModule_abstract :
"""
An abstract implementation of a module with expansions associated to its basis elements.
"""
def __init__(self, basis, **kwds) :
"""
INPUT:
- ``basis`` -- A sequence of (equivariant) monoid power series.
TESTS::
sage: from psage.modform.fourier_expansion_framework.gradedexpansions import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: emps = EquivariantMonoidPowerSeriesRing(NNMonoid(True), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", QQ))
sage: em = ExpansionModule_abstract(Sequence([emps.one_element(), emps.one_element()]))
"""
self.__abstract_basis = basis
def _abstract_basis(self) :
"""
Return a basis in terms of elements of the graded ambient.
OUTPUT:
A sequence of (equivariant) monoid power series.
TESTS::
sage: from psage.modform.fourier_expansion_framework.gradedexpansions import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: emps = EquivariantMonoidPowerSeriesRing(NNMonoid(True), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", QQ))
sage: basis = Sequence([emps.one_element(), emps.one_element()])
sage: em = ExpansionModule(basis)
sage: em._abstract_basis() == basis
True
"""
return self.__abstract_basis
@cached_method
def precision(self) :
"""
A common precision of the expansions associated to the basis elements.
OUTPUT:
A filter for the expansions' parent's action or monoid.
TESTS::
sage: from psage.modform.fourier_expansion_framework.gradedexpansions import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: emps = EquivariantMonoidPowerSeriesRing(NNMonoid(True), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", QQ))
sage: em = ExpansionModule(Sequence([emps.one_element(), emps.one_element()]))
sage: em.precision()
Filtered NN with action up to +Infinity
sage: em = ExpansionModule(Sequence([emps.one_element().truncate(3), emps.one_element()]))
sage: em.precision()
Filtered NN with action up to 3
sage: em = ExpansionModule(Sequence([], universe = emps))
sage: em.precision()
Filtered NN with action up to +Infinity
"""
if len(self.__abstract_basis) != 0 :
return min([b.precision() for b in self.__abstract_basis])
else :
if isinstance(self.__abstract_basis.universe(), EquivariantMonoidPowerSeriesAmbient_abstract) :
return self.__abstract_basis.universe().action().filter_all()
else :
return self.__abstract_basis.universe().monoid().filter_all()
def _bounding_precision(self) :
"""
A common precision of the expansions associtated to the basis elements
if it is finite or in case it is not a filter that comprises all
nonzero coefficient of the expansion.
OUTPUT:
A filter for the expansions' parent's action or monoid.
TESTS::
sage: from psage.modform.fourier_expansion_framework.gradedexpansions import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: emps = EquivariantMonoidPowerSeriesRing(NNMonoid(True), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", QQ))
sage: em = ExpansionModule(Sequence([emps.one_element(), emps.one_element()]))
sage: em._bounding_precision()
Filtered NN with action up to 1
sage: em = ExpansionModule(Sequence([emps.one_element().truncate(4), emps.one_element()]))
sage: em._bounding_precision()
Filtered NN with action up to 4
sage: em = ExpansionModule(Sequence([], universe = emps))
sage: em._bounding_precision()
Filtered NN with action up to 0
"""
if len(self.__abstract_basis) != 0 :
return max([b._bounding_precision() for b in self.__abstract_basis])
else :
if isinstance(self.__abstract_basis.universe(), EquivariantMonoidPowerSeriesAmbient_abstract) :
return self.__abstract_basis.universe().action().zero_filter()
else :
return self.__abstract_basis.universe().monoid().zero_filter()
@cached_method
def _check_precision(self, precision = None, lazy_rank_check = False) :
"""
Check whether the elements of this module are uniquely determined
by their Fourier expansions up to ``precision``. If ``precision`` is ``None``
the precision of this module will be used.
INPUT::
- ``precision`` -- A filter for the expansions' parent monoid or action or ``None`` (default: ``None``).
- ``lazy_rank_check`` -- A boolean (default: ``False``); If ``True`` the involved rank checks will
be done over `Q_p` (with finite precision).
OUTPUT:
A boolean.
TESTS::
sage: from psage.modform.fourier_expansion_framework.gradedexpansions import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: emps = EquivariantMonoidPowerSeriesRing(NNMonoid(True), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", QQ))
sage: em = ExpansionModule(Sequence([emps.one_element(), emps.one_element()]))
sage: em._check_precision()
False
sage: em = ExpansionModule(Sequence([], universe = emps))
sage: em._check_precision()
True
sage: em._check_precision(lazy_rank_check = True)
True
sage: h = EquivariantMonoidPowerSeries(emps, {emps.characters().one_element(): {1: 1, 3: 2}}, emps.action().filter_all())
sage: em = ExpansionModule(Sequence([emps.one_element(), h]))
sage: em._check_precision()
True
sage: em._check_precision(emps.action().filter(1))
False
sage: m = FreeModule(QQ, 3)
sage: empsm = EquivariantMonoidPowerSeriesModule(NNMonoid(True), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", m))
sage: hv = EquivariantMonoidPowerSeries(empsm, {empsm.characters().one_element(): {1: m([1,0,0])}}, empsm.action().filter_all())
sage: hv2 = EquivariantMonoidPowerSeries(empsm, {empsm.characters().one_element(): {1: m([1,1,0])}}, empsm.action().filter_all())
sage: em = ExpansionModule(Sequence([hv, hv2]))
sage: em._check_precision()
True
"""
if lazy_rank_check and not( self.base_ring() is ZZ or self.base_ring() is QQ) :
raise NotImplemented, "lazy rank checks only implemented for ZZ and QQ"
if precision is None :
precision = self.precision()
elif not precision <= self.precision() :
raise ValueError, "precison must be less equal self.__graded_ambient.precision()"
if precision.is_infinite() :
precision = self._bounding_precision()
if self.precision().is_infinite() :
total_precision = self._bounding_precision()
else :
total_precision = self.precision()
basis_fe_expansion = self.fourier_expansion_homomorphism().matrix()
if precision != self.precision() :
if isinstance(self._abstract_basis().universe().coefficient_domain(), Ring) :
indices = [i for (i,k) in enumerate(total_precision) if k in precision]
else :
indices = [i for (i,(k,_)) in enumerate(
itertools.product(total_precision, range(self._abstract_basis().universe().coefficient_domain().rank())) )
if k in precision]
basis_fe_expansion = basis_fe_expansion.matrix_from_columns(indices)
if lazy_rank_check :
basis_fe_expansion = matrix(Qp(random_prime(10**9), 10), basis_fe_expansion)
return basis_fe_expansion.rank() >= self.rank()
def _fourier_expansion_of_element(self, e) :
"""
The Fourier expansion of an element optained via linear combinations
of the basis' Fourier expansions.
INPUT:
- `e` -- An element of ``self``.
OUTPUT:
A (equivariant) monoid power series.
TESTS::
sage: from psage.modform.fourier_expansion_framework.gradedexpansions import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: emps = EquivariantMonoidPowerSeriesRing(NNMonoid(True), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", QQ))
sage: em = ExpansionModule(Sequence([emps.one_element(), emps.one_element()]))
sage: fe = em._fourier_expansion_of_element(em([1,0]))
sage: m = FreeModule(QQ, 3)
sage: empsm = EquivariantMonoidPowerSeriesModule(NNMonoid(True), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", m))
sage: hv = EquivariantMonoidPowerSeries(empsm, {empsm.characters().one_element(): {1: m([1,0,0])}}, empsm.action().filter_all())
sage: em = ExpansionModule(Sequence([hv]))
sage: fe = em._fourier_expansion_of_element(em([1]))
"""
return sum( (e[k]*b for (k,b) in enumerate(self.__abstract_basis) if e[k] != 0),
self.__abstract_basis.universe()(0) )
@cached_method
def _non_zero_characters(self) :
"""
Return those characters which cannot be guaranteed to have vanishing Fourier
expansion associated with for all basis elements of ``self``.
OUTPUT:
A list of characters of the expansions' parent if it is equivariant
or otherwise None.
TESTS::
sage: from psage.modform.fourier_expansion_framework.gradedexpansions import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: emps = EquivariantMonoidPowerSeriesRing(NNMonoid(True), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", QQ))
sage: em = ExpansionModule(Sequence([emps.one_element(), emps.one_element()]))
sage: em._non_zero_characters()
[1]
sage: em = ExpansionModule(Sequence([EquivariantMonoidPowerSeries(emps, {}, emps.action().filter_all())]))
sage: em._non_zero_characters()
[]
"""
if isinstance(self.__abstract_basis.universe(), EquivariantMonoidPowerSeriesAmbient_abstract) :
return list( reduce(union, [ set(b.non_zero_components())
for b in flatten(self.__abstract_basis, tuple) ], set()) )
else :
return None
@cached_method
def _fourier_expansion_indices(self) :
"""
A list of Fourier indices which are considered by the Fourier expansion morphism.
OUTPUT:
A list of monoid elements or components indices and monoid elements
in case the expansions' parent is not equivariant. Otherwise, it
is pairs of characters and monoid elements possibly with a component
index in case the coefficient domain of the expansions parent is only
a module.
SEE:
:meth:~`.fourier_expansion_homomorphism`.
TESTS::
sage: from psage.modform.fourier_expansion_framework.gradedexpansions import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: emps = EquivariantMonoidPowerSeriesRing(NNMonoid(True), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", QQ))
sage: em = ExpansionModule(Sequence([emps.one_element(), emps.one_element()]))
sage: em._fourier_expansion_indices()
[(1, 0)]
sage: m = FreeModule(QQ, 3)
sage: empsm = EquivariantMonoidPowerSeriesModule(NNMonoid(True), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", m))
sage: hv = EquivariantMonoidPowerSeries(empsm, {empsm.characters().one_element(): {1: m([1,0,0]), 2: m([0,0,1])}}, empsm.action().filter_all())
sage: em = ExpansionModule(Sequence([hv]))
sage: em._fourier_expansion_indices()
[(0, (1, 0)), (1, (1, 0)), (2, (1, 0)), (0, (1, 1)), (1, (1, 1)), (2, (1, 1)), (0, (1, 2)), (1, (1, 2)), (2, (1, 2))]
sage: mps = MonoidPowerSeriesRing(ZZ, NNMonoid())
sage: em = ExpansionModule([mps.one_element()])
sage: em._fourier_expansion_indices()
[0]
sage: mpsm = MonoidPowerSeriesModule(m, NNMonoid())
sage: hv = MonoidPowerSeries(mpsm, {1: m([1,0,0]), 2: m([0,0,1])}, mpsm.monoid().filter_all())
sage: em = ExpansionModule([hv])
sage: em._fourier_expansion_indices()
[(0, 0), (1, 0), (2, 0), (0, 1), (1, 1), (2, 1), (0, 2), (1, 2), (2, 2)]
"""
characters = self._non_zero_characters()
if isinstance(self.__abstract_basis.universe().coefficient_domain(), Ring) :
if characters is None :
return list(self._bounding_precision())
else :
return [ (ch, k) for k in self._bounding_precision()
for ch in characters ]
else :
if characters is None :
return [ (i, k) for k in self._bounding_precision()
for i in range(self.__abstract_basis.universe().coefficient_domain().rank()) ]
else :
return [ (i,(ch, k)) for k in self._bounding_precision()
for ch in characters
for i in range(self.__abstract_basis.universe().coefficient_domain().rank()) ]
@cached_method
def fourier_expansion_homomorphism(self, precision = None) :
"""
A morphism mapping elements of the underlying module to
a module such that each component of the image corresponds to an
Fourier coefficient of the Fourier expansion associated with this
element.
INPUT:
- ``precision`` -- A fitler for the expansions monoid or action or ``None``
(default: ``None``); If not ``None`` the Fourier expansions
of the basis will be truncated to this precision.
OUTPUT:
A morphism from ``self`` to a free module over the expansions' base ring.
TESTS::
sage: from psage.modform.fourier_expansion_framework.gradedexpansions import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: emps = EquivariantMonoidPowerSeriesRing(NNMonoid(True), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", QQ))
sage: em = ExpansionModule(Sequence([emps.one_element(), emps.one_element()]))
sage: em.fourier_expansion_homomorphism()
Free module morphism defined by the matrix
[1]
[1]
Domain: Module of Fourier expansions in Ring of equivariant monoid power ...
Codomain: Vector space of dimension 1 over Rational Field
sage: m = FreeModule(QQ, 3)
sage: empsm = EquivariantMonoidPowerSeriesModule(NNMonoid(True), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", m))
sage: hv = EquivariantMonoidPowerSeries(empsm, {empsm.characters().one_element(): {1: m([1,0,0]), 2: m([0,0,1])}}, empsm.action().filter_all())
sage: em = ExpansionModule(Sequence([hv]))
sage: em.fourier_expansion_homomorphism()
Free module morphism defined by the matrix
(not printing 1 x 9 matrix)
Domain: Module of Fourier expansions in Module of equivariant monoid ...
Codomain: Vector space of dimension 9 over Rational Field
"""
keys = self._fourier_expansion_indices()
codomain = FreeModule(self.base_ring(), len(keys))
if isinstance(self.__abstract_basis.universe().coefficient_domain(), Ring) :
basis_images = [ codomain([b[k] for k in keys])
for b in self.__abstract_basis ]
else :
basis_images = [ codomain([b[k][i] for (i,k) in keys])
for b in self.__abstract_basis ]
return self.Hom(codomain)(basis_images)
@cached_method
def _fourier_expansion_matrix_over_fraction_field(self) :
"""
The matrix associated with the Fourier expansion homomorphism
such that its base ring is a field.
OUTPUT:
A matrix over the fraction field of the expansions' base ring.
SEE:
:meth:~`.fourier_expansion_homomorphism`.
TESTS::
sage: from psage.modform.fourier_expansion_framework.gradedexpansions import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: emps = EquivariantMonoidPowerSeriesRing(NNMonoid(True), TrivialCharacterMonoid("1", ZZ), TrivialRepresentation("1", ZZ))
sage: em = ExpansionModule(Sequence([emps.one_element(), emps.one_element()]))
sage: em._fourier_expansion_matrix_over_fraction_field().base_ring()
Rational Field
"""
if self.base_ring().is_field() :
return self.fourier_expansion_homomorphism().matrix()
else :
return self.fourier_expansion_homomorphism().matrix(). \
base_extend(self.base_ring().fraction_field())
@cached_method
def pivot_elements(self) :
"""
Determine a set of generators, which minimally span the image of the Fourier expansion
homomorphism.
SEE:
:meth:~`.fourier_expansion_homomorphism`.
OUTPUT:
A list of indices.
TESTS::
sage: from psage.modform.fourier_expansion_framework.gradedexpansions import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: emps = EquivariantMonoidPowerSeriesRing(NNMonoid(True), TrivialCharacterMonoid("1", ZZ), TrivialRepresentation("1", ZZ))
sage: em = ExpansionModule(Sequence([emps.one_element(), emps.one_element()]))
sage: em.pivot_elements()
[0]
sage: em = ExpansionModule(Sequence([emps.one_element().truncate(0), emps.one_element().truncate(0)]))
sage: em.pivot_elements()
[]
sage: em = ExpansionModule(Sequence([], universe = emps))
sage: em.pivot_elements()
[]
sage: m = FreeModule(QQ, 3)
sage: empsm = EquivariantMonoidPowerSeriesModule(NNMonoid(True), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", m))
sage: hv = EquivariantMonoidPowerSeries(empsm, {empsm.characters().one_element(): {1: m([1,0,0]), 2: m([0,0,1])}}, empsm.action().filter_all())
sage: em = ExpansionModule(Sequence([hv,hv]))
sage: em.pivot_elements()
[0]
"""
expansion_matrix = self.fourier_expansion_homomorphism().matrix().transpose()
if expansion_matrix.rank() == self.rank() :
return range(self.rank())
else :
return expansion_matrix.pivots()
def _element_to_fourier_expansion_generator(self, e) :
"""
Given a monoid power series `e` return a generator iterating over the components of
the image of `e` under the Fourier expansion morphism.
INTPUT:
- `e` -- An element of the ``self``.
OUTPUT:
A generator over elements of the expansions' base ring.
SEE::
:meth:~`.fourier_expansion_homomorphism`.
TESTS::
sage: from psage.modform.fourier_expansion_framework.gradedexpansions import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: emps = EquivariantMonoidPowerSeriesRing(NNMonoid(True), TrivialCharacterMonoid("1", ZZ), TrivialRepresentation("1", ZZ))
sage: em = ExpansionModule(Sequence([emps.one_element(), emps.one_element()]))
sage: list(em._element_to_fourier_expansion_generator(em([3,0]).fourier_expansion()))
[3]
sage: m = FreeModule(QQ, 3)
sage: empsm = EquivariantMonoidPowerSeriesModule(NNMonoid(True), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", m))
sage: hv = EquivariantMonoidPowerSeries(empsm, {empsm.characters().one_element(): {1: m([1,0,0]), 2: m([0,0,1])}}, empsm.action().filter_all())
sage: em = ExpansionModule(Sequence([hv]))
sage: list(em._element_to_fourier_expansion_generator(em([1]).fourier_expansion()))
[0, 0, 0, 1, 0, 0, 0, 0, 1]
sage: mps = MonoidPowerSeriesRing(ZZ, NNMonoid())
sage: em = ExpansionModule([mps.one_element()])
sage: list(em._element_to_fourier_expansion_generator(em([2]).fourier_expansion()))
[2]
sage: mpsm = MonoidPowerSeriesModule(m, NNMonoid())
sage: hv = MonoidPowerSeries(mpsm, {1: m([1,0,0]), 2: m([0,0,1])}, mpsm.monoid().filter_all())
sage: em = ExpansionModule([hv])
sage: list(em._element_to_fourier_expansion_generator(em([1]).fourier_expansion()))
[0, 0, 0, 1, 0, 0, 0, 0, 1]
"""
keys = self._fourier_expansion_indices()
if isinstance(self.__abstract_basis.universe().coefficient_domain(), Ring) :
return (e[k] if k in e else 0 for k in keys)
else :
return (e[k][i] if k in e else 0 for (i,k) in keys)
def coordinates(self, x, in_base_ring = True, force_ambigous = False) :
"""
The coordinates in ``self`` of an element either of the following:
- An element of a submodule.
- An expansion in the parent of the basis' expansions.
INPUT:
- `x` -- Either of the types listed above.
- ``in_base_ring`` -- A boolean (default: ``True``); If ``True``
enforce the result to be definied over the
base ring of ``self``.
- ``force_ambigous`` -- A boolean (default: ``False``); If ``True``
also return the solutions that are not unique.
OUTPUT:
A list of elements in the base ring or and extension of it.
NOTE:
If the Fourier expansion of `x` lakes sufficient precision the
expansions associated to ``self`` will be truncated.
TESTS::
sage: from psage.modform.fourier_expansion_framework.gradedexpansions import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: emps = EquivariantMonoidPowerSeriesRing(NNMonoid(True), TrivialCharacterMonoid("1", ZZ), TrivialRepresentation("1", ZZ))
sage: em = ExpansionModule(Sequence([emps.one_element()]))
sage: em.coordinates(2 * emps.one_element())
[2]
sage: m = FreeModule(QQ, 3)
sage: empsm = EquivariantMonoidPowerSeriesModule(NNMonoid(True), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", m))
sage: hv = EquivariantMonoidPowerSeries(empsm, {empsm.characters().one_element(): {1: m([1,0,0]), 2: m([0,0,1])}}, empsm.action().filter_all())
sage: em = ExpansionModule(Sequence([hv]))
sage: em.coordinates(2 * hv)
[2]
sage: mps = MonoidPowerSeriesRing(ZZ, NNMonoid())
sage: em = ExpansionModule([mps.one_element()])
sage: em.coordinates(3 * mps.one_element())
[3]
sage: mpsm = MonoidPowerSeriesModule(m, NNMonoid())
sage: hv = MonoidPowerSeries(mpsm, {1: m([1,0,0]), 2: m([0,0,1])}, mpsm.monoid().filter_all())
sage: em = ExpansionModule([hv])
sage: em.coordinates(2 * hv)
[2]
sage: em = ExpansionModule(Sequence([emps.one_element()]))
sage: h = EquivariantMonoidPowerSeries(emps, {}, emps.action().filter_all())
sage: em.coordinates(h)
[0]
sage: em.coordinates(1 / 2 * emps.one_element())
Traceback (most recent call last):
...
ArithmeticError: Equivariant monoid power series in Ring of equivariant monoid power series over NN is not contained in this space.
sage: em.coordinates(1 / 2 * emps.one_element(), in_base_ring = False )
[1/2]
sage: K.<rho> = CyclotomicField(6)
sage: em.coordinates(rho * emps.one_element(), in_base_ring = False)
[rho]
sage: h = EquivariantMonoidPowerSeries(emps, {emps.characters().one_element(): {1: 2, 2: 3}}, emps.action().filter_all())
sage: em.coordinates(h)
Traceback (most recent call last):
...
ArithmeticError: Equivariant monoid power series in Ring of equivariant monoid power series over NN is not contained in this space.
sage: em.coordinates(hv)
Traceback (most recent call last):
...
ArithmeticError: No coordinates for Monoid power series in Module of monoid power series over NN with action.
sage: em = ExpansionModule(Sequence([emps.one_element(), emps.one_element()]))
sage: em.coordinates(2 * emps.one_element())
Traceback (most recent call last):
...
ValueError: Not unambigous coordinates available in this submodule.
sage: h = EquivariantMonoidPowerSeries(emps, {}, emps.action().filter_all())
sage: em = ExpansionModule(Sequence([h]))
sage: em.coordinates(emps.one_element())
Traceback (most recent call last):
...
ValueError: Not unambigous coordinates available in this submodule.
"""
if isinstance(x, Element) :
P = x.parent()
if P is self :
if self.ambient_module() is self :
return x.list()
else :
return list(self.coordinate_vector(x))
if isinstance(P, (EquivariantMonoidPowerSeriesAmbient_abstract,
MonoidPowerSeriesAmbient_abstract)) :
if not force_ambigous and \
not self._check_precision() :
raise ValueError( "Not unambigous coordinates available in this submodule." )
if P != self.__abstract_basis.universe() :
try :
Pnew = pushout(self.__abstract_basis.universe(), P)
except TypeError :
raise ArithmeticError( "No coordinates for %s." % (x,) )
if isinstance(Pnew, EquivariantMonoidPowerSeriesAmbient_abstract) \
and Pnew.representation().base_ring() == Pnew.representation().codomain() :
A = Pnew.base_ring()
elif isinstance(Pnew, MonoidPowerSeriesAmbient_abstract) \
and isinstance(Pnew.coefficient_domain(), Ring) :
A = Pnew.base_ring()
else :
A = Pnew.base_ring().base_ring()
try :
x = Pnew(x)
except TypeError :
raise ArithmeticError( "No coordinates for %s." % (x,) )
else :
A = self.base_ring()
# check those components of x, which have to be zero
if not self._non_zero_characters() is None :
x._cleanup_coefficients()
if set( x.non_zero_components() ) - set( self._non_zero_characters() ) != set() :
raise ArithmeticError( "%s is not contained in this space." % (x,) )
if in_base_ring :
fe_matrix = self.fourier_expansion_homomorphism().matrix().transpose()
x_fe_vector = matrix( A, fe_matrix.nrows(),
list(self._element_to_fourier_expansion_generator(x)) )
else :
fe_matrix = self._fourier_expansion_matrix_over_fraction_field().transpose()
x_fe_vector = matrix( A, fe_matrix.nrows(),
list(self._element_to_fourier_expansion_generator(x)) )
if self._non_zero_characters() is None :
if isinstance(self.__abstract_basis.universe().coefficient_domain(), Ring) :
valid_indices = [ i for (i,k) in enumerate(self._fourier_expansion_indices())
if k in x.precision() ]
else :
valid_indices = [ i for (i,(_,k)) in enumerate(self._fourier_expansion_indices())
if k in x.precision() ]
else :
if isinstance(self.__abstract_basis.universe().coefficient_domain(), Ring) :
valid_indices = [ i for (i,(_,k)) in enumerate(self._fourier_expansion_indices())
if k in x.precision() ]
else :
valid_indices = [ i for (i,(_,(_,k))) in enumerate(self._fourier_expansion_indices())
if k in x.precision() ]
fe_matrix = fe_matrix.matrix_from_rows(valid_indices)
x_fe_vector = x_fe_vector.matrix_from_rows(valid_indices)
fe_matrix = matrix(A, fe_matrix)
## TODO: use linbox
try :
## TODO: We deactivate the magma interface as it is almost never used and
## it is in bad shape
if True or (A is not ZZ and A is not QQ) :
raise TypeError
magma_fe_matrix = magma(fe_matrix.transpose())
if not force_ambigous and \
len(valid_indices) != self.fourier_expansion_homomorphism().matrix().ncols() and \
magma_fe_matrix.Rank() != self.rank() :
raise ValueError( "No unambigous coordinates available." )
coords = magma(fe_matrix.transpose()).Solution(magma(x_fe_vector.transpose())).sage()
coords = coords.row(0)
except TypeError, msg :
if "Runtime error in 'Solution': No solution exists" in msg :
raise ArithmeticError( "%s is not contained in this space." % (x,) )
if not force_ambigous and \
len(valid_indices) != self.fourier_expansion_homomorphism().matrix().ncols() and \
fe_matrix.rank() != self.rank() :
raise ValueError( "No unambigous coordinates available." )
try :
coords = fe_matrix.solve_right(x_fe_vector)
except ValueError, msg :
raise ArithmeticError( "%s is not contained in this space, %s" % (x, msg) )
coords = coords.column(0)
if self.precision() != self._bounding_precision() and \
not x.precision() < self._bounding_precision() :
if not self.change_ring(A)(list(coords)).fourier_expansion() == x :
raise ArithmeticError( "%s is not contained in this space." % (x,) )
if in_base_ring :
try :
return [self.base_ring()(c) for c in coords]
except TypeError :
raise ArithmeticError( "%s is not contained in this space." % (x,) )
else :
return list(coords)
#! elif isinstance(P, (EquivariantMonoidPowerSeriesAmbient_abstract,
# MonoidPowerSeriesAmbient_abstract)) :
#! if isinstance(x, (tuple, Element)) :
raise ArithmeticError( "No coordinates for %s." % (x,) )
def _sparse_module(self):
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.gradedexpansions import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: emps = EquivariantMonoidPowerSeriesRing(NNMonoid(True), TrivialCharacterMonoid("1", ZZ), TrivialRepresentation("1", ZZ))
sage: em = ExpansionModule(Sequence([emps.one_element()]))
sage: em._sparse_module()
Traceback (most recent call last):
...
NotImplementedError
"""
raise NotImplementedError
def _dense_module(self):
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.gradedexpansions import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: emps = EquivariantMonoidPowerSeriesRing(NNMonoid(True), TrivialCharacterMonoid("1", ZZ), TrivialRepresentation("1", ZZ))
sage: em = ExpansionModule(Sequence([emps.one_element()]))
sage: em._dense_module() is em
True
"""
return self
def _repr_(self) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.gradedexpansions import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: emps = EquivariantMonoidPowerSeriesRing(NNMonoid(True), TrivialCharacterMonoid("1", ZZ), TrivialRepresentation("1", ZZ))
sage: ExpansionModule(Sequence([emps.one_element()]))
Module of Fourier expansions in Ring of equivariant monoid power series over NN
"""
return "Module of Fourier expansions in %s" % (self.__abstract_basis.universe(),)
def _latex_(self) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.gradedexpansions import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: emps = EquivariantMonoidPowerSeriesRing(NNMonoid(True), TrivialCharacterMonoid("1", ZZ), TrivialRepresentation("1", ZZ))
sage: latex( ExpansionModule(Sequence([emps.one_element()])) )
Module of Fourier expansions in Ring of equivariant monoid power series over $\NN$
"""
return "Module of Fourier expansions in %s" % (latex(self.__abstract_basis.universe()),)
class ExpansionModule_generic ( ExpansionModule_abstract, FreeModule_generic ) :
"""
A generic module of abstract elements with Fourier expansions attached to.
The base ring has to be an integral domain.
"""
def __init__(self, basis, degree, **kwds) :
"""
INPUT:
- ``basis`` -- A sequence of (equivariant) monoid power series.
- ``degree`` -- An integer; The ambient's module dimension.
- ``kwds`` -- A keyword dictionary that will be forwarded to
initialization of the underlying free module.
NOTE:
The base ring of the expansions' parent must be an integral
domain.
TESTS::
sage: from psage.modform.fourier_expansion_framework.gradedexpansions import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: emps = EquivariantMonoidPowerSeriesRing(NNMonoid(True), TrivialCharacterMonoid("1", ZZ), TrivialRepresentation("1", ZZ))
sage: em = ExpansionModule_generic(Sequence([emps.one_element()]), 2)
sage: em = ExpansionModule_generic(Sequence([emps.one_element()]), 2, _element_class = ExpansionModuleVector_generic )
"""
if not hasattr(self, '_element_class') :
if '_element_class' in kwds :
self._element_class = kwds['_element_class']
else :
self._element_class = ExpansionModuleVector_generic
ExpansionModule_abstract.__init__(self, basis)
FreeModule_generic.__init__(self, basis.universe().base_ring(), len(basis), degree, sparse = False)
def gen(self, i) :
"""
The `i`-th generator of the module.
INPUT:
- `i` -- An integer.
OUTPUT:
An element of ``self``.
TESTS::
sage: from psage.modform.fourier_expansion_framework.gradedexpansions import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: emps = EquivariantMonoidPowerSeriesRing(NNMonoid(True), TrivialCharacterMonoid("1", ZZ), TrivialRepresentation("1", ZZ))
sage: em = ExpansionModule_generic(Sequence([emps.one_element()]), 1)
sage: em.gen(0)
Traceback (most recent call last):
...
NotImplementedError
"""
raise NotImplementedError
def basis(self) :
"""
A basis of ``self``.
OUTPUT:
A list of elements of ``self``.
TESTS::
sage: from psage.modform.fourier_expansion_framework.gradedexpansions import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: emps = EquivariantMonoidPowerSeriesRing(NNMonoid(True), TrivialCharacterMonoid("1", ZZ), TrivialRepresentation("1", ZZ))
sage: em = ExpansionModule_generic(Sequence([emps.one_element()]), 1)
sage: em.basis()
Traceback (most recent call last):
...
NotImplementedError
"""
raise NotImplementedError
def change_ring(self, R):
"""
Return the ambient expansion module over `R` with the same basis as ``self``.
INPUT:
- `R` -- A ring.
OUTPUT:
An instance of :class:~`.ExpansionModule_generic`.
TESTS::
sage: from psage.modform.fourier_expansion_framework.gradedexpansions import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: emps = EquivariantMonoidPowerSeriesRing(NNMonoid(True), TrivialCharacterMonoid("1", ZZ), TrivialRepresentation("1", ZZ))
sage: em = ExpansionModule_generic(Sequence([emps.one_element()]), 2)
sage: em.change_ring(ZZ) is em
True
sage: em.change_ring(QQ).base_ring()
Rational Field
"""
if self.base_ring() == R :
return self
R = pushout(self._abstract_basis().universe(), R)
return ExpansionModule_generic(Sequence(self._abstract_basis(), universe = R), self.degree(), _element_class = self._element_class)
#===============================================================================
# _fourier_expansion_kernel
#
# This will be used in ExpansionModule_ambient_pid and
# ExpansionModule_submodule_pid
#===============================================================================
def _fourier_expansion_kernel(self) :
"""
The kernel of the Fourier expansion morphism.
OUTPUT:
A module over the basis ring.
SEE:
:meth:~`.ExpansionModule_abstract.fourier_expansion_homomorphism`.
TESTS::
sage: from psage.modform.fourier_expansion_framework.gradedexpansions import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: emps = EquivariantMonoidPowerSeriesRing(NNMonoid(True), TrivialCharacterMonoid("1", ZZ), TrivialRepresentation("1", ZZ))
sage: em = ExpansionModule(Sequence([emps.one_element(), emps.one_element(), emps.one_element()]))
sage: em.fourier_expansion_kernel()
Free module of degree 3 and rank 2 over Integer Ring
Echelon basis matrix:
[ 1 0 -1]
[ 0 1 -1]
sage: em.span([em([1,0,0]), em([1,2,0])]).fourier_expansion_kernel()
Free module of degree 2 and rank 1 over Integer Ring
Echelon basis matrix:
[ 3 -1]
"""
return self.fourier_expansion_homomorphism().matrix().left_kernel()
#===============================================================================
# _span
#
# This will be used in ExpansionModule_ambient_pid and
# ExpansionModule_submodule_pid
#===============================================================================
def _span( self, gens, base_ring = None, check = True, already_echelonized = False ) :
"""
The expansion submodule spanned by ``gens``.
INPUT:
- ``gens`` -- A list, tuple or sequence of module elements.
- ``base_ring`` -- A ring or ``None`` (default: ``None``); If ``None``
the base ring of ``self`` will be used.
- ``check`` -- A boolean (default: ``True``); If ``True`` check
whether the generators are appropriately coerced.
- ``already_echelonized`` -- A boolean (default: ``False``); If ``True``
the generators are already in echelon form
with respect to the ambient's basis.
OUTPUT:
An instance of :class:~`.ExpansionModule_submodule_pid`.
TESTS::
sage: from psage.modform.fourier_expansion_framework.gradedexpansions import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: emps = EquivariantMonoidPowerSeriesRing(NNMonoid(True), TrivialCharacterMonoid("1", ZZ), TrivialRepresentation("1", ZZ))
sage: em = ExpansionModule(Sequence([emps.one_element(), emps.one_element(), emps.one_element()]))
sage: em.span([em([1,0,0]), em([1,2,0])])
Module of Fourier expansions in Ring of equivariant monoid power series over NN
sage: em.span([em([1,0,0]), em([1,2,0])]).span([em([1,0,0])])
Module of Fourier expansions in Ring of equivariant monoid power series over NN
"""
if is_FreeModule(gens):
gens = gens.gens()
if not isinstance(gens, (list, tuple, Sequence)):
raise TypeError, "Argument gens (= %s) must be a list, tuple, or sequence." % (gens,)
if base_ring is None or base_ring == self.base_ring() :
gens = Sequence(gens, check = check, universe = self.ambient_module())
return ExpansionModule_submodule_pid(self.ambient_module(), gens)
else:
try:
M = self.ambient_module().change_ring(base_ring)
except TypeError:
raise ValueError, "Argument base_ring (= %s) is not compatible " % (base_ring,) + \
"with the base field (= %s)." % (self.base_field(),)
try:
return M.span(gens)
except TypeError:
raise ValueError, "Argument gens (= %s) is not compatible " % (gens,) + \
"with base_ring (= %s)." % (base_ring,)
#===============================================================================
# ExpansionModule_ambient_pid
#===============================================================================
class ExpansionModule_ambient_pid ( ExpansionModule_abstract, FreeModule_ambient_pid ) :
"""
An ambient module of expansions over a principal ideal domain.
"""
def __init__(self, basis, _element_class = None, **kwds) :
"""
INPUT:
- ``basis`` -- A list or sequence of (equivariant) monoid power series.
- ``element_class`` -- A type or ``None`` (default: ``None``); The element class
attached to ``self``. If ``None`` :class:~`.ExpansionModuleVector_generic`
will be used.
TESTS::
sage: from psage.modform.fourier_expansion_framework.gradedexpansions import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: emps = EquivariantMonoidPowerSeriesRing(NNMonoid(True), TrivialCharacterMonoid("1", ZZ), TrivialRepresentation("1", ZZ))
sage: em = ExpansionModule_ambient_pid(Sequence([emps.one_element(), emps.one_element(), emps.one_element()]))
sage: em = ExpansionModule_ambient_pid(Sequence([emps.one_element(), emps.one_element(), emps.one_element()]), _element_class = ExpansionModuleVector_generic)
"""
if not hasattr(self, '_element_class') :
if not _element_class is None :
self._element_class = _element_class
else :
self._element_class = ExpansionModuleVector_generic
if isinstance(basis.universe(), EquivariantMonoidPowerSeriesAmbient_abstract) \
and basis.universe().representation().base_ring() == basis.universe().representation().codomain() :
base_ring = basis.universe().base_ring()
elif isinstance(basis.universe(), MonoidPowerSeriesAmbient_abstract) \
and isinstance(basis.universe().coefficient_domain(), Ring) :
base_ring = basis.universe().base_ring()
else :
base_ring = basis.universe().base_ring().base_ring()
ExpansionModule_abstract.__init__(self, basis)
FreeModule_ambient_pid.__init__(self, base_ring, len(basis))
global _fourier_expansion_kernel, _span
fourier_expansion_kernel = _fourier_expansion_kernel
span = _span
def gen(self, i) :
"""
The `i`-th generator of the module.
INPUT:
- `i` -- An integer.
OUTPUT:
An element of ``self``.
TESTS::
sage: from psage.modform.fourier_expansion_framework.gradedexpansions import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: emps = EquivariantMonoidPowerSeriesRing(NNMonoid(True), TrivialCharacterMonoid("1", ZZ), TrivialRepresentation("1", ZZ))
sage: em = ExpansionModule_ambient_pid(Sequence([emps.one_element(), emps.one_element(), emps.one_element()]))
sage: em.gen(0)
(1, 0, 0)
"""
return self._element_class(self, FreeModule_ambient_pid.gen(self, i))
def basis(self) :
"""
A basis of ``self``.
OUTPUT:
A list of elements of ``self``.
TESTS::
sage: from psage.modform.fourier_expansion_framework.gradedexpansions import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: emps = EquivariantMonoidPowerSeriesRing(NNMonoid(True), TrivialCharacterMonoid("1", ZZ), TrivialRepresentation("1", ZZ))
sage: em = ExpansionModule_ambient_pid(Sequence([emps.one_element(), emps.one_element(), emps.one_element()]))
sage: em.basis()
[(1, 0, 0), (0, 1, 0), (0, 0, 1)]
"""
return map(lambda b: self._element_class(self, b), FreeModule_ambient_pid.basis(self))
def change_ring(self, R):
"""
Return the ambient expansion module over `R` with the same basis as ``self``.
INPUT:
- `R` -- A ring.
OUTPUT:
An instance of :class:~`.ExpansionModule_ambient_pid`.
TESTS::
sage: from psage.modform.fourier_expansion_framework.gradedexpansions import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: emps = EquivariantMonoidPowerSeriesRing(NNMonoid(True), TrivialCharacterMonoid("1", ZZ), TrivialRepresentation("1", ZZ))
sage: em = ExpansionModule_ambient_pid(Sequence([emps.one_element(), emps.one_element(), emps.one_element()]))
sage: em.change_ring(ZZ) is em
True
sage: emq = em.change_ring(QQ)
sage: emq.base_ring()
Rational Field
sage: emq.ambient_module() is emq
True
"""
if self.base_ring() == R :
return self
R = pushout(self._abstract_basis().universe(), R)
return ExpansionModule_ambient_pid(Sequence(self._abstract_basis(), universe = R), _element_class = self._element_class)
def ambient_module(self) :
"""
Return the ambient module of ``self``.
OUTPUT:
An instance of :class:~`.ExpansionModule_ambient_pid`.
TESTS::
sage: from psage.modform.fourier_expansion_framework.gradedexpansions import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: emps = EquivariantMonoidPowerSeriesRing(NNMonoid(True), TrivialCharacterMonoid("1", ZZ), TrivialRepresentation("1", ZZ))
sage: em = ExpansionModule_ambient_pid(Sequence([emps.one_element(), emps.one_element(), emps.one_element()]))
sage: em.ambient_module() is em
True
"""
return self
#===============================================================================
# ExpansionModule_submodule_pid
#===============================================================================
class ExpansionModule_submodule_pid ( ExpansionModule_abstract, FreeModule_submodule_pid ) :
"""
A submodule of another module of expansions over a principal ideal domain.
"""
def __init__(self, ambient, gens, _element_class = None, **kwds) :
"""
INPUT:
- ``ambient`` -- An instance of :class:~`.ExpansionModule_ambient_pid` or :class:~`.ExpansionModule_submodule_pid`.
- ``gens`` -- A list, tuple or sequence of elements of ``ambient``.
- ``element_class`` -- A type or ``None`` (default: ``None``); The element class
attached to ``self``. If ``None`` :class:~`.ExpansionModuleVector_generic`
will be used.
TESTS::
sage: from psage.modform.fourier_expansion_framework.gradedexpansions import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: emps = EquivariantMonoidPowerSeriesRing(NNMonoid(True), TrivialCharacterMonoid("1", ZZ), TrivialRepresentation("1", ZZ))
sage: em = ExpansionModule_ambient_pid(Sequence([emps.one_element(), emps.one_element(), emps.one_element()]))
sage: ems = ExpansionModule_submodule_pid(em, [em([1,0,0]), em([1,2,0])])
sage: ems = ExpansionModule_submodule_pid(em, [em([1,0,0]), em([1,2,0])], _element_class = ExpansionModuleVector_generic)
"""
if not hasattr(self, '_element_class') :
if not _element_class is None :
self._element_class = _element_class
else :
self._element_class = ExpansionModuleVector_generic
if ambient.precision().is_infinite() :
ExpansionModule_abstract.__init__(self, Sequence( map( lambda g: g.fourier_expansion(), gens ),
universe = ambient._abstract_basis().universe() ))
else :
ExpansionModule_abstract.__init__(self, Sequence( map( lambda g: LazyFourierExpansionEvaluation( ambient._abstract_basis().universe(), g,
ambient.precision() ),
gens ),
universe = ambient._abstract_basis().universe() ))
FreeModule_submodule_pid.__init__(self, ambient, gens)
global _fourier_expansion_kernel, _span
fourier_expansion_kernel = _fourier_expansion_kernel
span = _span
def gen(self, i) :
"""
The `i`-th generator of the module.
INPUT:
- `i` -- An integer.
OUTPUT:
An element of ``self``.
TESTS::
sage: from psage.modform.fourier_expansion_framework.gradedexpansions import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: emps = EquivariantMonoidPowerSeriesRing(NNMonoid(True), TrivialCharacterMonoid("1", ZZ), TrivialRepresentation("1", ZZ))
sage: em = ExpansionModule_ambient_pid(Sequence([emps.one_element(), emps.one_element(), emps.one_element()]))
sage: ems = ExpansionModule_submodule_pid(em, [em([1,0,0]), em([1,2,0])])
sage: ems.gen(0)
(1, 0, 0)
"""
return self._element_class(self, FreeModule_submodule_pid.gen(self, i).list())
def basis(self) :
"""
A basis of ``self``.
OUTPUT:
A list of elements of ``self``.
TESTS::
sage: from psage.modform.fourier_expansion_framework.gradedexpansions import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: emps = EquivariantMonoidPowerSeriesRing(NNMonoid(True), TrivialCharacterMonoid("1", ZZ), TrivialRepresentation("1", ZZ))
sage: em = ExpansionModule_ambient_pid(Sequence([emps.one_element(), emps.one_element(), emps.one_element()]))
sage: ems = ExpansionModule_submodule_pid(em, [em([1,0,0]), em([1,2,0])])
sage: ems.basis()
[(1, 0, 0), (0, 2, 0)]
"""
return [self._element_class(self, b.list()) for b in FreeModule_submodule_pid.basis(self)]
def change_ring(self, R):
"""
Return the ambient expansion module over `R` with the same basis as ``self``.
INPUT:
- `R` -- A ring.
OUTPUT:
An instance of :class:~`.ExpansionModule_ambient_pid`.
TESTS::
sage: from psage.modform.fourier_expansion_framework.gradedexpansions import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: emps = EquivariantMonoidPowerSeriesRing(NNMonoid(True), TrivialCharacterMonoid("1", ZZ), TrivialRepresentation("1", ZZ))
sage: em = ExpansionModule_ambient_pid(Sequence([emps.one_element(), emps.one_element(), emps.one_element()]))
sage: ems = ExpansionModule_submodule_pid(em, [em([1,0,0]), em([1,2,0])])
sage: emc = ems.change_ring(ZZ)
sage: emc.ambient_module() is emc
True
sage: emc = ems.change_ring(QQ)
sage: emc.ambient_module() is emc
True
sage: emc.base_ring()
Rational Field
"""
if self.base_ring() == R :
return ExpansionModule_ambient_pid(self._abstract_basis(), _element_class = self._element_class)
R = pushout(self._abstract_basis().universe(), R)
return ExpansionModule_ambient_pid(Sequence(self._abstract_basis(), universe = R), _element_class = self._element_class)
#===============================================================================
# ExpansionModuleVector_generic
#===============================================================================
class ExpansionModuleVector_generic ( FreeModuleElement_generic_dense, FourierExpansionWrapper ) :
"""
A generic implementation of an element in a module of expansions.
"""
def __init__(self, parent, x, coerce = True, copy = True) :
"""
INPUT:
- ``parent`` -- An instance of :class:~`.ExpansionModule_abstract`.
- `x` -- A list or tuple of integers or an element that admits coordinates
in ``parent``.
- ``coerce`` -- A boolean (default: ``True``); If ``True`` coerce coordinates into the base ring.
- ``copy`` -- A boolean (default: ``True``); If ``True`` store a copy of the coordinates.
TESTS::
sage: from psage.modform.fourier_expansion_framework.gradedexpansions import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: emps = EquivariantMonoidPowerSeriesRing(NNMonoid(True), TrivialCharacterMonoid("1", ZZ), TrivialRepresentation("1", ZZ))
sage: em = ExpansionModule(Sequence([emps.one_element(), emps.one_element(), emps.one_element()]))
sage: ExpansionModuleVector_generic(em, [1,0,2])
(1, 0, 2)
"""
if not isinstance(x, (list, tuple)) and x != 0 :
x = parent.ambient_module().coordinates(x)
coerce = False
copy = False
FreeModuleElement_generic_dense.__init__(self, parent, x, coerce, copy)
def _add_(left, right) :
"""
TESTS::
sage: from psage.modform.fourier_expansion_framework.gradedexpansions import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: emps = EquivariantMonoidPowerSeriesRing(NNMonoid(True), TrivialCharacterMonoid("1", ZZ), TrivialRepresentation("1", ZZ))
sage: em = ExpansionModule(Sequence([emps.one_element(), emps.one_element(), emps.one_element()]))
sage: em.0 + em.1
(1, 1, 0)
"""
return left.parent()._element_class(left.parent(), FreeModuleElement_generic_dense._add_(left, right))
def __copy__(self) :
"""
Return a copy of ``self``.
OUTPUT:
An instance of :class:~`.ExpansionModuleVector_generic`.
TESTS::
sage: from psage.modform.fourier_expansion_framework.gradedexpansions import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: emps = EquivariantMonoidPowerSeriesRing(NNMonoid(True), TrivialCharacterMonoid("1", ZZ), TrivialRepresentation("1", ZZ))
sage: em = ExpansionModule(Sequence([emps.one_element(), emps.one_element(), emps.one_element()]))
sage: copy(ExpansionModuleVector_generic(em, [1,0,2])) == ExpansionModuleVector_generic(em, [1,0,2])
True
"""
return ExpansionModuleVector_generic( self.parent(), self.list(), coerce = False, copy = True)
| Python |
"""
Lazy monoid power series which wrap graded expansions.
AUTHOR :
-- Martin Raum (2010 - 05 - 23) Initial version
"""
#===============================================================================
#
# Copyright (C) 2010 Martin Raum
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 3
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, see <http://www.gnu.org/licenses/>.
#
#===============================================================================
from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_lazyelement import EquivariantMonoidPowerSeries_lazy
def LazyFourierExpansionEvaluation(parent, element, precision) :
"""
Create an lazy equivaraint monoid power series which evaluates a
graded expansion.
INPUT:
- ``parent`` -- A ring or module of equivariant monoid power series.
- ``element`` -- A graded expansion element.
- ``precision`` -- A filter for the parent's action.
OUTPUT:
An instance of :class:~`fourier_expansion_framework.monoidpowerseries.monoidpowerseries_lazyelement.EquivariantMonoidPowerSeries_abstract_lazy`.
TESTS::
sage: from psage.modform.fourier_expansion_framework.gradedexpansions import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: emps = EquivariantMonoidPowerSeriesRing(NNMonoid(True), TrivialCharacterMonoid("1", ZZ), TrivialRepresentation("1", ZZ))
sage: em = ExpansionModule(Sequence([emps.one_element(), emps.one_element(), emps.one_element()]))
sage: h = LazyFourierExpansionEvaluation(emps, em([1,2,3]), emps.action().filter(3))
sage: h.coefficients()
{0: 6, 1: 0, 2: 0}
"""
if precision.is_infinite() :
raise ValueError( "Lazy evaluation of infinite expansions is not possible")
delayed_coeffs = DelayedEvaluation_fourier_expansion(parent, element)
return EquivariantMonoidPowerSeries_lazy(parent, precision, delayed_coeffs.getcoeff)
class DelayedEvaluation_fourier_expansion :
"""
Helper class which evaluates the a graded expansion on and returns its
coefficients.
"""
def __init__(self, parent, element) :
"""
INPUT:
- ``parent`` -- A ring or module of equivariant monoid power series.
- ``element`` -- A graded expansion element.
TESTS::
sage: from psage.modform.fourier_expansion_framework.gradedexpansions import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: emps = EquivariantMonoidPowerSeriesRing(NNMonoid(True), TrivialCharacterMonoid("1", ZZ), TrivialRepresentation("1", ZZ))
sage: em = ExpansionModule(Sequence([emps.one_element(), emps.one_element(), emps.one_element()]))
sage: de = DelayedEvaluation_fourier_expansion(emps, em([1,2,5]))
"""
self.__parent = parent
self.__element = element
def getcoeff(self, key) :
"""
Return a coefficient of the Fourier expansion of a graded expansion.
INPUT:
- ``key`` -- A pair ``(ch, k)`` of a character and a monoid element.
OUTPUT:
An element of the parents coefficient domain.
TESTS::
sage: from psage.modform.fourier_expansion_framework.gradedexpansions import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries import *
sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
sage: emps = EquivariantMonoidPowerSeriesRing(NNMonoid(True), TrivialCharacterMonoid("1", ZZ), TrivialRepresentation("1", ZZ))
sage: em = ExpansionModule(Sequence([emps.one_element(), emps.one_element(), emps.one_element()]))
sage: de = DelayedEvaluation_fourier_expansion(emps, em([1,2,-2]))
sage: (de.getcoeff(0), de.getcoeff(1))
(1, 0)
"""
try :
return self.__fourier_expansion[key]
except AttributeError :
self.__fourier_expansion = self.__element.fourier_expansion()
if self.__fourier_expansion.parent().coefficient_domain() != self.__parent.coefficient_domain() :
self.__fourier_expansion = self.__parent(self.__fourier_expansion)
return self.__fourier_expansion[key]
| Python |
from monoidpowerseries import *
from gradedexpansions import *
from modularforms import * | Python |
# -*- coding: utf-8 -*-
r"""
p-adic L-series of modular Jacobians with ordinary reduction at p.
REFERENCES:
- [MTT] B. Mazur, J. Tate, and J. Teitelbaum,
On `p`-adic analogues of the conjectures of Birch and
Swinnerton-Dyer, Inventiones mathematicae 84, (1986), 1-48.
- [SW] William Stein and Christian Wuthrich, Computations About
Tate-Shafarevich Groups using Iwasawa theory, preprint 2009.
AUTHORS:
- William Stein and Jennifer Balakrishnan (2010-07-01): first version
"""
######################################################################
# Copyright (C) 2010 William Stein <wstein@gmail.com>
#
# Distributed under the terms of the GNU General Public License (GPL)
#
# This code is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# General Public License for more details.
#
# The full text of the GPL is available at:
#
# http://www.gnu.org/licenses/
######################################################################
from sage.rings.integer_ring import ZZ
from sage.rings.rational_field import QQ
from sage.rings.padics.factory import Qp, Zp
from sage.rings.infinity import infinity
from sage.rings.all import LaurentSeriesRing, PowerSeriesRing, PolynomialRing, Integers
from sage.rings.integer import Integer
from sage.rings.arith import valuation, binomial, kronecker_symbol, gcd, prime_divisors, valuation
from sage.structure.sage_object import SageObject
from sage.misc.all import verbose, denominator, get_verbose
from sage.databases.cremona import parse_cremona_label
from sage.schemes.elliptic_curves.constructor import EllipticCurve
import sage.rings.arith as arith
from sage.modules.free_module_element import vector
import sage.matrix.all as matrix
# from sage.interfaces.all import gp
from sage.misc.functional import log
from sage.modular.modsym.modsym import ModularSymbols
class pAdicLseries(SageObject):
r"""
The `p`-adic L-series of a modular abelian variety.
EXAMPLES:
An ordinary example::
"""
def __init__(self, J, p, normalize='L_ratio'):
r"""
INPUT:
- ``J`` - modular abelian variety
- ``p`` - a prime of good reduction
- ``normalize`` - ``'L_ratio'`` (default), ``'period'`` or
``'none'``; this is describes the way the modular
symbols are normalized
"""
self._J = J
self._level = J.level()
self._p = ZZ(p)
self._normalize = normalize
if not self._p.is_prime():
raise ValueError, "p (=%s) must be a prime"%p
A = self._J.modular_symbols(sign=1)
self._modular_symbols_subspace = A
v = A.dual_eigenvector()
self._dual_eigenvector = v
self._hecke_eigenvalue_field = v[0].parent()
def __cmp__(self,other):
r"""
Compare self and other.
TESTS::
sage: lp1 = J0(23)[0].padic_lseries(5)
sage: lp2 = J0(23)[0].padic_lseries(7)
sage: lp3 = J0(29)[0].padic_lseries(5)
sage: lp1 == lp1
True
sage: lp1 == lp2
False
sage: lp1 == lp3
False
"""
c = cmp(type(self), type(other))
if c:
return c
return cmp((self._J, self._p), (other._J, other._p))
def modular_symbols_subspace(self):
"""
"""
return self._modular_symbols_subspace
def hecke_eigenvalue_field(self):
"""
The field of definition of the dual eigenform.
"""
return self._hecke_eigenvalue_field
def psi(self):
"""
The embedding $\Q(\alpha) \into \Q_p(a)$ sending $\alpha \mapsto a$.
"""
K_f = self._hecke_eigenvalue_field
p = self._p
# kbar = K_f.residue_field(p)
Q = Qp(p)
###split case
pOK = K_f.factor(p)
if (len(pOK) == 2 and pOK[0][1] == 1):
R = Q['x']
r1, r2 = R(K_f.defining_polynomial()).roots()
psi1 = K_f.hom([r1[0]])
psi2 = K_f.hom([r2[0]])
return [psi1, psi2]
else:
F = Q.extension(K_f.defining_polynomial(),names='a')
a = F.gen()
psi = self._psis = [K_f.hom([a])]
return psi
def modular_symbol(self,r):
"""
Compute the modular symbol at the cusp $r$.
"""
v = self._dual_eigenvector
try:
psis = self._psis
except AttributeError:
psis = self._psis = self.psi()
# TODO: rewrite this function to be a separate Cython class
# that just does reducing [r,infinity] to a rational using
# exactly the data that ones needs to do this (not going
# through modular symbols), and it'll make this massively
# faster.
if len(psis) == 1:
psi = psis[0]
M = self.modular_symbols_subspace().ambient()
s = M([r,infinity])
return psi(v.dot_product(s.element()))
else:
if self._emb == 1:
psi = psis[0]
elif self._emb == 2:
psi = psis[1]
# elif (self._current_alpha == self.alpha()[0]):
# psi = psis[0]
# else:
# psi = psis[1]
M = self.modular_symbols_subspace().ambient()
s = M([r,infinity])
return psi(v.dot_product(s.element()))
#############stuff for p-adic BSD, should be moved######
def regulator(self):
"""
"""
list = [23, 29, 31, 35, 39, 63,65, 87, 117, 135, 175, 189]
if (self.abelian_variety().level() in list):
return 1
else:
raise NotImplementedError
def rank(self):
"""
"""
list = [23, 29, 31, 35,39, 63,65, 87, 117, 135, 175, 189]
if (self.abelian_variety().level() in list):
return 1
else:
raise NotImplementedError
def tamagawa_prod(self):
"""
"""
list = [23, 29, 31, 35,39, 63,65, 87, 117, 125, 133, 135, 175, 189]
A = self.abelian_variety()
if A.dimension() != 2:
raise NotImplementedError
lev = self._level
if lev not in list:
raise NotImplementedError
elif lev == 23:
return 11
elif lev == 29:
return 7
elif lev == 31:
return 5
elif lev == 35:
return 32
elif lev == 39:
return 28
elif lev == 63:
return 6
elif self.label() == '65a(1,65)':
return 7
elif self.label() == '65b(1,65)':
return 3
elif lev == 87:
return 5
elif self.label() == '117a(1,117)':
return 12
elif self.label() == '117b(1,117)':
return 4
elif self.label() == '125b(1,125)':
return 5
elif self.label() == '133a(1,133)':
return 5
elif lev == 135:
return 3
elif lev == 175:
return 5
elif lev == 189:
return 3
def torsion_order(self):
"""
"""
list = [23, 29, 31, 35,39, 63,65, 87, 117, 125, 133, 135, 175, 189]
A = self.abelian_variety()
if A.dimension() != 2:
raise NotImplementedError
lev = self._level
if lev not in list:
raise NotImplementedError
elif lev == 23:
return 11
elif lev == 29:
return 7
elif lev == 31:
return 5
elif lev == 35:
return 16
elif lev == 39:
return 28
elif lev == 63:
return 6
elif self.label() == '65a(1,65)':
return 14
elif self.label() == '65b(1,65)':
return 6
elif lev == 87:
return 5
elif self.label() == '117a(1,117)':
return 6
elif self.label() == '117b(1,117)':
return 2
elif self.label() == '125b(1,125)':
return 5
elif self.label() == '133a(1,133)':
return 5
elif lev == 135:
return 3
elif lev == 175:
return 5
elif lev == 189:
return 3
def sha(self):
"""
"""
list = [23, 29, 31, 35,39, 63,65, 87, 117, 125, 133, 135, 175, 189]
A = self.abelian_variety()
if A.dimension() != 2:
raise NotImplementedError
lev = self._level
if lev not in list:
raise NotImplementedError
elif lev == 23:
return 1
elif lev == 29:
return 1
elif lev == 31:
return 1
elif lev == 35:
return 1
elif lev == 39:
return 1
elif lev == 63:
return 1
elif self.label() == '65a(1,65)':
return 2
elif self.label() == '65b(1,65)':
return 2
elif lev == 87:
return 1
elif self.label() == '117a(1,117)':
return 1
elif self.label() == '117b(1,117)':
return 1
elif self.label() == '125b(1,125)':
return 4
elif self.label() == '133a(1,133)':
return 4
elif lev == 135:
return 1
elif lev == 175:
return 1
elif lev == 189:
return 1
def rhs(self):
"""
"""
list = [23, 29, 31, 35,39, 63,65, 87, 117, 125, 133, 135, 175, 189]
lev = self.abelian_variety().level()
if lev not in list:
raise NotImplementedError
else:
try:
eps = (1-1/self.alpha()).norm()**2
except AttributeError:
eps = (1-1/self.alpha())**4
return eps*(self.tamagawa_prod()*self.sha())/(self.torsion_order()**2)
#######################################################
def abelian_variety(self):
r"""
Return the abelian variety to which this `p`-adic L-series is
associated.
EXAMPLES::
sage: L = J0(23)[0].padic_lseries(5)
sage: L.abelian_variety()
Simple abelian variety J0(23) of dimension 2
"""
return self._J
def prime(self):
r"""
Returns the prime `p` as in 'p-adic L-function'.
EXAMPLES::
sage: L = J0(23)[0].padic_lseries(5)
sage: L.prime()
5
"""
return self._p
def _repr_(self):
r"""
Return print representation.
EXAMPLES::
"""
s = "%s-adic L-series of %s"%(self._p, self._J)
if not self._normalize == 'L_ratio':
s += ' (not normalized)'
return s
def ap(self):
"""
Return the Hecke eigenvalue $a_p$.
EXAMPLES::
sage: J = J0(23)[0]
sage: [(p, J.padic_lseries(p)) for p in prime_range(5,30)]
(5, 2*alpha)
(7, 2*alpha + 2)
(11, -2*alpha - 4)
(13, 3)
(17, -2*alpha + 2)
(19, -2)
(23, 1)
(29, -3)
"""
try:
A = self._modular_symbols_subspace
except AttributeError:
A = self._modular_symbols_subspace = self.modular_symbols_subspace()
a_p = self._ap = A.eigenvalue(self._p)
return a_p
def is_ordinary(self):
"""
Check if $p$ is an ordinary prime.
"""
try:
K_f = self._hecke_eigenvalue_field
except AttributeError:
K_f = self._hecke_eigenvalue_field = self.hecke_eigenvalue_field()
try:
a_p = self._ap
except AttributeError:
a_p = self._ap = self.ap()
frak_p = [x[0] for x in K_f.factor(self._p)]
not_in_p = [x for x in frak_p if a_p not in frak_p]
if len(not_in_p) == 0:
return False
else:
return True
def measure(self,a,n,prec,quadratic_twist=+1,user_alpha=[],outside_call=False):
"""
outside_call: if using this from outside the series computation
"""
if quadratic_twist > 0:
s = +1
else:
s = -1
try:
p, alpha, z, w, f = self.__measure_data[(n,prec,s)]
except (KeyError, AttributeError):
if not hasattr(self, '__measure_data'):
self.__measure_data = {}
p = self._p
alpha = user_alpha
z = 1/(alpha**n)
w = p**(n-1)
f = self.modular_symbol
self.__measure_data[(n,prec,s)] = (p,alpha,z,w,f)
if outside_call:
if (user_alpha == self.alpha()[0]):
self._emb = 1
else:
self._emb = 2
if alpha != user_alpha:
alpha = user_alpha
z = 1/(alpha**n)
f = self.modular_symbol
self.__measure_data[(n,prec,s)] = (p,alpha,z,w,f)
if quadratic_twist == 1:
return z * f(a/(p*w)) - (z/alpha) * f(a/w)
else:
D = quadratic_twist
chip = kronecker_symbol(D,p)
if self._E.conductor() % p == 0:
mu = chip**n * z * sum([kronecker_symbol(D,u) * f(a/(p*w)+ZZ(u)/D) for u in range(1,abs(D))])
else:
mu = chip**n * sum([kronecker_symbol(D,u) *(z * f(a/(p*w)+ZZ(u)/D) - chip *(z/alpha)* f(a/w+ZZ(u)/D)) for u in range(1,abs(D))])
return s*mu
def alpha(self, prec=20):
r"""
Return a `p`-adic root `\alpha` of the polynomial `x^2 - a_p x
+ p` with `ord_p(\alpha) < 1`. In the ordinary case this is
just the unit root.
INPUT:
- ``prec`` - positive integer, the `p`-adic precision of the root.
EXAMPLES:
"""
try:
return self._alpha[prec]
except AttributeError:
self._alpha = {}
except KeyError:
pass
J = self._J
p = self._p
Q = Qp(p)
try:
a_p = self._ap
except AttributeError:
a_p = self._ap = self.ap()
try:
psis = self._psis
except AttributeError:
psis = self._psis = self.psi()
K_f = self.hecke_eigenvalue_field()
if len(psis) == 1:
F = Q.extension(K_f.defining_polynomial(),names='a')
a = F.gen()
G = K_f.embeddings(K_f)
if G[0](K_f.gen()) == K_f.gen():
conj_map = G[1]
else:
conj_map = G[0]
v = self._dual_eigenvector
v_conj = vector(conj_map(a) for a in v)
a_p_conj = conj_map(a_p)
R = F['x']
x = R.gen()
psi = psis[0]
a_p_padic = psi(a_p)
a_p_conj_padic = psi(a_p_conj)
f = x**2 - (a_p_padic)*x + p
fconj = x**2 - (a_p_conj_padic)*x + p
norm_f = f*fconj
norm_f_basefield = norm_f.change_ring(Q)
FF = norm_f_basefield().factor()
root0 = -f.gcd(FF[0][0])[0]
root1 = -f.gcd(FF[1][0])[0]
if root0.valuation() < 1:
padic_lseries_alpha = [root0]
else:
padic_lseries_alpha = [root1]
else:
a_p_conj_padic = []
a_p_padic = []
for psi in psis:
a_p_padic = a_p_padic + [psi(a_p)]
R = Q['x']
x = R.gen()
padic_lseries_alpha = []
for aps in a_p_padic:
f = R(x**2 - aps*x + p)
roots = f.roots()
root0 = roots[0][0]
root1 = roots[1][0]
if root0.valuation() < 1:
padic_lseries_alpha = padic_lseries_alpha + [root0]
else:
padic_lseries_alpha = padic_lseries_alpha + [root1]
return padic_lseries_alpha
def order_of_vanishing(self):
r"""
Return the order of vanishing of this `p`-adic L-series.
The output of this function is provably correct, due to a
theorem of Kato [Ka]. This function will terminate if and only if
the Mazur-Tate-Teitelbaum analogue [MTT] of the BSD conjecture about
the rank of the curve is true and the subgroup of elements of
`p`-power order in the Shafarevich-Tate group of this curve is
finite. I.e. if this function terminates (with no errors!),
then you may conclude that the `p`-adic BSD rank conjecture is
true and that the `p`-part of Sha is finite.
NOTE: currently `p` must be a prime of good ordinary reduction.
REFERENCES:
- [MTT] B. Mazur, J. Tate, and J. Teitelbaum,
On `p`-adic analogues of the conjectures of Birch and
Swinnerton-Dyer, Inventiones mathematicae 84, (1986), 1-48.
- [Ka] Kayuza Kato, `p`-adic Hodge theory and values of zeta functions of modular
forms, Cohomologies `p`-adiques et applications arithmetiques III,
Asterisque vol 295, SMF, Paris, 2004.
EXAMPLES::
"""
try:
return self.__ord
except AttributeError:
pass
if not self.is_ordinary():
raise NotImplementedError
E = self.elliptic_curve()
if not E.is_good(self.prime()):
raise ValueError, "prime must be of good reduction"
r = E.rank()
n = 1
while True:
f = self.series(n)
v = f.valuation()
if v < r:
raise RuntimeError, "while computing p-adic order of vanishing, got a contradiction: the curve is %s, the curve has rank %s, but the p-adic L-series vanishes to order <= %s"%(E, r, v)
if v == r:
self.__ord = v
return v
n += 1
def _c_bounds(self, n):
raise NotImplementedError
def _prec_bounds(self, n,prec):
raise NotImplementedError
def teichmuller(self, prec):
r"""
Return Teichmuller lifts to the given precision.
INPUT:
- ``prec`` - a positive integer.
OUTPUT:
- a list of `p`-adic numbers, the cached Teichmuller lifts
EXAMPLES::
sage: L = EllipticCurve('11a').padic_lseries(7)
sage: L.teichmuller(1)
[0, 1, 2, 3, 4, 5, 6]
sage: L.teichmuller(2)
[0, 1, 30, 31, 18, 19, 48]
"""
p = self._p
K = Qp(p, prec, print_mode='series')
return [Integer(0)] + \
[a.residue(prec).lift() for a in K.teichmuller_system()]
def _e_bounds(self, n, prec):
p = self._p
prec = max(2,prec)
R = PowerSeriesRing(ZZ,'T',prec+1)
T = R(R.gen(),prec +1)
w = (1+T)**(p**n) - 1
return [infinity] + [valuation(w[j],p) for j in range(1,min(w.degree()+1,prec))]
def _get_series_from_cache(self, n, prec, D):
try:
return self.__series[(n,prec,D)]
except AttributeError:
self.__series = {}
except KeyError:
for _n, _prec, _D in self.__series.keys():
if _n == n and _D == D and _prec >= prec:
return self.__series[(_n,_prec,_D)].add_bigoh(prec)
return None
def _set_series_in_cache(self, n, prec, D, f):
self.__series[(n,prec,D)] = f
def _quotient_of_periods_to_twist(self,D):
r"""
For a fundamental discriminant `D` of a quadratic number field
this computes the constant `\eta` such that
`\sqrt{D}\cdot\Omega_{E_D}^{+} =\eta\cdot
\Omega_E^{sign(D)}`. As in [MTT]_ page 40. This is either 1
or 2 unless the condition on the twist is not satisfied,
e.g. if we are 'twisting back' to a semi-stable curve.
REFERENCES:
- [MTT] B. Mazur, J. Tate, and J. Teitelbaum,
On `p`-adic analogues of the conjectures of Birch and
Swinnerton-Dyer, Invertiones mathematicae 84, (1986), 1-48.
.. note: No check on precision is made, so this may fail for huge `D`.
EXAMPLES::
"""
from sage.functions.all import sqrt
# This funciton does not depend on p and could be moved out of this file but it is needed only here
# Note that the number of real components does not change by twisting.
if D == 1:
return 1
if D > 1:
Et = self._E.quadratic_twist(D)
qt = Et.period_lattice().basis()[0]/self._E.period_lattice().basis()[0]
qt *= sqrt(qt.parent()(D))
else:
Et = self._E.quadratic_twist(D)
qt = Et.period_lattice().basis()[0]/self._E.period_lattice().basis()[1].imag()
qt *= sqrt(qt.parent()(-D))
verbose('the real approximation is %s'%qt)
# we know from MTT that the result has a denominator 1
return QQ(int(round(8*qt)))/8
class pAdicLseriesOrdinary(pAdicLseries):
"""
EXAMPLE:
sage: from psage.modform.rational.padic_lseries import *
sage: A = J0(188)[-2]
sage: L = pAdicLseriesOrdinary(A, 7)
sage: L.series()
O(7^20) + ((2*a + 4) + (6*a + 2)*7 + 6*7^2 + 4*a*7^3 + (4*a + 5)*7^4 + (4*a + 5)*7^5 + (6*a + 3)*7^6 + (2*a + 1)*7^7 + (5*a + 2)*7^8 + 5*7^9 + (2*a + 2)*7^10 + (5*a + 4)*7^11 + 3*a*7^12 + (5*a + 4)*7^13 + 5*a*7^14 + (3*a + 6)*7^15 + (5*a + 6)*7^16 + (6*a + 4)*7^17 + 5*a*7^18 + (3*a + 5)*7^19 + O(7^20))*T + ((5*a + 3) + (a + 6)*7 + (2*a + 1)*7^2 + (3*a + 2)*7^3 + (4*a + 2)*7^4 + 4*a*7^5 + (2*a + 6)*7^6 + 3*7^7 + (3*a + 5)*7^8 + (5*a + 2)*7^9 + (a + 3)*7^10 + 6*a*7^11 + (5*a + 5)*7^12 + (6*a + 6)*7^13 + (3*a + 4)*7^14 + (2*a + 4)*7^15 + (3*a + 6)*7^16 + (6*a + 1)*7^17 + 5*7^18 + (6*a + 5)*7^19 + O(7^20))*T^2 + ((3*a + 6) + (6*a + 6)*7 + 5*7^2 + 6*a*7^3 + (a + 4)*7^4 + (3*a + 2)*7^5 + 3*a*7^6 + (4*a + 6)*7^7 + (5*a + 2)*7^8 + 6*a*7^9 + (3*a + 1)*7^10 + (5*a + 3)*7^11 + (a + 1)*7^12 + (a + 4)*7^13 + (6*a + 2)*7^14 + (a + 2)*7^15 + (3*a + 1)*7^17 + (2*a + 5)*7^18 + (a + 3)*7^19 + O(7^20))*T^3 + ((3*a + 6) + (4*a + 3)*7 + (2*a + 3)*7^2 + (2*a + 2)*7^3 + 5*a*7^4 + 3*a*7^5 + (2*a + 5)*7^6 + (6*a + 1)*7^7 + (a + 2)*7^8 + (a + 1)*7^9 + (4*a + 5)*7^10 + 5*a*7^11 + (3*a + 4)*7^12 + (5*a + 6)*7^13 + (a + 5)*7^14 + 5*7^15 + 4*a*7^16 + (a + 3)*7^17 + (6*a + 2)*7^18 + (2*a + 3)*7^19 + O(7^20))*T^4 + O(T^5)
sage: L = pAdicLseriesOrdinary(A,19)
sage: f = L.series(n=3)
sage: f[2]
8 + 13*19 + 11*19^2 + 12*19^3 + 16*19^4 + 16*19^5 + 4*19^6 + 19^7 + 3*19^8 + 6*19^9 + 3*19^10 + 15*19^11 + 9*19^12 + 15*19^13 + 5*19^14 + 8*19^15 + 16*19^16 + 6*19^17 + 11*19^18 + 6*19^19 + O(19^20)
"""
def measure_experimental(self,a,n,prec,quadratic_twist=+1,alpha=[]):
"""
"""
if quadratic_twist > 0:
s = +1
else:
s = -1
try:
p, p_inv, alpha, alpha_inv, z, w, w_inv, f = self.__measure_data[(n,prec,s)]
except (KeyError, AttributeError):
if not hasattr(self, '__measure_data'):
self.__measure_data = {}
p = self._p
z = 1/(alpha**n)
w = p**(n-1)
f = self.modular_symbol
w_inv = ~w
alpha_inv = ~alpha
p_inv = p.parent()(1)/p
R = alpha.parent()
self.__measure_data[(n,prec,s)] = (R(p),R(p_inv),alpha,alpha_inv,z,R(w),R(w_inv),f)
if quadratic_twist == 1:
return z * f(a*p_inv*w_inv) - (z*alpha_inv) * f(a*w_inv)
else:
D = quadratic_twist
chip = kronecker_symbol(D,p)
if self._E.conductor() % p == 0:
mu = chip**n * z * sum([kronecker_symbol(D,u) * f(a/(p*w)+ZZ(u)/D) for u in range(1,abs(D))])
else:
mu = chip**n * sum([kronecker_symbol(D,u) *(z * f(a/(p*w)+ZZ(u)/D) - chip *(z/alpha)* f(a/w+ZZ(u)/D)) for u in range(1,abs(D))])
return s*mu
def series(self, n=2, quadratic_twist=+1, prec=5):
r"""
Returns the `n`-th approximation to the `p`-adic L-series as a
power series in `T` (corresponding to `\gamma-1` with
`\gamma=1+p` as a generator of `1+p\ZZ_p`). Each coefficient
is a `p`-adic number whose precision is provably correct.
Here the normalization of the `p`-adic L-series is chosen such
that `L_p(J,1) = (1-1/\alpha)^2 L(J,1)/\Omega_J` where
`\alpha` is the unit root
INPUT:
- ``n`` - (default: 2) a positive integer
- ``quadratic_twist`` - (default: +1) a fundamental
discriminant of a quadratic field, coprime to the
conductor of the curve
- ``prec`` - (default: 5) maximal number of terms of the
series to compute; to compute as many as possible just
give a very large number for ``prec``; the result will
still be correct.
ALIAS: power_series is identical to series.
EXAMPLES:
sage: J = J0(188)[0]
sage: p = 7
sage: L = J.padic_lseries(p)
sage: L.is_ordinary()
True
sage: f = L.series(2)
sage: f[0]
O(7^20)
sage: f[1].norm()
3 + 4*7 + 3*7^2 + 6*7^3 + 5*7^4 + 5*7^5 + 6*7^6 + 4*7^7 + 5*7^8 + 7^10 + 5*7^11 + 4*7^13 + 4*7^14 + 5*7^15 + 2*7^16 + 5*7^17 + 7^18 + 7^19 + O(7^20)
"""
n = ZZ(n)
if n < 1:
raise ValueError, "n (=%s) must be a positive integer"%n
if not self.is_ordinary():
raise ValueError, "p (=%s) must be an ordinary prime"%p
# check if the conditions on quadratic_twist are satisfied
D = ZZ(quadratic_twist)
if D != 1:
if D % 4 == 0:
d = D//4
if not d.is_squarefree() or d % 4 == 1:
raise ValueError, "quadratic_twist (=%s) must be a fundamental discriminant of a quadratic field"%D
else:
if not D.is_squarefree() or D % 4 != 1:
raise ValueError, "quadratic_twist (=%s) must be a fundamental discriminant of a quadratic field"%D
if gcd(D,self._p) != 1:
raise ValueError, "quadratic twist (=%s) must be coprime to p (=%s) "%(D,self._p)
if gcd(D,self._E.conductor())!= 1:
for ell in prime_divisors(D):
if valuation(self._E.conductor(),ell) > valuation(D,ell) :
raise ValueError, "can not twist a curve of conductor (=%s) by the quadratic twist (=%s)."%(self._E.conductor(),D)
p = self._p
if p == 2 and self._normalize :
print 'Warning : For p=2 the normalization might not be correct !'
#verbose("computing L-series for p=%s, n=%s, and prec=%s"%(p,n,prec))
# bounds = self._prec_bounds(n,prec)
# padic_prec = max(bounds[1:]) + 5
padic_prec = 10
# verbose("using p-adic precision of %s"%padic_prec)
res_series_prec = min(p**(n-1), prec)
verbose("using series precision of %s"%res_series_prec)
ans = self._get_series_from_cache(n, res_series_prec,D)
if not ans is None:
verbose("found series in cache")
return ans
K = QQ
gamma = K(1 + p)
R = PowerSeriesRing(K,'T',res_series_prec)
T = R(R.gen(),res_series_prec )
#L = R(0)
one_plus_T_factor = R(1)
gamma_power = K(1)
teich = self.teichmuller(padic_prec)
p_power = p**(n-1)
# F = Qp(p,padic_prec)
verbose("Now iterating over %s summands"%((p-1)*p_power))
verbose_level = get_verbose()
count_verb = 0
alphas = self.alpha()
#print len(alphas)
Lprod = []
self._emb = 0
if len(alphas) == 2:
split = True
else:
split = False
for alpha in alphas:
L = R(0)
self._emb = self._emb + 1
for j in range(p_power):
s = K(0)
if verbose_level >= 2 and j/p_power*100 > count_verb + 3:
verbose("%.2f percent done"%(float(j)/p_power*100))
count_verb += 3
for a in range(1,p):
if split:
# b = ((F.teichmuller(a)).lift() % ZZ(p**n))
b = (teich[a]) % ZZ(p**n)
b = b*gamma_power
else:
b = teich[a] * gamma_power
s += self.measure(b, n, padic_prec,D,alpha)
L += s * one_plus_T_factor
one_plus_T_factor *= 1+T
gamma_power *= gamma
Lprod = Lprod + [L]
if len(Lprod)==1:
return Lprod[0]
else:
return Lprod[0]*Lprod[1]
power_series = series
| Python |
#################################################################################
#
# (c) Copyright 2010 William Stein
#
# This file is part of PSAGE
#
# PSAGE is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# PSAGE is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
#
#################################################################################
"""
Miscellaneous code related to rational modular forms, until I find a
better place to put it.
WARNING: Depend on this code at your own risk! It will get moved to
another module at some point, probably.
"""
def modular_symbols_from_curve(C, N, num_factors=3):
"""
Find the modular symbols spaces that shoudl correspond to the
Jacobian of the given hyperelliptic curve, up to the number of
factors we consider.
INPUT:
- C -- a hyperelliptic curve over QQ
- N -- a positive integer
- num_factors -- number of Euler factors to verify match up; this is
important, because if, e.g., there is only one factor of degree g(C), we
don't want to just immediately conclude that Jac(C) = A_f.
OUTPUT:
- list of all sign 1 simple modular symbols factor of level N
that correspond to a simple modular abelian A_f
that is isogenous to Jac(C).
EXAMPLES::
sage: from psage.modform.rational.unfiled import modular_symbols_from_curve
sage: R.<x> = ZZ[]
sage: f = x^7+4*x^6+5*x^5+x^4-3*x^3-2*x^2+1
sage: C1 = HyperellipticCurve(f)
sage: modular_symbols_from_curve(C1, 284)
[Modular Symbols subspace of dimension 3 of Modular Symbols space of dimension 39 for Gamma_0(284) of weight 2 with sign 1 over Rational Field]
sage: f = x^7-7*x^5-11*x^4+5*x^3+18*x^2+4*x-11
sage: C2 = HyperellipticCurve(f)
sage: modular_symbols_from_curve(C2, 284)
[Modular Symbols subspace of dimension 3 of Modular Symbols space of dimension 39 for Gamma_0(284) of weight 2 with sign 1 over Rational Field]
"""
# We will use the Eichler-Shimura relation and David Harvey's
# p-adic point counting hypellfrob. Harvey's code has the
# constraint: p > (2*g + 1)*(2*prec - 1).
# So, find the smallest p not dividing N that satisfies the
# above constraint, for our given choice of prec.
f, f2 = C.hyperelliptic_polynomials()
if f2 != 0:
raise NotImplementedError, "curve must be of the form y^2 = f(x)"
if f.degree() % 2 == 0:
raise NotImplementedError, "curve must be of the form y^2 = f(x) with f(x) odd"
prec = 1
g = C.genus()
B = (2*g + 1)*(2*prec - 1)
from sage.rings.all import next_prime
p = B
# We use that if F(X) is the characteristic polynomial of the
# Hecke operator T_p, then X^g*F(X+p/X) is the characteristic
# polynomial of Frob_p, because T_p = Frob_p + p/Frob_p, according
# to Eichler-Shimura. Use this to narrow down the factors.
from sage.all import ModularSymbols, Integers, get_verbose
D = ModularSymbols(N,sign=1).cuspidal_subspace().new_subspace().decomposition()
D = [A for A in D if A.dimension() == g]
from sage.schemes.hyperelliptic_curves.hypellfrob import hypellfrob
while num_factors > 0:
p = next_prime(p)
while N % p == 0: p = next_prime(p)
R = Integers(p**prec)['X']
X = R.gen()
D2 = []
# Compute the charpoly of Frobenius using hypellfrob
M = hypellfrob(p, 1, f)
H = R(M.charpoly())
for A in D:
F = R(A.hecke_polynomial(p))
# Compute charpoly of Frobenius from F(X)
G = R(F.parent()(X**g * F(X + p/X)))
if get_verbose(): print (p, G, H)
if G == H:
D2.append(A)
D = D2
num_factors -= 1
return D
| Python |
#################################################################################
#
# (c) Copyright 2011 William Stein
#
# This file is part of PSAGE
#
# PSAGE is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# PSAGE is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
#
#################################################################################
"""
Python code for very fast high precision computation of certain
specific modular forms of interest.
"""
import sys
from sage.rings.all import ZZ, QQ, PolynomialRing
from sage.modular.all import eisenstein_series_qexp, ModularForms
from sage.misc.all import cached_function, cputime, prod
from psage.modform.rational.special_fast import (
_change_ring_ZZ, _evaluate_series_at_power_of_gen,
Integer_list_to_polynomial)
def degen(h, n):
"""
Return power series h(q^n) to the same precision as h.
INPUT:
- h -- power series over the rational numbers
- n -- positive integer
OUTPUT:
- power series over the rational numbers
EXAMPLES::
sage: from psage.modform.rational.special import degen
sage: R.<q> = QQ[[]]
sage: f = 2/3 + 3*q + 14*q^2 + O(q^3)
sage: degen(f,2)
2/3 + 3*q^2 + O(q^3)
"""
if n == 1:
return h
return _evaluate_series_at_power_of_gen(h,n,True)
#############################################################
@cached_function
def cached_eisenstein_series_qexp(k, prec, verbose=False):
"""
Return q-expansion of the weight k level 1 Eisenstein series to
the requested precision. The result is cached, so that subsequent
calls are quick.
INPUT:
- k -- even positive integer
- prec -- positive integer
- verbose -- bool (default: False); if True, print timing information
OUTPUT:
- power series over the rational numbers
EXAMPLES::
sage: from psage.modform.rational.special import cached_eisenstein_series_qexp
sage: cached_eisenstein_series_qexp(4, 10)
1/240 + q + 9*q^2 + 28*q^3 + 73*q^4 + 126*q^5 + 252*q^6 + 344*q^7 + 585*q^8 + 757*q^9 + O(q^10)
sage: cached_eisenstein_series_qexp(4, 5, verbose=True)
Computing E_4(q) + O(q^5)... (time = ... seconds)
1/240 + q + 9*q^2 + 28*q^3 + 73*q^4 + O(q^5)
sage: cached_eisenstein_series_qexp(4, 5, verbose=True) # cache used, so no timing printed
1/240 + q + 9*q^2 + 28*q^3 + 73*q^4 + O(q^5)
"""
if verbose: print "Computing E_%s(q) + O(q^%s)..."%(k,prec),; sys.stdout.flush(); t = cputime()
e = eisenstein_series_qexp(k, prec)
if verbose: print "(time = %.2f seconds)"%cputime(t)
return e
def eis_qexp(k, t, prec, verbose=False):
"""
Return the q-expansion of holomorphic level t weight k Eisenstein
series. Thus when k=2, this is E2(q) - t*E2(q^t), and is Ek(q^t)
otherwise.
INPUT:
- k -- even positive integer
- t -- positive integer
- prec -- positive integer
- verbose -- bool (default: False); if True, print timing information
OUTPUT:
- power series over the rational numbers
EXAMPLES::
sage: from psage.modform.rational.special import eis_qexp
sage: eis_qexp(2, 1, 8) # output is 0, since holomorphic
O(q^8)
sage: eis_qexp(2, 3, 8)
1/12 + q + 3*q^2 + q^3 + 7*q^4 + 6*q^5 + 3*q^6 + 8*q^7 + O(q^8)
sage: E2 = eisenstein_series_qexp(2, 8)
sage: q = E2.parent().0
sage: E2(q) - 3*E2(q^3)
1/12 + q + 3*q^2 + q^3 + 7*q^4 + 6*q^5 + 3*q^6 + 8*q^7 + O(q^8)
sage: eis_qexp(4, 3, 8)
1/240 + q^3 + 9*q^6 + O(q^8)
sage: eisenstein_series_qexp(4, 8)(q^3)
1/240 + q^3 + 9*q^6 + 28*q^9 + 73*q^12 + 126*q^15 + 252*q^18 + 344*q^21 + O(q^24)
Test verbose::
sage: eis_qexp(2, 5, 7, verbose=True)
Computing E_2(q) + O(q^8)... (time = ... seconds)
1/6 + q + 3*q^2 + 4*q^3 + 7*q^4 + q^5 + 12*q^6 + O(q^7)
"""
Ek = cached_eisenstein_series_qexp(k, prec+1, verbose=verbose)
q = Ek.parent().gen()
if k == 2:
e = Ek - t*degen(Ek,t)
else:
e = degen(Ek,t)
return e.add_bigoh(prec)
def eisenstein_gens(N, k, prec, verbose=False):
r"""
Find spanning list of 'easy' generators for the subspace of
`M_k(\Gamma_0(N))` spanned by polynomials in Eisenstein series.
The meaning of 'easy' is that the modular form is a monomial of
weight `k` in the images of Eisenstein series from level `1` of
weight dividing `k`. Note that this list need not span the full
space `M_k(\Gamma_0(N))`
INPUT:
- N -- positive integer
- k -- even positive integer
- prec -- positive integer
- verbose -- bool (default: False); if True, print timing information
OUTPUT:
- list of triples (t,w,E), where E is the q-expansion of the
weight w, holomorphic Eisenstein series of level t.
EXAMPLES::
sage: from psage.modform.rational.special import eisenstein_gens
sage: eisenstein_gens(5,4,6)
[(1, 2, O(q^6)), (5, 2, 1/6 + q + 3*q^2 + 4*q^3 + 7*q^4 + q^5 + O(q^6)), (1, 4, 1/240 + q + 9*q^2 + 28*q^3 + 73*q^4 + 126*q^5 + O(q^6)), (5, 4, 1/240 + q^5 + O(q^6))]
sage: eisenstein_gens(11,2,6)
[(1, 2, O(q^6)), (11, 2, 5/12 + q + 3*q^2 + 4*q^3 + 7*q^4 + 6*q^5 + O(q^6))]
Test verbose option::
sage: eisenstein_gens(11,2,9,verbose=True)
Computing E_2(q) + O(q^10)... (time = 0.00 seconds)
[(1, 2, O(q^9)), (11, 2, 5/12 + q + 3*q^2 + 4*q^3 + 7*q^4 + 6*q^5 + 12*q^6 + 8*q^7 + 15*q^8 + O(q^9))]
"""
assert N > 1
if k % 2 != 0:
return []
div = ZZ(N).divisors()
gens = []
for w in range(2, k+1, 2):
d = div if w > 2 else div[1:]
for t in div:
gens.append((t, w, eis_qexp(w, t, prec, verbose=verbose)))
return gens
class EisensteinMonomial(object):
"""
A monomial in terms of Eisenstein series.
"""
def __init__(self, v):
"""
INPUT:
- v -- a list of triples (k,t,n) that corresponds to E_k(q^t)^n.
EXAMPLES::
sage: from psage.modform.rational.special import EisensteinMonomial
sage: e = EisensteinMonomial([(5,4,2), (5,6,3)]); e
E4(q^5)^2*E6(q^5)^3
sage: type(e)
<class 'psage.modform.rational.special.EisensteinMonomial'>
"""
self._v = v
def __repr__(self):
"""
EXAMPLES::
sage: from psage.modform.rational.special import EisensteinMonomial
sage: e = EisensteinMonomial([(5,4,12), (5,6,3)]); e.__repr__()
'E4(q^5)^12*E6(q^5)^3'
"""
return '*'.join(['E%s%s(q^%s)^%s'%(k,'^*' if k==2 else '', t,e) for t,k,e in self._v])
def qexp(self, prec, verbose=False):
"""
The q-expansion of a monomial in Eisenstein series.
INPUT:
- prec -- positive integer
- verbose -- bool (default: False)
EXAMPLES::
sage: from psage.modform.rational.special import EisensteinMonomial
sage: e = EisensteinMonomial([(5,4,2), (5,6,3)])
sage: e.qexp(11)
-1/7374186086400 + 43/307257753600*q^5 - 671/102419251200*q^10 + O(q^11)
sage: E4 = eisenstein_series_qexp(4,11); q = E4.parent().gen()
sage: E6 = eisenstein_series_qexp(6,11)
sage: (E4(q^5)^2 * E6(q^5)^3).add_bigoh(11)
-1/7374186086400 + 43/307257753600*q^5 - 671/102419251200*q^10 + O(q^11)
"""
z = [eis_qexp(k, t, prec, verbose=verbose)**e for t,k,e in self._v]
if verbose: print "Arithmetic to compute %s +O(q^%s)"%(self, prec); sys.stdout.flush(); t=cputime()
p = prod(z)
if verbose: print "(time = %.2f seconds)"%cputime(t)
return p
def _monomials(v, n, i):
"""
Used internally for recursively computing monomials function.
Returns each power of the ith generator times all products not
involving the ith generator.
INPUT:
- `v` -- see docstring for monomials
- `n` -- see docstring for monomials
- `i` -- nonnegative integer
OUTPUT:
- list
EXAMPLES::
sage: from psage.modform.rational.special import _monomials
sage: R.<x,y> = QQ[]
sage: _monomials([(x,2),(y,3)], 6, 0)
[y^2, x^3]
sage: _monomials([(x,2),(y,3)], 6, 1)
[x^3, y^2]
"""
# each power of the ith generator times all products
# not involving the ith generator.
if len(v) == 1:
b, k = v[0]
if n%k == 0:
return [b**(n//k)]
else:
return []
else:
z, k = v[i]
w = list(v)
del w[i]
m = 0
y = 1
result = []
while m <= n:
for X in monomials(w, n - m):
result.append(X*y)
y *= z
m += k
return result
def monomials(v, n):
"""
Return homogeneous monomials of degree exactly n.
INPUT:
- v -- list of pairs (x,d), where x is a ring element that
we view as having degree d.
- n -- positive integer
OUTPUT:
- list of monomials in elements of v
EXAMPLES::
sage: from psage.modform.rational.special import monomials
sage: R.<x,y> = QQ[]
sage: monomials([(x,2),(y,3)], 6)
[y^2, x^3]
sage: [monomials([(x,2),(y,3)], i) for i in [0..6]]
[[1], [], [x], [y], [x^2], [x*y], [y^2, x^3]]
"""
if len(v) == 0:
return []
return _monomials(v, n, 0)
def eisenstein_basis(N, k, verbose=False):
r"""
Find spanning list of 'easy' generators for the subspace of
`M_k(\Gamma_0(N))` generated by level 1 Eisenstein series and
their images of even integer weights up to `k`.
INPUT:
- N -- positive integer
- k -- positive integer
- ``verbose`` -- bool (default: False)
OUTPUT:
- list of monomials in images of level 1 Eisenstein series
- prec of q-expansions needed to determine element of
`M_k(\Gamma_0(N))`.
EXAMPLES::
sage: from psage.modform.rational.special import eisenstein_basis
sage: eisenstein_basis(5,4)
([E4(q^5)^1, E4(q^1)^1, E2^*(q^5)^2], 3)
sage: eisenstein_basis(11,2,verbose=True) # warning below because of verbose
Warning -- not enough series.
([E2^*(q^11)^1], 2)
sage: eisenstein_basis(11,2,verbose=False)
([E2^*(q^11)^1], 2)
"""
assert N > 1
if k % 2 != 0:
return []
# Make list E of Eisenstein series, to enough precision to
# determine them, until we span space.
M = ModularForms(N, k)
prec = M.echelon_basis()[-1].valuation() + 1
gens = eisenstein_gens(N, k, prec)
R = PolynomialRing(ZZ, len(gens), ['E%sq%s'%(g[1],g[0]) for g in gens])
z = [(R.gen(i), g[1]) for i, g in enumerate(gens)]
m = monomials(z, k)
A = QQ**prec
V = A.zero_subspace()
E = []
for i, z in enumerate(m):
d = z.degrees()
f = prod(g[2]**d[i] for i, g in enumerate(gens) if d[i])
v = A(f.padded_list(prec))
if v not in V:
V = V + A.span([v])
w = [(gens[i][0],gens[i][1],d[i]) for i in range(len(d)) if d[i]]
E.append(EisensteinMonomial(w))
if V.dimension() == M.dimension():
return E, prec
if verbose: print "Warning -- not enough series."
return E, prec
class FastModularForm(object):
"""
EXAMPLES::
sage: from psage.modform.rational.special import FastModularForm
Level 5, weight 4::
sage: f = FastModularForm(CuspForms(5,4).0); f
(-250/3)*E4(q^5)^1 + (-10/3)*E4(q^1)^1 + (13)*E2^*(q^5)^2
sage: f.qexp(10)
q - 4*q^2 + 2*q^3 + 8*q^4 - 5*q^5 - 8*q^6 + 6*q^7 - 23*q^9 + O(q^10)
sage: parent(f.qexp(10))
Power Series Ring in q over Integer Ring
sage: t=cputime(); h=f.qexp(10^5); assert cputime(t)<5 # a little timing test.
Level 5, weight 6::
sage: f = CuspForms(5,6).0; g = FastModularForm(f); g
(521/6)*E6(q^5)^1 + (-1/30)*E6(q^1)^1 + (248)*E2^*(q^5)^1*E4(q^5)^1
Level 8, weight 4::
sage: f = CuspForms(8,4).0; g = FastModularForm(f); g
(-256/3)*E4(q^8)^1 + (4)*E4(q^4)^1 + (1)*E4(q^2)^1 + (-4/3)*E4(q^1)^1 + (4)*E2^*(q^8)^2
Level 7, weight 4::
sage: f = CuspForms(7,4).0; g = FastModularForm(f); g
(-147/2)*E4(q^7)^1 + (-3/2)*E4(q^1)^1 + (5)*E2^*(q^7)^2
"""
def __init__(self, f, verbose=False):
"""
EXAMPLES::
Level 3, weight 6::
sage: from psage.modform.rational.special import FastModularForm
sage: f = CuspForms(3,6).0; g = FastModularForm(f); g
(549/10)*E6(q^3)^1 + (-3/10)*E6(q^1)^1 + (312)*E2^*(q^3)^1*E4(q^3)^1
sage: type(g)
<class 'psage.modform.rational.special.FastModularForm'>
"""
import sage.modular.modform.element
if not isinstance(f, sage.modular.modform.element.ModularForm_abstract):
raise TypeError
chi = f.character()
if not chi or not chi.is_trivial():
raise ValueError, "form must trivial character"
self._f = f
N = f.level()
k = f.weight()
B, prec = eisenstein_basis(N, k, verbose=verbose)
# Now write f in terms of q-expansions of elements in B.
V = QQ**prec
W = V.span_of_basis([V(h.qexp(prec).padded_list()) for h in B])
self._basis = B
self._coordinates = W.coordinates(f.qexp(prec).padded_list())
self._verbose = verbose
assert self.qexp(prec) == f.qexp(prec), "bug -- q-expansions don't match"
def qexp(self, prec):
"""
Return the q-expansion of this fast modular form to the given
precision.
EXAMPLES::
sage: from psage.modform.rational.special import FastModularForm
sage: f = FastModularForm(CuspForms(5,4).0); f
(-250/3)*E4(q^5)^1 + (-10/3)*E4(q^1)^1 + (13)*E2^*(q^5)^2
sage: f.qexp(10)
q - 4*q^2 + 2*q^3 + 8*q^4 - 5*q^5 - 8*q^6 + 6*q^7 - 23*q^9 + O(q^10)
sage: g = f.modular_form(); g
q - 4*q^2 + 2*q^3 + 8*q^4 - 5*q^5 + O(q^6)
sage: g.qexp(10)
q - 4*q^2 + 2*q^3 + 8*q^4 - 5*q^5 - 8*q^6 + 6*q^7 - 23*q^9 + O(q^10)
"""
f = sum(c*self._basis[i].qexp(prec, verbose=self._verbose)
for i, c in enumerate(self._coordinates) if c)
return ZZ[['q']](_change_ring_ZZ(f.polynomial()), prec)
q_expansion = qexp
def modular_form(self):
"""
Return the underlying modular form object.
EXAMPLES::
sage: from psage.modform.rational.special import FastModularForm
sage: f = FastModularForm(CuspForms(5,4).0); f
(-250/3)*E4(q^5)^1 + (-10/3)*E4(q^1)^1 + (13)*E2^*(q^5)^2
sage: f.qexp(10)
q - 4*q^2 + 2*q^3 + 8*q^4 - 5*q^5 - 8*q^6 + 6*q^7 - 23*q^9 + O(q^10)
sage: g = f.modular_form(); g.qexp(10)
q - 4*q^2 + 2*q^3 + 8*q^4 - 5*q^5 - 8*q^6 + 6*q^7 - 23*q^9 + O(q^10)
"""
return self._f
def __repr__(self):
"""
Print representation.
EXAMPLES::
sage: from psage.modform.rational.special import FastModularForm
sage: f = FastModularForm(CuspForms(5,4).0)
sage: f.__repr__()
'(-250/3)*E4(q^5)^1 + (-10/3)*E4(q^1)^1 + (13)*E2^*(q^5)^2'
"""
return ' + '.join('(%s)*%s'%(c, self._basis[i]) for i, c in enumerate(self._coordinates) if c)
#####################################################
# CM forms
#####################################################
from sage.all import fast_callable, prime_range, SR
from psage.ellcurve.lseries.helper import extend_multiplicatively_generic
def elliptic_cm_form(E, n, prec, aplist_only=False, anlist_only=False):
"""
Return q-expansion of the CM modular form associated to the n-th
power of the Grossencharacter associated to the elliptic curve E.
INPUT:
- E -- CM elliptic curve
- n -- positive integer
- prec -- positive integer
- aplist_only -- return list only of ap for p prime
- anlist_only -- return list only of an
OUTPUT:
- power series with integer coefficients
EXAMPLES::
sage: from psage.modform.rational.special import elliptic_cm_form
sage: f = CuspForms(121,4).newforms(names='a')[0]; f
q + 8*q^3 - 8*q^4 + 18*q^5 + O(q^6)
sage: E = EllipticCurve('121b')
sage: elliptic_cm_form(E, 3, 7)
q + 8*q^3 - 8*q^4 + 18*q^5 + O(q^7)
sage: g = elliptic_cm_form(E, 3, 100)
sage: g == f.q_expansion(100)
True
"""
if not E.has_cm():
raise ValueError, "E must have CM"
n = ZZ(n)
if n <= 0:
raise ValueError, "n must be positive"
prec = ZZ(prec)
if prec <= 0:
return []
elif prec <= 1:
return [ZZ(0)]
elif prec <= 2:
return [ZZ(0), ZZ(1)]
# Derive formula for sum of n-th powers of roots
a,p,T = SR.var('a,p,T')
roots = (T**2 - a*T + p).roots(multiplicities=False)
s = sum(alpha**n for alpha in roots).simplify_full()
# Create fast callable expression from formula
g = fast_callable(s.polynomial(ZZ))
# Compute aplist for the curve
v = E.aplist(prec)
# Use aplist to compute ap values for the CM form attached to n-th
# power of Grossencharacter.
P = prime_range(prec)
if aplist_only:
# case when we only want the a_p (maybe for computing an
# L-series via Euler product)
return [g(ap,p) for ap,p in zip(v,P)]
# Default cause where we want all a_n
anlist = [ZZ(0),ZZ(1)] + [None]*(prec-2)
for ap,p in zip(v,P):
anlist[p] = g(ap,p)
# Fill in the prime power a_{p^r} for r >= 2.
N = E.conductor()
for p in P:
prm2 = 1
prm1 = p
pr = p*p
pn = p**n
e = 1 if N%p else 0
while pr < prec:
anlist[pr] = anlist[prm1] * anlist[p]
if e:
anlist[pr] -= pn * anlist[prm2]
prm2 = prm1
prm1 = pr
pr *= p
# fill in a_n with n divisible by at least 2 primes
extend_multiplicatively_generic(anlist)
if anlist_only:
return anlist
f = Integer_list_to_polynomial(anlist, 'q')
return ZZ[['q']](f, prec=prec)
| Python |
#################################################################################
#
# (c) Copyright 2010 William Stein
#
# This file is part of PSAGE
#
# PSAGE is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# PSAGE is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
#
#################################################################################
from newforms import (degrees,
eigenvalue_fields)
| Python |
#################################################################################
#
# (c) Copyright 2010 William Stein
#
# This file is part of PSAGE
#
# PSAGE is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# PSAGE is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
#
#################################################################################
"""
Bases of newforms for classical GL2 modular forms over QQ.
"""
def degrees(N, k, eps=None):
"""
Return the degrees of the newforms of level N, weight k, with character eps.
INPUT:
- N -- level; positive integer or Dirichlet character
- k -- weight; integer at least 2
- eps -- None or Dirichlet character; if specified N is ignored
EXAMPLES::
sage: import psage
sage: psage.modform.rational.degrees(11,2)
[1]
sage: psage.modform.rational.degrees(37,2)
[1, 1]
sage: psage.modform.rational.degrees(43,2)
[1, 2]
sage: psage.modform.rational.degrees(DirichletGroup(13).0^2,2)
[1]
sage: psage.modform.rational.degrees(13,2,DirichletGroup(13).0^2)
[1]
sage: psage.modform.rational.degrees(13,2)
[]
"""
group = eps if eps else N
from sage.all import ModularSymbols, dimension_new_cusp_forms
d = dimension_new_cusp_forms(group, k)
if d == 0:
# A useful optimization!
return []
M = ModularSymbols(group=group, weight=k, sign=1).cuspidal_subspace()
N = M.new_subspace()
D = N.decomposition()
# TODO: put in a consistency check.
degs = [f.dimension() for f in D]
assert sum(degs) == d, "major consistency check failed in degrees"
return degs
def eigenvalue_fields(N, k, eps=None):
"""
Return Hecke eigenvalue fields of the newforms in the space with
given level, weight, and character.
Note that computing this field involves taking random linear
combinations of Hecke eigenvalues, so is not deterministic. Set
the random seed first (set_random_seed(0)) if you want this to be
deterministic.
INPUT:
- N -- level; positive integer
- k -- weight; integer at least 2
- eps -- None or Dirichlet character; if specified N is ignored
EXAMPLES::
sage: import psage
sage: psage.modform.rational.eigenvalue_fields(11,2)
[Rational Field]
sage: psage.modform.rational.eigenvalue_fields(43,2)
[Rational Field, Number Field in alpha with defining polynomial x^2 - 2]
sage: psage.modform.rational.eigenvalue_fields(DirichletGroup(13).0^2,2)
[Cyclotomic Field of order 6 and degree 2]
sage: psage.modform.rational.eigenvalue_fields(13,2,DirichletGroup(13).0^2)
[Cyclotomic Field of order 6 and degree 2]
"""
group = eps if eps else N
from sage.all import ModularSymbols
M = ModularSymbols(group=group, weight=k, sign=1).cuspidal_subspace()
N = M.new_subspace()
D = N.decomposition()
X = [f.compact_system_of_eigenvalues([2])[1].base_ring() for f in D]
return X
| Python |
#import maass
from maass import *
import rational
import hilbert
from siegel import SiegelModularForm, SiegelModularFormsAlgebra
import fourier_expansion_framework
| Python |
# -*- coding: utf-8 -*-
# cython: profile=True
r"""
A general class for subgroups of the (projective) modular group, PSL(2,Z).
Extends the standard classes with methods needed for Maass waveforms.
AUTHORS:
- Fredrik Strömberg
EXAMPLES::
sage: P=Permutations(6)
sage: pS=P([2,1,4,3,6,5])
sage: pR=P([3,1,2,5,6,4])
sage: G
Arithmetic Subgroup of PSL2(Z) with index 6.
Given by
perm(S)=[2, 1, 4, 3, 6, 5]
perm(ST)=[3, 1, 2, 5, 6, 4]
Constructed from G=Arithmetic subgroup corresponding to permutations L=(2,3,5,4), R=(1,3,6,4)
sage: TestSuite.run()
Commutator subgroup
sage: pR=MyPermutation('(1 3 5)(2 4 6)')
sage: pS=MyPermutation('(1 2)(3 4)(5 6)')
sage: G=MySubgroup(o2=pS,o3=pR)
Gamma^3
sage: pR=MyPermutation('(1 2 3)')
sage: pS=MyPermutation('(1)(2)(3)')
sage: G=MySubgroup(o2=pS,o3=pR)
"""
#*****************************************************************************
# Copyright (C) 2010 Fredrik Strömberg <stroemberg@mathematik.tu-darmstadt.de>,
#
# Distributed under the terms of the GNU General Public License (GPL)
#
# This code is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# General Public License for more details.
#
# The full text of the GPL is available at:
#
# http://www.gnu.org/licenses/
#*****************************************************************************
#from sage.all_cmdline import * # import sage library
from sage.rings.arith import xgcd
from sage.rings.all import Integer,CC,ZZ,QQ,RR,RealNumber,I,infinity,Rational,gcd
#from sage.combinat.permutation import (Permutations,PermutationOptions)
from sage.modular.cusps import Cusp
#from Cusp import is_gamma0_equiv
from sage.modular.arithgroup.all import *
from sage.symbolic.expression import Expression
from sage.modular.modsym.p1list import lift_to_sl2z
from sage.functions.other import ceil,floor,sqrt
from sage.all import matrix,SageObject,numerator,denominator,copy,log_b
from sage.modular.arithgroup import congroup_gamma0
from sage.modular.arithgroup.congroup_gamma0 import Gamma0_class
from sage.rings.integer import is_Integer
from sage.groups.all import SymmetricGroup
from sage.rings.arith import lcm
from copy import deepcopy
from psage.modform.maass.mysubgroups_alg import *
from psage.modform.maass.permutation_alg import MyPermutation
#from psage.modform.maass.permutation_alg import MyPermutation,MyPermutationIterator
from plot_dom import draw_funddom_d,draw_funddom
from psage.modform.maass.permutation_alg import are_transitive_permutations,num_fixed
## _sage_const_3 = Integer(3); _sage_const_2 = Integer(2);
## _sage_const_1 = Integer(1); _sage_const_0 = Integer(0);
## _sage_const_6 = Integer(6); _sage_const_4 = Integer(4);
## _sage_const_100 = Integer(100);
## _sage_const_1En12 = RealNumber('1E-12');
## _sage_const_201 = Integer(201); _sage_const_1p0 = RealNumber('1.0');
## _sage_const_1p5 = RealNumber('1.5'); _sage_const_0p0 = RealNumber('0.0');
## _sage_const_2p0 = RealNumber('2.0'); _sage_const_0p2 = RealNumber('0.2');
## _sage_const_0p5 = RealNumber('0.5'); _sage_const_1000 = Integer(1000);
## _sage_const_10000 = Integer(10000); _sage_const_1En10 = RealNumber('1E-10');
## _sage_const_20 = Integer(20); _sage_const_3p0 = RealNumber('3.0')
import warnings
import sys,os
import matplotlib.patches as patches
import matplotlib.path as path
from sage.modular.arithgroup.arithgroup_perm import *
#from subgroups_alg import *
#load "/home/stromberg/sage/subgroups/subgroups_alg.spyx"
class MySubgroup (ArithmeticSubgroup):
r"""
A class for subgroups of the modular group SL(2,Z).
Extends the standard classes with methods needed for Maass waveforms.
EXAMPLES::
sage: G=MySubgroup(Gamma0(5));G
Arithmetic Subgroup of PSL2(Z) with index 6.
Given by
perm(S)=[2, 1, 4, 3, 5, 6]
perm(ST)=[3, 1, 2, 5, 6, 4]
Constructed from G=Congruence Subgroup Gamma0(5)
sage: G.is_subgroup(G5)
True
sage: G.cusps()
[Infinity, 0]
G.cusp_normalizer(G.cusps()[1])
[ 0 -1]
[ 1 0]
"""
def __init__(self,G=None,o2=None,o3=None,str=None,verbose=0,version=0,data={}):
r""" Init a subgroup in the following forms:
1. G = Arithmetic subgroup
2. (o2,o3) = pair of transitive permutations of order 2 and
order 3 respectively.
INPUT:
- 'G' -- Subgroup of the modular group.
- 'o2' -- Permutation of order 2. The permutation implementation needs to have method: .cycle_tuples()
- 'o3' -- Permutation of order 3.
- 'str' -- String: either prepresenting permutations or a subgroup.
- 'verbose' -- integer, set verbosity with positive values.
INPUT TYPES:
ATTRIBUTES:
permS = permutation representating S
permT = permutation representating T
permR = permutation representating R=ST
permP = permutation representating P=STS
(permR,permT) gives the group as permutation group
Note:
The usual permutation group has two parabolic permutations L,R
L=permT, R=permP
EXAMPLES::
sage: G=SL2Z
sage: MG=MySubgroup(G);MG
Arithmetic Subgroup of PSL2(Z) with index 1.
Given by
perm(S)=[1]
perm(ST)=[1]
Constructed from G=Modular Group SL(2,Z)
sage: P=Permutatons(6)
sage: pS=[2,1,4,3,6,5]
sage: pR=[3,1,2,5,6,4]
sage: G=MySubgroup(o2=pS,o3=pR);G
Arithmetic Subgroup of PSL2(Z) with index 6.
Given by
perm(S)=[2, 1, 4, 3, 6, 5]
perm(ST)=[3, 1, 2, 5, 6, 4]
Constructed from G=Arithmetic subgroup corresponding to permutations L=(2,3,5,4), R=(1,3,6,4)
"""
self._verbose = verbose
self._version = version
if self._verbose>1:
print "g=",G
print "o2=",o2
print "o3=",o3
print "str=",str
self._level=None
self._generalised_level=None; self._is_congruence=None
self._perm_group=None; self._is_Gamma0=False
self._coset_rep_perms={}
self._coset_rep_strings={}
self._cusps_as_cusps=[]
if data<>{}:
self.init_group_from_dict(data)
else:
self._str = str
self.permT=None; self.permP=None
self._verbose=verbose
if str<>None:
try:
G=sage_eval(str)
except:
try:
[o2,o3]=self._get_perms_from_str(str)
except:
raise ValueError,"Incorrect string as input to constructor! Got s=%s" %(str)
if isinstance(G,(int,Integer)):
G = Gamma0(G).as_permutation_group()
self._is_Gamma0=True
if hasattr(G,"index"):
if not hasattr(G,"permutation_action"):
G = G.as_permutation_group()
self.init_group_from_subgroup(G)
elif o2<>None and o3<>None:
self.init_group_from_permutations(o2,o3)
else:
raise ValueError,"Incorrect input to subgroup! Got G={0}, o2={1} nad o3={2}".format(G,o2,o3)
self._uid = self._get_uid()
self.class_name='MySubgroup'
def init_group_from_permutations(self,o2,o3):
r"""
Initialize the group using the two permutations of order 2 and 3.
"""
if self._verbose>0:
print "in init_from_perm"
if isinstance(o2,MyPermutation):
self.permS=o2
else:
self.permS=MyPermutation(o2)
if isinstance(o3,MyPermutation):
self.permR=o3
else:
self.permR=MyPermutation(o3)
self.permT = self.permS*self.permR
self.permP = self.permT*self.permS*self.permT
self._G=ArithmeticSubgroup_Permutation(self.permT.list(),
self.permP.list())
self.get_data_from_group()
def init_group_from_subgroup(self,G):
r"""
Initalize self from a given subgroup.
"""
if self._verbose>0:
print "in init_from_subgroup"
if not hasattr(G,"permutation_action"):
raise ValueError,"Need a subgroup given by permutations."
self._G = G
L = self._G.L(); R = self._G.R()
self.permS = MyPermutation((L*~R*L).list())
self.permT = MyPermutation( L.list())
self.permR = self.permS * self.permT
self.permP = self.permR*self.permS
self.get_data_from_group()
def init_group_from_dict(self,dict):
r"""
Initalize self from a dictionary.
"""
if self._verbose>0:
print "in init_from_dict"
for key in dict.keys():
self.__dict__[key] = dict[key]
def get_data_from_group(self):
if self._verbose>0:
print "in Get_data_from_Group"
if not hasattr(self._G,"permutation_action"):
raise ValueError,"Need to set self._G before calling this routine!"
self._index=self._get_index(self._G,self.permS,self.permR)
self._generalised_level = self._G.generalised_level()
self._is_congruence = self._G.is_congruence()
if self._is_congruence:
self._level=self._G.generalised_level()
if self._G == Gamma0(self._level):
self._is_Gamma0=True
if self._version==2:
self._coset_reps=self._get_coset_reps_from_G_2(self._G)
elif self._version==1:
self._coset_reps=self._get_coset_reps_from_G(self._G)
else:
self._coset_reps=self._get_coset_reps_from_perms(self.permS,
self.permR)
self._coset_reps_list=copy(self._coset_reps)
self._test_consistency_perm(self.permS,self.permR)
self._nu2=num_fixed(self.permS.list())
self._nu3=num_fixed(self.permR.list())
self._ncusps=self._G.ncusps()
self._genus=1 +QQ(self._index - 6*self._ncusps-3*self._nu2-4 *self._nu3)/QQ(12)
self._signature=[self._index,self._ncusps,self._nu2,self._nu3,self._genus]
## Get information about cusps and vertices
l=self._get_all_cusp_data(self._coset_reps)
self._vertices,self._vertex_data,self._cusps,self._cusp_data=l
self._nvertices=len(self._vertices)
self._vertex_widths=list()
self._vertex_maps=list()
self._cusp_maps=list()
for i in range(len(self._vertices)):
wi = self._cusp_data[self._vertex_data[i]['cusp']]['width']
self._vertex_widths.append(wi)
N=self._cusp_data[self._vertex_data[i]['cusp']]['normalizer']
N = SL2Z_elt(N[0],N[1],N[2],N[3])
U = self._vertex_data[i]['cusp_map']
self._cusp_maps.append(U) #[U[0,0],U[0,1],U[1,0],U[1,1]])
N = N.inverse()*U
self._vertex_maps.append(N) #[N[0,0],N[0,1],N[1,0],N[1,1]])
# We might also want to see which cusps are simultaneously
# symmetrizable with respect to reflection in the imaginary axis
self._symmetrizable_cusp=dict()
for j in range(self._ncusps):
self._symmetrizable_cusp[j]=0
a,b,c,d=self._cusp_data[j]['normalizer']
if self._is_Gamma0:
if self._level.divides(2*d*c):
self._symmetrizable_cusp[j]=1
else:
if [a*d+b*c,-2*a*b,-2*d*c,a*d+b*c] in self:
self._symmetrizable_cusp[j]=1
## Then we chek if the cusps are symmetrizable in the sense that the normalizing maps
## are normalizers of the group.
## The entries of this dict are pairs: (o,d) where
## N^o is in self and has [1,1] element d.
self._cusp_normalizer_is_normalizer={0: (1,1) }# The first map is just the identity
for j in range(1,self._ncusps):
d=self.cusp_normalizer_is_normalizer(j,1)
def cusp_normalizer_is_normalizer(self,j,brute_force=0):
r"""
The dictionary self._cusp_normalizer_is_normalizer
consists of key-value pairs:
j => (o,d)
where o is the order of the cusp normalizer of cusp nr. j
and =0 if the normalizer is not a normalizer of the group (or identity)
and d is factor which the lower right entry in N*A*N^-1 differs from that of A by
I.e. chi(NAN^-1)=chi(d)chi(A)
(should mostly be 1 if everything works as hoped)
"""
if self._verbose>0:
print "Checking j:",j
print "have:",self._cusp_normalizer_is_normalizer
if self._cusp_normalizer_is_normalizer.has_key(j):
return self._cusp_normalizer_is_normalizer[j]
if not self._is_Gamma0:
self._cusp_normalizer_is_normalizer[j]=(0,0)
return self._cusp_normalizer_is_normalizer[j]
l = self._level
self._cusp_normalizer_is_normalizer[j]=(0,0)
N0=self._cusp_data[j]['normalizer']
if self._verbose>0:
print "N={0}".format(N0)
a,b,c,d=N0
w = self._cusp_data[j]['width']
if self._verbose>0:
print "w=",w
if j==1:
if a==0 and b*c==-1 and d==0:
self._cusp_normalizer_is_normalizer[j]=(2,1)
else:
warnings.warn("\nIt appears that the normalizer of 0 is not w_N! Have:{0}".format(a,b,c,d))
elif j>1 and j<self._ncusps:
## First see if we actually have an Atkin-Lehner involution directly:
## Multiply with the scaling matrix.
aa=a*w
cc=c*w
if cc==l and (l % aa)==0:
if self._verbose>0:
print "possible A-L invol: Q/N=",aa,"/",cc
if aa*d-b*cc==aa:
self._cusp_normalizer_is_normalizer[j]=(2,d)
return self._cusp_normalizer_is_normalizer[j]
# The other Atkin-Lehner involutions are more tricky...
if self._verbose>1:
print "cnc1=",self._cusp_normalizer_is_normalizer[j]
p,q=self._cusps[j]
if q.divides(l*p):
Q = (l*p).divide_knowing_divisible_by(q)
if self._verbose>0:
print "Q=",Q
## It is necessary that gcd(Q,N/Q)=1 for an A-L involution to exist
if Q.divides(l):
lQ=l.divide_knowing_divisible_by(Q)
if self._verbose>0:
print "N/Q=",lQ
#print "cnc1=",self._cusp_normalizer_is_normalizer[j]
if gcd(Q,lQ)==1:
if self._verbose>0:
print "gcd(Q,N/Q)=1 => possible Atkin-Lehner involution here."
fak=lcm(a,Q) ## We try to see if we can writ e the map as an A-L inv.
aa=fak*a; bb=fak*b; cc=fak*c; dd=fak*d
if Q.divides(aa) and Q.divides(dd) and l.divides(cc) and (aa*dd-bb*cc)==Q:
# We now have a normalizer so we have to find its order.
for k in range(2,l):
N=N*N0
if N in self:
self._cusp_normalizer_is_normalizer[j]=(k,N[1,1])
break #return self._cusp_normalizer_is_normalizer[j]
if k>=l-1 and self._cusp_normalizer_is_normalizer[j]==(0,0):
warnings.warn("It appears that the normalizer does not have finite order! N={0}".format(N0))
# We also have a brute force method:
# print "doing brute force!"
if self._verbose>1:
print "cnc2[",j,"]=",self._cusp_normalizer_is_normalizer[j]
if brute_force==1:
if self.is_normalizer(N0):
#NN=matrix(ZZ,2,2,N0)
# for A in self.gens():
# #print "A=",A,type(A)
# AA = SL2Z_elt(A[0,0],A[0,1],A[1,0],A[1,1])
# #.matrix().list()
# # matrix(ZZ,2,2,A.matrix().list())
# B = N0*AA #mul_list_maps(N,AA)
# B = B._mul(N0,2)
# #B = NN*AA*NN**-1
# c = gcd(list(B))
# #BB=B/c
# bc = ZZ(B[2]).divide_knowing_divisible_by(c)
# if self._is_Gamma0:
# t = bc % self._level == 0
# else:
# ba =[ZZ(B[0]).divide_knowing_divisible_by(c)]
# bb =[ZZ(B[1]).divide_knowing_divisible_by(c)]
# bd =[ZZ(B[3]).divide_knowing_divisible_by(c)]
# t = [ba,bb,bc,bd] in self
# if not t:
# self._cusp_normalizer_is_normalizer[j]=(0,0)
# return self._cusp_normalizer_is_normalizer[j]
# # Then find order
# N=N0
N = SL2Z_elt(N0[0],N0[1],N0[2],N0[3])
for k in range(2,l):
N=N._mul(N0) #mul_list_maps(N,N)
# print "N=",N,type(N)
if N in self:
self._cusp_normalizer_is_normalizer[j]=(k,N[3])
break
if k>=l-1 and self._cusp_normalizer_is_normalizer[j]==(0,0):
warnings.warn("It appears that the normalizer does not have finite order! j={0}, N={1}".format(j,N0))
return self._cusp_normalizer_is_normalizer[j]
def is_symmetrizable_even_odd(self,j):
r"""
Returns 1 if this cusp is symmetrizable in the sense that the normalizing map N=A*rho
satisfies: JNJ^-1=AN where A is a memeber of self.
Note: If self is a G amma_0(l) then A[1,1]==1 mod l
"""
return self._symmetrizable_cusp[j]
def normalizer_order(self,j):
r"""
If cusp number j has normalizer N
satisfies: JNJ^-1=AN where A is a memeber of self.
Note: If self is a G amma_0(l) then A[1,1]==1 mod l
"""
return self._symmetrizable_cusp[j]
def _repr_(self):
r"""
Return the string representation of self.
EXAMPLES::
sage: P=Permutatons(6)
sage: pS=[2,1,4,3,6,5]
sage: pR=[3,1,2,5,6,4]
sage: G=MySubgroup(o2=pS,o3=pR);G._repr_()
Arithmetic Subgroup of PSL2(Z) with index 6.
Given by
perm(S)=[2, 1, 4, 3, 6, 5]
perm(ST)=[3, 1, 2, 5, 6, 4]
Constructed from G=Arithmetic subgroup corresponding to permutations L=(2,3,5,4), R=(1,3,6,4)
sage: G=SL2Z
sage: MG=MySubgroup(G);MG._repr_()
Arithmetic Subgroup of PSL2(Z) with index 1.
Given by
perm(S)=[1]
perm(ST)=[1]
Constructed from G=Modular Group SL(2,Z)
"""
s ="Arithmetic Subgroup of PSL2(Z) with index "+str(self._index)+". "
s+="Given by: \n \t perm(S)="+str(self.permS)+"\n \t perm(ST)="+str(self.permR)
s+="\nConstructed from G="+self._G._repr_()
#self._name=s
#print "s=",s
return s
def _get_uid(self):
r""" Constructs a unique identifier for the group
OUTPUT::
A unique identifier as string.
The only truly unique identifier is the set of permutations
so we return those as strings.
Because of the extra stucture given by e.g. Gamma0(N) we also return
this information if available.
EXAMPLES::
sage: G=MySubgroup(Gamma0(5))
sage: G._get_uid()
[2_1_4_3_5_6]-[3_1_2_5_6_4]-Gamma0(5)'
sage: P=Permutations(6)
sage: pS=P([2,1,4,3,6,5])
sage: pR=P([3,1,2,5,6,4])
sage: G=MySubgroup(o2=pS,o3=pR)
sage: G._get_uid()
'[2_1_4_3_6_5]-[3_1_2_5_6_4]'
"""
# If we have a Congruence subgroup it is (more or less) easy
s=""
N=self.generalised_level()
domore=False
s=str(self.permS.list())+"-"
s=s+str(self.permR.list())
s=s.replace(", ","_")
if(self._is_congruence):
# test:
if(self._G == Gamma0(N) or self._G == Gamma0(N).as_permutation_group()):
s+="-Gamma0("+str(N)+")"
else:
if(self._G == Gamma(N)):
s+="-Gamma("+str(N)+")"
elif(Gamma(N).is_even()):
if(self._G == Gamma(N).as_permutation_group()):
s+="-Gamma("+str(N)+")"
if(self._G == Gamma1(N)):
s+="-Gamma1("+str(N)+")"
elif(Gamma1(N).is_even()):
if(self._G == Gamma1(N) or self._G == Gamma1(N).as_permutation_group()):
s+="-Gamma1("+str(N)+")"
return s
def signature(self):
r"""
Returns the signature of self: (index,h,nu2,nu3,g).
"""
return self._signature
def __reduce__(self):
r"""
Used for pickling self.
EXAMPLES::
sage: G=MySubgroup(Gamma0(5))
Not implmented!
"""
data = self.__dict__
return (MySubgroup, (self._G,self.permS,self.permR,self._str,self._verbose,self._version,data))
def __cmp__(self,other):
r""" Compare self to other.
EXAMPLES::
sage: G=MySubgroup(Gamma0(5))
sage: G <> Gamma0(5)
False
sage: GG=MySubgroup(None,G.permS,G.permR)
sage: GG == G
"""
if str(type(self._G)).find('MySubgroup')<0:
return -1
return self._G.__cmp__(other._G)
def __ne__(self,G):
return not self.__eq__(G)
def __eq__(self,G):
r"""
Test if G is equal to self.
EXAMPLES::
sage: G=MySubgroup(Gamma0(5))
sage: G==Gamma0(5)
False
sage: GG=MySubgroup(None,G.permS,G.permR)
sage: GG == G
True
"""
try:
pR=G.permR
pS=G.permS
if(pR==self.permR and pS==self.permS):
return True
except:
pass
return False
def _get_index(self,G=None,o2=None,o3=None):
r""" Index of self.
INPUT:
- ``G`` -- subgroup
- ``o2``-- permutation
- ``o3``-- permutation
OUTPUT:
- integer -- the index of G in SL2Z or the size of the permutation group.
EXAMPLES::
sage: G=MySubgroup(Gamma0(5))
sage: G._get_index(G._G,None,None)
6
sage: G._get_index(Gamma0(8))
12
sage: pS=P([2,1,4,3,6,5])
sage: pR=P([3,1,2,5,6,4])
sage: G._get_index(o2=pS,o3=pR)
6
"""
if hasattr(G,"index"):
try:
if G.is_subgroup(SL2Z):
ix=G.index()
except:
raise TypeError,"Wrong format for input G: Need subgroup of PSLZ! Got: \n %s" %(G)
else:
if o2==None:
raise TypeError,"Need to supply one of G,o2,o3 got: \n G=%s,\n o2=%s,\o3=%s"%(G,o2,o3)
if hasattr(o2,"to_cycles"):
ix=len(o2)
elif hasattr(o2,"list"): # We had an element of the SymmetricGroup
ix=len(o2.list())
else:
raise TypeError,"Wrong format of input: o2=%s, \n o2.parent=%s"%(o2,o2.parent())
return ix
def _get_vertices(self,reps):
r""" Compute vertices of a fundamental domain corresponding
to coset reps. given in the list reps.
INPUT:
- ''reps'' -- a set of matrices in SL2Z (coset representatives)
OUTPUT:
- [vertices,vertex_reps]
''vertices'' = list of vertices represented as cusps of self
''vertex_reps'' = list of matrices corresponding to the vertices
(essentially a reordering of the elements of reps)
EXAMPLES::
sage: G=MySubgroup(Gamma0(5))
sage: l=G._coset_reps
sage: G._get_vertices(l)
sage: G._get_vertices(l)
[[Infiniy, 0], {0: [ 0 -1]
[ 1 -2], Infinity: [1 0]
[0 1]}]
sage: P=Permutations(6)
sage: pS=P([2,1,4,3,6,5])
sage: pR=P([3,1,2,5,6,4])
sage: G=MySubgroup(o2=pS,o3=pR)
sage: G._get_vertices(G._coset_reps)
[[Infinity, 0, -1/2], {0: [ 0 -1]
[ 1 2], Infinity: [1 0]
[0 1], -1/2: [-1 0]
[ 2 -1]}]
"""
v=list()
vr=dict()
for A in reps:
if(A[1 ,0 ]<>0 and v.count(Cusp(A[0 ,0 ],A[1 ,0 ]))==0 ):
c=Cusp(A[0 ,0 ],A[1 ,0 ])
v.append(c)
elif(v.count(Cusp(infinity))==0 ):
c=Cusp(infinity)
v.append(c)
vr[c]=A
# Reorder so that Infinity and 0 are first
if(v.count(Cusp(0 ))>0 ):
v.remove(Cusp(0 )); v.remove(Cusp(infinity))
v.append(Cusp(0 )); v.append(Cusp(infinity))
else:
v.remove(Cusp(infinity))
v.append(Cusp(infinity))
v.reverse()
return [v,vr]
def _test_consistency_perm(self,o2,o3):
r""" Check the consistency of input permutations.
INPUT:
- ''o2'' Permutation of N1 letters
- ''o3'' Permutation of N2 letters
OUTPUT:
- True : If N1=N2=N, o2**2=o3**3=Identity, <o2,o3>=Permutations(N)
(i.e. the pair o2,o3 is transitive) where N=index of self
- Otherwise an Exception is raised
EXAMPLES::
sage: P=Permutations(6)
sage: pS=P([2,1,4,3,6,5])
sage: pR=P2([3,1,2,5,6,4])
sage: G=MySubgroup(o2=pS,o3=pR)
sage: G._test_consistency_perm(pS,pR)
True
"""
#SG1=MyPermutation(length=self._index) #self._S.identity()
#o22=o2*o2; o33=o3*o3*o3
if self._index==1:
return True
if o2.order() <>2 or o3.order()<>3:
print "o2=",o2,o2.order()
print "o3=",o3,o3.order()
s="Input permutations are not of order 2 and 3: \n perm(S)^2={0} \n perm(R)^3={1} "
raise ValueError, s.format(o2*o2,o3*o3*o3)
if(not are_transitive_permutations(o2,o3)):
S = SymmetricGroup(self._index)
S.subgroup([S(self.permS.list()),S(self.permR)])
#GS=self._S.subgroup([self.permS,self.permR])
s="Error in construction of permutation group! Permutations not transitive: <S,R>=%s"
raise ValueError, s % GS.list()
return True
def permutation_action(self,A,type=1):
r""" The permutation corresponding to the matrix A
INPUT:
- ''A'' Matrix in SL2Z
OUPUT:
element in self._S given by the presentation of the group self
- type: 0 gives PermutationGroup element and 1 gives MyPermutation
EXAMPLES::
P=Permutations(6)
sage: pS=P([2,1,4,3,6,5])
sage: pR=P([3,1,2,5,6,4])
sage: G=MySubgroup(o2=pS,o3=pR)
sage: G.permutation_action(S*T).cycle_tuples()
[(1, 3, 2), (4, 5, 6)]
sage: G.permutation_action(S).cycle_tuples()
[(1, 2), (3, 4), (5, 6)]
sage: pR.cycle_tuples()
[(1, 3, 2), (4, 5, 6)]
sage: pS.cycle_tuples()
[(1, 2), (3, 4), (5, 6)]
sage: G=MySubgroup(Gamma0(5))
sage: G.permutation_action(S).cycle_tuples()
[(1, 2), (3, 4), (5,), (6,)]
sage: G.permutation_action(S*T).cycle_tuples()
[(1, 3, 2), (4, 5, 6)]
"""
[sg,t0,cf]=factor_matrix_in_sl2z(A) #_in_S_and_T(A)
if self._verbose>1:
print "sg=",sg
print "t0=",t0
print "cf=",cf
print "S=",self.permS
print "T=",self.permT
print "index=",self._index
# The sign doesn't matter since we are working in practice only with the projective group PSL(2,Z)
# We now have A=T^a0*S*T^a1*...*S*T^an
# Hence
# h(A)=h(T^an)*h(S)*...*h(T^a1)*h(S)*h(T^a0)
#print "cf=",cf
n=len(cf)
if t0==0:
p=MyPermutation(length=self._index)
else:
p=self.permT**t0 #p=ppow(self.permT,cf[0 ])
# print "p(",0,")=",p.cycles()
#if self._verbose>1:
# print "p=",p
for j in range(n):
a=cf[j]
if a<>0:
Ta = self.permT**a
#if self._verbose>1:
# print "Ta=",Ta
p=p*self.permS*Ta
else:
p=p*self.permS
if type==0:
return SymmetricGroup(self._index)(p.list())
else:
return p
def _get_coset_reps_from_G(self,G,string=False,perm=False):
r"""
Compute a better/nicer list of right coset representatives [V_j]
i.e. SL2Z = \cup G V_j
Use this routine for known congruence subgroups.
EXAMPLES::
sage: G=MySubgroup(Gamma0(5))
sage: G._get_coset_reps_from_G(Gamma0(5))
[[1 0]
[0 1], [ 0 -1]
[ 1 0], [ 0 -1]
[ 1 1], [ 0 -1]
[ 1 -1], [ 0 -1]
[ 1 2], [ 0 -1]
[ 1 -2]]
"""
if self._is_Gamma0:
return self._get_coset_reps_from_Gamma0N()
cl=list()
S=[0,-1,1,0]
T=[1,1,0,1]
#S,T=SL2Z.gens()
lvl=12 #G.generalised_level()
# Start with identity rep.
cl.append([1 ,0 ,0 ,1 ])
if self._is_Gamma0 and self._level>1:
cl.append(S)
elif not S in G:
cl.append(S)
# If the original group is given as a Gamma0 then
# the reps are not the one we want
# I.e. we like to have a fundamental domain in
# -1/2 <=x <= 1/2 for Gamma0, Gamma1, Gamma
if self._is_Gamma0:
N=lvl #self._level #G.level()
if (N % 2) == 0:
#reprange=range(-N/2+1,N/2+1)
reprange=range(0,N)
else:
reprange=range(0,N)
#reprange=range(-(N-1)/2,(N-1)/2+1)
for j in reprange:
if j==0:
continue
cl.append([0 ,-1 ,1 ,j])
else:
#print "HERE!"
for j in range(1 , floor(0.5*lvl) + 2):
for ep in [1 ,-1]:
if(len(cl)>=self._index):
break
# The ones about 0 are all of this form
A=[0 ,-1 ,1 ,ep*j]
# just make sure they are inequivalent
try:
for V in cl:
t1=A<>V
#A*V^-1=[a,b]*[ v11 -v01]
# [c d] [-v10 v00]
if self._is_Gamma0:
t2= (c*v11-d*v10) % lvl == 0
else:
t2 = SL2Z_elt(a*v11-b*v10,-v01*a+v00*b,c*v11-d*v10,-c*v01+d*v00) in G
if t1 and t2:
#if((A<>V and A*V**-1 in G) or cl.count(A)>0 ):
raise StopIteration()
cl.append(A)
except StopIteration:
pass
# We now addd the rest of the "flips" of these reps.
# So that we end up with a connected domain
i=1
Ti = [1,-1,0,1]
while(True):
lold=len(cl)
for V in cl:
for A in [S,T,Ti]:
#B=V*A
B=mul_list_maps(V,A)
try:
for W in cl:
tmp = mul_list_maps(B,W,inv=2)
if self._is_Gamma0:
t1= (tmp[2] % lvl)==0
else:
#print "HERE!22"
t1= mul_list_maps(B,W,inv=2) in G
#if( (B*W**-1 in G) or cl.count(B)>0 ):
if t1:
raise StopIteration()
cl.append(B)
except StopIteration:
pass
if(len(cl)>=self._index or lold>=len(cl)):
# If we either did not addd anything or if we addded enough
# we exit
break
# If we missed something (which is unlikely)
if len(cl)<>self._index:
print "cl=",cl
raise ValueError,"Problem getting coset reps! Need %s and got %s" %(self._index,len(cl))
return cl
def _get_coset_reps_from_Gamma0N(self):
cl=list()
S=SL2Z_elt(0,-1,1,0)
T=SL2Z_elt(1,1,0,1)
if not self._level:
self._level=self._G.level()
lvl=self._level #12 #G.generalised_level()
cl.append(SL2Z_elt(1 ,0 ,0 ,1 ))
if self._index==1:
return cl
cl.append(S)
# If the original group is given as a Gamma0 then
# the reps are not the one we want
# I.e. we like to have a fundamental domain in
# -1/2 <=x <= 1/2 for Gamma0, Gamma1, Gamma
N=lvl
if (N % 2) == 0:
reprange=range(-N/2+1,N/2+1)
#reprange=range(N)
else:
reprange=range(-(N-1)/2,(N-1)/2+1)
decomp_seq=[[0,0],[0]]
for j in reprange:
if j==0:
continue
cl.append(SL2Z_elt(0 ,-1 ,1 ,j))
tmp=[0]
if j>0:
for i in range(j):
tmp.append(1)
else:
for i in range(-j):
tmp.append(-1)
decomp_seq.append(tmp)
# We now addd the rest of the "flips" of these reps.
# So that we end up with a connected domain
i=1
Ti = SL2Z_elt(1,-1,0,1)
gens=[S,T,Ti]
last = -1
while(True):
clold=cl
lold=len(clold)
for i in range(1,lold):
V=clold[i]
#for V in clold:
last=decomp_seq[i][-1]
if self._verbose>0:
print "V=",V
for j in range(2):
if last==0 and j==0:
continue
if last==1 and j==2:
continue
if last==2 and j==1:
continue
A=gens[j]
B=V*A
## We are getting new elements by multiplying the
## old with S,T or T^-1
if self._verbose>0:
print "V=",V
print "A=",A
print "B=",B
#B=mul_list_maps(V,A)
try:
for W in cl:
#tmp = mul_list_maps(B,W,inv=2)
tmp = B._mul(W,inv=2)
#print "tmp[2]=",tmp[2]
if tmp[2] % lvl==0:
raise StopIteration()
cl.append(B)
tmpl = decomp_seq[i]
tmpl.append(j)
decomp_seq.append(tmpl)
#last=j
except StopIteration:
pass
if len(cl)>=self._index or lold>=len(cl):
# If we either did not addd anything or if we addded enough
# we exit
break
# If we missed something (which is unlikely)
if self._verbose>0:
print "cosets=",cl
if len(cl)<>self._index:
print "cl=",cl
raise ValueError,"Problem getting coset reps! Need %s and got %s" %(self._index,len(cl))
# Try another coset rep for Gamma0(8)
#if lvl==8:
# A=SL2Z_elt(-1,0,-2,-1)
# j = cl.index(A)
# A=SL2Z_elt(-1,-1,2,1)
# cl[j]=A
return cl
def _get_coset_reps_from_G_2(self,G,string=False,perm=False):
r"""
Compute a better/nicer list of right coset representatives [V_j]
i.e. SL2Z = \cup G V_j
Use this routine for known congruence subgroups.
EXAMPLES::
sage: G=MySubgroup(Gamma0(5))
sage: G._get_coset_reps_from_G(Gamma0(5))
[[1 0]
[0 1], [ 0 -1]
[ 1 0], [ 0 -1]
[ 1 1], [ 0 -1]
[ 1 -1], [ 0 -1]
[ 1 2], [ 0 -1]
[ 1 -2]]
"""
cl=list()
lvl=G.generalised_level()
# Start with identity rep.
S = SL2Z_elt(0, -1 ,1 ,0 )
T = SL2Z_elt(1, 1 ,0 ,1 )
cl.append(SL2Z_elt(1 ,0 ,0 ,1 ))
if(not S in G):
cl.append(S)
# If the original group is given as a Gamma0 then
# the reps are not the one we want
# I.e. we like to have a fundamental domain in
# -1/2 <=x <= 1/2 for Gamma0, Gamma1, Gamma
for j in range(1 , floor(0.5*lvl) + 2):
for ep in [1 ,-1 ]:
if(len(cl)>=self._index):
break
# The ones about 0 are all of this form
A=SL2Z_elt(0 ,-1 ,1 ,ep*j)
# just make sure they are inequivalent
try:
for V in cl:
if((A<>V and A*V**-1 in G) or cl.count(A)>0 ):
raise StopIteration()
cl.append(A)
except StopIteration:
pass
# We now addd the rest of the "flips" of these reps.
# So that we end up with a connected domain
i=1
while(True):
lold=len(cl)
for V in cl:
for A in [S,T,T**-1 ]:
B=V*A
try:
for W in cl:
if( (B*W**-1 in G) or cl.count(B)>0 ):
raise StopIteration()
cl.append(B)
except StopIteration:
pass
if(len(cl)>=self._index or lold>=len(cl)):
# If we either did not addd anything or if we addded enough
# we exit
break
# If we missed something (which is unlikely)
if(len(cl)<>self._index):
print "cl=",cl
raise ValueError,"Problem getting coset reps! Need %s and got %s" %(self._index,len(cl))
return cl
def permutation_coset_rep(self,j):
r"""
Return the permutation corresponding to coset-representative nr. j
"""
if not self._coset_rep_perms.has_key(j):
perm = self.permutation_action(self._coset_reps[j])
self._coset_rep_perms[j]=perm
return self._coset_rep_perms[j]
def string_coset_rep(self,j):
r"""
Return the permutation corresponding to coset-representative nr. j
"""
if not self._coset_rep_strings.has_key(j):
s = self.element_as_string(self._coset_reps[j])
self._coset_rep_strings[j]=s
return self._coset_rep_strings[j]
def element_as_string(self,A):
r"""
Writes A as a string in generators S and T
"""
i=0
z,t0,cf=factor_matrix_in_sl2z(A)
if z==-1:
s='-'
else:
s=''
if t0<>0:
s=s+"T^%" %t0
for n in range(len(cf)):
s=s+"ST^{%}" % cf[n]
return s
def _get_coset_reps_from_perms(self,pS,pR):
r"""
Compute a better/nicer list of right coset representatives
i.e. SL2Z = \cup G V_j
INPUT:
- 'pS' -- permutation of order 2
- 'pR' -- permutation of order 3
OUTPUT:
- list of (right) coset-representatives of the group given by pS and pR
the rep V[j] has the property that self.permutation_action(V[j])=j
EXAMPLES::
sage: pS=P([1,3,2,5,4,7,6]); pS
(2,3)(4,5)(6,7)
sage: pR=P([3,2,4,1,6,7,5]); pR
(1,3,4)(5,6,7)
sage: G=MySubgroup(o2=pS,o3=pR)
sage: G._get_coset_reps_from_perms(G.permS,G.permR,G.permT)
[[1 0]
[0 1], [1 2]
[0 1], [1 1]
[0 1], [1 3]
[0 1], [1 5]
[0 1], [1 4]
[0 1], [ 4 -1]
[ 1 0]]
# Testing that the reps really are correct coset reps
sage: l=G._get_coset_reps_from_perms(G.permS,G.permR,G.permT)
sage: for V in l:
....: print G.permutation_action(V)
....:
()
(1,2,6)(3,4,5)
(1,3,2,4,6,5)
(1,4)(2,5)(3,6)
(1,5,6,4,2,3)
(1,6,2)(3,5,4)
(1,7,6,3,4,2)
"""
pT = pS*pR
ix=len(pR.list())
#S,T=SL2Z.gens()
T=SL2Z_elt(1 ,1 ,0 ,1 )
S=SL2Z_elt(0 ,-1 ,1 ,0 )
Id=SL2Z_elt(1 ,0 ,0 ,1 )
R=S*T
coset_reps=dict()
coset_reps[1]=Id
if self._verbose>0:
print "coset_reps=",coset_reps,len(coset_reps)
print "T=",T,pT.cycle_tuples()
print "S=",S,pS.cycle_tuples()
print "R=",R,pR.cycle_tuples()
#cycT=perm_cycles(pT) #.cycle_tuples()
cycT=pT.cycle_tuples()
#old_perm=pT[0]
next_cycle = cycT[0]
new_index = 0
got_cycles=[]
old_map = Id
for cyi in range(len(cycT)):
cy = next_cycle
r = len(cy)
i=pT(cy[new_index])
if self._verbose>0:
print "cy=",cy
print "new_index=",new_index
print "i=pT(cy[0])=",i
print "cy[new_index]=",cy[new_index]
# adding the rest of the cusp
if i<>cy[new_index]:
for j in range(r):
if self._verbose>0:
print "i=",i
print "j=",j
if j==new_index:
continue
k = (j - new_index)
if(k<=r/2):
#_add_unique(coset_reps,cy[j],old_map*T**k)
coset_reps[cy[j]]=old_map*T**k
else:
#_add_unique(coset_reps,cy[j],old_map*T**(k-r))
coset_reps[cy[j]]=old_map*T**(k-r)
if self._verbose>0:
print "k=",k
print "coset_reps[",cy[j],"]=",coset_reps[cy[j]]
got_cycles.append(cycT.index(cy))
# we have now added all translate inside the same cusp
# and we should see if we can connect to anther cusp
# if there is any left
if self._verbose>0:
print "cyi=",cyi
print "len(cycT)-1=",len(cycT)-1
if cyi>= len(cycT)-1:
if self._verbose>0:
print "break!"
break
# otherwise we use the order two element to connect the next cycle to one of the previous ones
# since (S,T) are transitive this must be the case.
old_map = Id
if self._verbose>0:
print "got_cycles=",got_cycles
try:
for cyii in range(len(cycT)):
if cyii in got_cycles:
## If we already treated this cycle
continue
next_cycle = cycT[cyii]
if self._verbose>0:
print "next_cycle=",next_cycle
for cyj in range(len(cycT)):
if self._verbose>0:
print "cyj=",cyj
if cyj not in got_cycles:
# We can only use cycles which are in the list
continue
cy=cycT[cyj]
if self._verbose>0:
print "check with cy=",cy
for i in cy:
j = pS(i)
if j in next_cycle:
# we have connected the cycles
old_map = coset_reps[i]*S # this is the connecting map and we may as well add it
#_add_unique(coset_reps,j,old_map)
coset_reps[j]=old_map
new_index = next_cycle.index(j)
if self._verbose>0:
print "connecting: S(",i,")=",j," in new cycle!"
print "ix=",new_index
print "old_map = ",old_map
print "next_cycle=",next_cycle
raise StopIteration()
except StopIteration:
pass
if old_map == Id:
raise ValueError,"Problem getting coset reps! Could not connect %s using %s" %(cycT,pS)
if self._verbose>0:
print "in this step:"
for j in coset_reps.keys():
if(coset_reps[j]<>Id):
print "V(",j,")=",coset_reps[j]
else:
print "V(",j,")=Id"
# By construction none of the coset-reps are in self and h(V_j)=j so they are all independent
# But to make sure we got all we count the keys
if coset_reps.keys() <> range(1,self._index+1):
print "ix=",ix
print "cl=",coset_reps
raise ValueError,"Problem getting coset reps! Need %s and got %s" %(self._index,len(coset_reps))
res = list()
for i in range(ix):
res.append(coset_reps[i+1])
return res
def are_equivalent_cusps(self,p,c,map=False):
r"""
Check whether two cusps are equivalent with respect to self
EXAMPLES::
sage: G=MySubgroup(Gamma0(5))
sage: G.are_equivalent_cusps(Cusp(1),Cusp(infinity))
False
sage: G.are_equivalent_cusps(Cusp(1),Cusp(0))
True
"""
if self._verbose>0:
print "test if eqiv:",p,c
if(p==c):
if map:
return True,SL2Z_elt(1,0,0,1)
return True
are_eq=False
try:
if(p.denominator()<>0 or c.denominator()<>0 ):
# The builtin equivalent cusp function is not working properly in all cases
# (and it is slow for the cusp at infinity)
if p.denominator()==0:
np=SL2Z_elt(1,0,0,1)
else:
w = lift_to_sl2z(p.denominator(), p.numerator(), 0 )
np = SL2Z_elt(w[3 ], w[1 ], w[2 ],w[0 ])
if c.denominator()==0:
nc=SL2Z_elt(1,0,0,1)
else:
w = lift_to_sl2z(c.denominator(), c.numerator(), 0 )
nc = SL2Z_elt(w[3 ], w[1 ], w[2 ],w[0 ])
if self._verbose>0:
print "np=",np
print "nc=",nc
# for i in range(len(self.permT.cycle_tuples()[0 ])):
m = self.generalised_level() #len(perm_cycles(self.permT)[0])
for i in range(m):
test=np.inverse()*SL2Z_elt(1 ,i,0 ,1 )*nc
if self._verbose>0:
print "test=",test
if test in self:
are_eq=True
raise StopIteration()
if i==0:
continue
test=np.inverse()*SL2Z_elt(1 ,-i,0 ,1 )*nc
if self._verbose>0:
print "test=",test
if test in self:
are_eq=True
raise StopIteration()
else:
raise ArithmeticError," the cusps should both be +oo. Got: %s and %s "(p,c)
except StopIteration:
pass
if self._verbose>0:
print "are_eq=",are_eq
print "map=",test
if map:
return are_eq,test
return are_eq
def _get_cusps(self,l):
r""" Compute a list of inequivalent cusps from the list of vertices
EXAMPLES::
sage: S=SymmetricGroup(6)
sage: pS=S([2,1,4,3,6,5])
sage: pR=S([3,1,2,5,6,4])
sage: G=MySubgroup(o2=pS,o3=pR)
sage: l=G._get_vertices(G._coset_reps)[0];l
[Infinity, 0, -1/2]
sage: G._get_cusps(l)
"""
lc=list()
for p in l:
are_eq=False
for c in lc:
if(self.are_equivalent_cusps(p,c)):
are_eq=True
continue
if(not are_eq):
lc.append(Cusp(p))
if(lc.count(Cusp(infinity))==1 and lc.count(0 )==1 ):
lc.remove(Cusp(infinity))
lc.remove(0 )
lc.append(Cusp(0 ))
lc.append(Cusp(infinity))
else:
lc.remove(Cusp(infinity))
lc.append(Cusp(infinity))
lc.reverse()
return lc
def is_normalizer(self,A,verbose=0):
if hasattr(A,"acton"):
A = matrix(ZZ,2,2,list(A))
for g in self.gens():
gg = g.matrix(1) # matrix(ZZ,2,2,list(g))
AA=A*gg*A**-1
#print AA[1,0]
if AA not in self:
if verbose>0:
print "A*{0}A^-1={1}".format(gg,AA)
if verbose>1:
return False,AA
else:
return False
return True
# def _get_cusp_data_old(self):
# r""" Return lists of cusp normalizers, stabilisers and widths
# OUTPUT:
# -- [ns,ss,ws] - list of dictionaries with cusps p as keys.
# ns : ns[p] = A in SL2Z with A(p)=infinity (cusp normalizer)
# ss : ss[p] = A in SL2Z s.t. A(p)=p (cusp stabilizer)
# ws : ws[p]= (w,s).
# w = width of p and s = 1 if p is regular and -1 if not
# EXAMPLES::
# sage: S=SymmetricGroup(6)
# sage: pS=S([2,1,4,3,6,5])
# sage: pR=S([3,1,2,5,6,4])
# sage: G=MySubgroup(o2=pS,o3=pR)
# sage: l=G._get_cusp_data()
# sage: l[0]
# {0: [ 0 -1]
# [ 1 0], Infinity: [1 1]
# [0 1], -1/2: [-1 0]
# [ 2 -1]}
# sage: l[1]
# {0: [ 1 0]
# [-4 1], Infinity: [1 1]
# [0 1], -1/2: [ 3 1]
# [-4 -1]}
# sage: l[2]
# {0: (4, 1), Infinity: (1, 1), -1/2: (1, 1)}
# """
# try:
# p=self._cusps[0 ]
# except:
# self._get_cusps(self._vertices)
# ns=list()
# ss=list()
# ws=list()
# if self._verbose>0:
# print "permT=",self.permT
# lws=perm_cycles(self.permT)
# if self._verbose>0:
# print "permT.cycles0=",lws
# cusp_widths=map(len,lws)
# cusp_widths.sort()
# # Recall that we have permutations for all groups here
# # and that the widths can be read from self.permT
# if self._verbose>0:
# print "cusps=",self._cusps
# print "widths=",cusp_widths
# for p in self._cusps:
# if self._verbose>0:
# print "p=",p
# # could use self._G.cusp_data but is more efficient to redo all
# if(p.denominator()==0):
# wi=len(lws[0 ])
# ns.append( SL2Z([1 , 0 , 0 ,1 ]))
# ss.append( SL2Z([1 , wi,0 ,1 ]))
# ws.append((wi,1 ) )
# cusp_widths.remove(wi)
# else:
# w = lift_to_sl2z(p.denominator(), p.numerator(), 0 )
# n = SL2Z([w[3 ], w[1 ], w[2 ],w[0 ]])
# stab=None
# wi=0
# if self._verbose >0:
# print "n=",n
# print "widths=",cusp_widths
# try:
# for d in cusp_widths:
# if self._verbose>0:
# print "d=",d
# if n * SL2Z([1 ,d,0 ,1 ]) * (~n) in self:
# stab = n * SL2Z([1 ,d,0 ,1 ]) * (~n)
# wi = (d,1 )
# cusp_widths.remove(d)
# raise StopIteration()
# elif n * SL2Z([-1 ,-d,0 ,-1 ]) * (~n) in self:
# stab = n * SL2Z([-1 ,-d,0 ,-1 ]) * (~n)
# wi=(d,-1 )
# cusp_widths.remove(d)
# raise StopIteration()
# except StopIteration:
# pass
# if(wi==0):
# raise ArithmeticError, "Can not find cusp stabilizer for cusp:" %p
# ss.append(stab)
# ns.append(n)
# ws.append(wi)
# return [ns,ss,ws]
def coset_reps(self):
r""" Returns coset reps of self
EXAMPLES::
sage: S=SymmetricGroup(6)
sage: pS=S([2,1,4,3,6,5])
sage: pR=S([3,1,2,5,6,4])
sage: pS
(1,2)(3,4)(5,6)
sage: pR
(1,3,2)(4,5,6)
sage: G=MySubgroup(o2=pS,o3=pR)
sage: G.coset_reps()
[[1 0]
[0 1], [1 2]
[0 1], [1 1]
[0 1], [1 3]
[0 1], [1 5]
[0 1], [1 4]
[0 1], [ 4 -1]
[ 1 0]]
"""
return self._coset_reps
def _get_perms_from_coset_reps(self):
r""" Get permutations of order 2 and 3 from the coset representatives
EXAMPLES::
sage: S=SymmetricGroup(6)
sage: pS=S([2,1,4,3,6,5])
sage: pR=S([3,1,2,5,6,4])
sage: G=MySubgroup(o2=pS,o3=pR)
sage: G._get_perms_from_coset_reps()
[(1,2)(3,4)(5,6), (1,3,2)(4,5,6)]
sage: G=MySubgroup(Gamma0(6))
sage: p=G._get_perms_from_coset_reps(); p[0]; p[1]
(1,2)(3,4)(5,8)(6,9)(7,10)(11,12)
(1,3,2)(4,5,9)(6,11,10)(7,12,8)
"""
l=self._coset_reps_list
li=list()
n=len(l)
G=self._G
ps=range(1 ,self._index+1 )
pr=range(1 ,self._index+1 )
S=SL2Z_elt(0,-1,1,0); T=SL2Z_elt(1,1,0,1)
R=SL2Z_elt(0,-1,1,1)
#S,T=SL2Z.gens()
#R=S*T
if self._is_Gamma0:
level=G.level()
if isinstance(l[0],SL2Z_elt):
for i in range(n):
li.append(l[i].inverse())
#li.append([l[i][3],-l[i][1],-l[i][2],l[i][0]])
#li.append( SL2Z(l[i])**-1 )
ixr=range(n)
else:
for i in range(n):
li.append( l[i].inverse() )
ixr=range(n)
ixs=range(n)
for i in range(n):
[a,b,c,d]=l[i]
VS=SL2Z_elt(b,-a,d,-c) # Vi*S
VR=SL2Z_elt(b,b-a,d,d-c) # Vi*R=Vi*S*T
for j in ixr:
Vji=li[j] # Vj^-1
tmp = VR*Vji
#tmp = mul_list_maps(VR,Vji)
if self._is_Gamma0:
t = tmp[2] % level == 0
else:
t = list(tmp) in G
if t:
pr[i]=j+1
ixr.remove(j)
break
for j in ixs:
Vji=li[j]
tmp = VS*Vji
#tmp = mul_list_maps(VS,Vji)
if self._is_Gamma0:
t = tmp[2] % level == 0
else:
t = list(tmp) in G
if t: #(VS*Vji in G):
ps[i]=j+1
ixs.remove(j)
break
#print "ps=",ps
#print "pr=",pr
#print "PS=",MyPermutation(ps)
#print "PR=",MyPermutation(pr)
#return [self._S(ps),self._S(pr)]
return MyPermutation(ps),MyPermutation(pr)
# def _get_perms_from_coset_reps_old(self):
# r""" Get permutations of order 2 and 3 from the coset representatives
# EXAMPLES::
# sage: S=SymmetricGroup(6)
# sage: pS=S([2,1,4,3,6,5])
# sage: pR=S([3,1,2,5,6,4])
# sage: G=MySubgroup(o2=pS,o3=pR)
# sage: G._get_perms_from_coset_reps()
# [(1,2)(3,4)(5,6), (1,3,2)(4,5,6)]
# sage: G=MySubgroup(Gamma0(6))
# sage: p=G._get_perms_from_coset_reps(); p[0]; p[1]
# (1,2)(3,4)(5,8)(6,9)(7,10)(11,12)
# (1,3,2)(4,5,9)(6,11,10)(7,12,8)
# """
# l=self._coset_reps
# li=list()
# n=len(l)
# G=self._G
# ps=range(1 ,self._index+1 )
# pr=range(1 ,self._index+1 )
# S,T=SL2Z.gens()
# R=S*T
# if isinstance(l[0],list):
# for i in range(n):
# li.append( SL2Z(l[i])**-1 )
# ixr=range(n)
# else:
# for i in range(n):
# li.append(l[i]**-1 )
# ixr=range(n)
# ixs=range(n)
# for i in range(n):
# [a,b,c,d]=l[i]
# VS=SL2Z([b,-a,d,-c]) # Vi*S
# VR=SL2Z([b,b-a,d,d-c]) # Vi*R=Vi*S*T
# for j in ixr:
# Vji=li[j] # Vj^-1
# if(VR*Vji in G):
# pr[i]=j+1
# ixr.remove(j)
# break
# for j in ixs:
# Vji=li[j]
# if(VS*Vji in G):
# ps[i]=j+1
# ixs.remove(j)
# break
# return [self._S(ps),self._S(pr)]
# Now to public routines
def coset_rep(self,A):
r"""
Indata: A in PSL(2,Z)
Returns the coset representative of A in
PSL(2,Z)/self.G
EXAMPLES::
sage: G=MySubgroup(Gamma0(4))
sage: A=SL2Z([9,4,-16,-7])
sage: G.coset_rep(A)
[1 0]
[0 1]
sage: A=SL2Z([3,11,-26,-95])
sage: G.coset_rep(A)
[-1 0]
[ 2 -1]
sage: A=SL2Z([71,73,35,36])
sage: G.coset_rep(A)
[ 0 -1]
[ 1 0]
"""
if isinstance(A,SL2Z_elt):
for V in (self._coset_reps_list):
if( (A*V.inverse() ) in self):
return V
else:
for V in (self._coset_reps):
if( (A*V**-1 ) in self):
return V
raise ArithmeticError,"Did not find coset rep. for A=%s" %(A)
def pullback(self,x_in,y_in,ret_mat=1,prec=201):
r""" Find the pullback of a point in H to the fundamental domain of self
INPUT:
- ''x_in,y_in'' -- x_in+I*y_in is in the upper half-plane
- ''prec'' -- (default 201) precision in bits
- ret_mat -- set to 0 if you want to return a list instead of a matrix.
OUTPUT:
- [xpb,ypb,B] -- xpb+I*ypb=B(x_in+I*y_in) with B in self
xpb and ypb are complex numbers with precision prec
EXAMPLES::
sage: S=SymmetricGroup(6)
sage: pS=S([2,1,4,3,6,5])
sage: pR=S([3,1,2,5,6,4])
sage: G=MySubgroup(o2=pS,o3=pR)
sage: [x,y,B]=G.pullback(0.2,0.5,53); x,y;B
(-0.237623762376238, 0.123762376237624)
[-1 0]
[ 4 -1]
sage: (B**-1).acton(x+I*y)
0.200000000000000 + 0.500000000000000*I
"""
#x=deepcopy(x_in); y=deepcopy(y_in)
if self._is_Gamma0:
if isinstance(x_in,float):
xpb,ypb,a,b,c,d=pullback_to_Gamma0N_dp(self,x_in,y_in,self._verbose)
elif isinstance(x_in,Expression):
prec=round(RR(len(str(x_in).split(".")[1])/log_b(2,10)))
RF=RealField(prec)
x=RF(x_in); y=RF(y_in)
if prec<=53:
xpb,ypb,a,b,c,d=pullback_to_Gamma0N_dp(self,x,y,self._verbose)
else:
xpb,ypb,a,b,c,d=pullback_to_Gamma0N_mpfr(self,x,y)
else:
xpb,ypb,a,b,c,d=pullback_to_Gamma0N_mpfr(self,x_in,y_in)
if ret_mat==1:
return xpb,ypb,SL2Z_elt(a,b,c,d)
else:
return xpb,ypb,int(a),int(b),int(c),int(d)
else:
A=pullback_to_psl2z_mat(RR(x_in),RR(y_in))
A=SL2Z_elt(A) #.matrix()
try:
for V in self._coset_reps:
B=V*A
if B in self:
raise StopIteration
except StopIteration:
pass
else:
raise ArithmeticError,"Did not find coset rep. for A=%s" % A
#if ret_int==1:
# a,b,c,d=B[0,0],B[0,1],B[1,0],B[1,1]
if isinstance(x_in,float):
xpb,ypb=apply_sl2z_map_dp(x_in,y_in,B[0,0],B[0,1],B[1,0],B[1,1])
else:
xpb,ypb=apply_sl2z_map_mpfr(x_in,y_in,B[0,0],B[0,1],B[1,0],B[1,1])
if ret_mat==1:
return xpb,ypb,B.matrix()
else:
return xpb,ypb,B[0,0],B[0,1],B[1,0],B[1,1]
def is_congruence(self):
r""" Is self a congruence subgroup or not?
EXAMPLES::
sage: S=SymmetricGroup(6)
sage: pS=S([2,1,4,3,6,5])
sage: pR=S([3,1,2,5,6,4])
sage: G=MySubgroup(o2=pS,o3=pR)
sage: G.is_congruence()
True
sage: S=SymmetricGroup(7)
sage: pS=S([1,3,2,5,4,7,6]); pS
(2,3)(4,5)(6,7)
sage: pR=S([3,2,4,1,6,7,5]); pR
(1,3,4)(5,6,7)
sage: G=MySubgroup(o2=pS,o3=pR)
sage: G.is_congruence()
False
"""
try:
return self._is_congruence
except:
self._is_congruence=self._G.is_congruence()
return self._is_congruence
def is_Gamma0(self):
return self._is_Gamma0
def generalised_level(self):
r""" Generalized level of self
EXAMPLES::y
sage: S=SymmetricGroup(6)
sage: pS=S([2,1,4,3,6,5])
sage: pR=S([3,1,2,5,6,4])
sage: G=MySubgroup(o2=pS,o3=pR)
sage: G.generalised_level()
4
sage: S=SymmetricGroup(7)
sage: pS=S([1,3,2,5,4,7,6]); pS
(2,3)(4,5)(6,7)
sage: pR=S([3,2,4,1,6,7,5]); pR
(1,3,4)(5,6,7)
sage: G=MySubgroup(o2=pS,o3=pR)
sage: G.generalised_level()
6
"""
if self._generalised_level==None:
# compute the generalized level
self._generalised_level= lcm(map(len,self.permT.cycle_tuples()))
return self._generalised_level
#raise ArithmeticError, "Could not compute generalised level of %s" %(self)
def level(self):
r""" Level of self
EXAMPLES::
sage: G=MySubgroup(Gamma0(5));
sage: G.level()
5
"""
if(self._is_congruence):
return self.generalised_level()
else:
raise TypeError,"Group is not a congruence group! Use G.generalised_level() instead!"
def genus(self):
r""" Genus of self
EXAMPLES::
sage: G=MySubgroup(Gamma0(5));
sage: G.genus()
5
"""
return self._genus
def nu2(self):
r""" Number of elliptic fixed points of order 2 of self.
EXAMPLES::
sage: G=MySubgroup(Gamma0(5));
sage: G.genus()
5
"""
return self._nu2
def nu3(self):
r""" Number of elliptic fixed points of order 3 of self.
EXAMPLES::
sage: G=MySubgroup(Gamma0(5));
sage: G.genus()
5
"""
return self._nu3
def gens(self):
r""" Generators of self
EXAMPLES::
sage: G=MySubgroup(Gamma0(5));
sage: G.gens()
([1 1]
[0 1], [-1 0]
[ 0 -1], [ 1 -1]
[ 0 1], [1 0]
[5 1], [1 1]
[0 1], [-2 -1]
[ 5 2], [-3 -1]
[10 3], [-1 0]
[ 5 -1], [ 1 0]
[-5 1])
sage: G3=MySubgroup(o2=Permutations(3)([1,2,3]),o3=Permutations(3)([2,3,1]))
sage: G3.gens()
([1 3]
[0 1], [ 0 -1]
[ 1 0], [ 1 -2]
[ 1 -1], [ 2 -5]
[ 1 -2])
"""
# do some reductions from the generators
if self._gens:
return self._gens
gens = self._G.gens()
newgens=[]
for i in range(len(gens)):
l = list(gens[i])
newgens.append(SL2Z_elt(l[0],l[1],l[2],l[3]))
if self._verbose>1:
print "original gens=",newgens
m1=SL2Z_elt(-1,0,0,-1)
for x in gens:
l = list(gens[i])
x = SL2Z_elt(l[0],l[1],l[2],l[3])
if x not in newgens:
continue
if self._verbose>1:
print "x:",x
t=m1*x
if t<>x and t in newgens:
if self._verbose>1:
print "remove -x:",m1*x
newgens.remove(t)
t=x.inverse() #**-1
if t<>x and t in newgens:
if self._verbose>1:
print "remove x**-1:",t
newgens.remove(t) #**-1)
t=t*m1
if t<>x and t in newgens:
if self._verbose>1:
print "remove -x**-1:",t #m1*x**-1
newgens.remove(t)
# also remove duplicate
gens=newgens
for x in gens:
if gens.count(x)>1:
newgens.remove(x)
if self._verbose>1:
print "type(gens[0])=",type(newgens[0])
print "newgens=",newgens
self._gens=newgens
return newgens
def closest_vertex(self,x,y,as_integers=1):
r"""
The closest vertex to the point z=x+iy in the following sense:
Let sigma_j be the normalized cusp normalizer of the vertex p_j,
i.e. sigma_j^-1(p_j)=Infinity and sigma_j*S_j*sigma_j^-1=T, where
S_j is the generator of the stabiliser of p_j
The closest vertex is then the one for which Im(sigma_j^-1(p_j))
is maximal.
INPUT:
- ''x,y'' -- x+iy in the upper half-plane
OUTPUT:
- ''v'' -- the closest vertex to x+iy
EXAMPLES::
sage: G=MySubgroup(Gamma0(5))
sage: G.closest_vertex(-0.4,0.2)
Infinity
sage: G.closest_vertex(-0.1,0.1)
0
"""
ci=closest_vertex(self._vertex_maps,self._vertex_widths,self._nvertices,x,y,self._verbose)
if as_integers:
return ci
else:
return self._vertices[ci]
def closest_cusp(self,x,y,vertex=0,as_integers=1):
r"""
The closest cusp to the point z=x+iy in the following sense:
Let sigma_j be the normalized cusp normalizer of the vertex p_j,
i.e. sigma_j^-1(p_j)=Infinity and sigma_j*S_j*sigma_j^-1=T, where
S_j is the generator of the stabiliser of p_j
The closest vertex is then the one for which Im(sigma_j^-1(p_j))
is maximal and the closest cusp is the cusp associated to this vertex
INPUT:
- ''x,y'' -- x+iy in the upper half-plane
OUTPUT:
- ''v'' -- the closest vertex to x+iy
EXAMPLES::
sage: G=MySubgroup(Gamma0(5))
sage: G.closest_vertex(-0.4,0.2)
Infinity
sage: G.closest_vertex(-0.1,0.1)
0
"""
vi = closest_vertex(self._vertex_maps,self._vertex_widths,self._nvertices,x,y,self._verbose)
ci = self._vertex_data[vi]['cusp']
if vertex==1:
if as_integers:
return ci,vi
else:
return self._cusps[ci],self._vertices[vi]
else:
if as_integers:
return ci
else:
return self._cusps[ci]
## def block_systems(self):
## r"""
## Return a list of possible Block systems and overgroups for the group G.
## INDATA: G = subgroup of the modular group
## OUTDATA res['blocksystems']= Block systems
## res['overgroups'] = Overgroups corresponding to the blocks
## in the block systems
## EXAMPLES::
## """
## return get_block_systems(self.permS,self.permR,False)
def dimension_cuspforms(self,k):
r"""
The implementation of this in the standard arithmetic subgroup package
returns a false answer. Therefore it is better to overwrite it...
"""
return self.dimension_cuspforms(k)
def dimension_cuspforms(self,k):
r"""
Returns the dimension of the space of cuspforms on G of weight k
where k is an even integer
EXAMPLES::
sage: G=MySubgroup(Gamma0(4))
sage: G.dimension_cuspforms(12)
4
sage: S=SymmetricGroup(7)
sage: pR=S([3,2,4,1,6,7,5]); pR
(1,3,4)(5,6,7)
sage: pS=S([1,3,2,5,4,7,6]); pS
(2,3)(4,5)(6,7)
sage: G.dimension_cuspforms(4)
1
"""
#kk=ZZ(k)
ki = ZZ(k)
if is_odd(ki):
raise ValueError, "Use only for even weight k! not k=" %(kk)
if ki<2:
dim=0
elif ki==2:
dim=self._genus
elif ki>=4:
kk = RR(k)
dim=ZZ(kk-1)*(self._genus-1)+self._nu2*floor(kk/4.0)+self._nu3*floor(kk/3.0)
dim+= ZZ(kk/2.0 - 1)*self._ncusps
return dim
def dimension_modularforms(self,k):
r"""
Returns the dimension of the space of modular forms on G of weight k
where k is an even integer
EXAMPLES::
sage: S=SymmetricGroup(7)
sage: pR=S([3,2,4,1,6,7,5]); pR
(1,3,4)(5,6,7)
sage: pS=S([1,3,2,5,4,7,6]); pS
(2,3)(4,5)(6,7)
sage: G.dimension_modularforms(4)
3
"""
kk=Integer(k)
if is_odd(kk):
raise ValueError, "Use only for even weight k! not k=" %(kk)
if k==0 :
dim=1 # the constant functionz
elif k<2:
dim=0
else:
dim=self.dimension_cuspforms(k)+self._ncusps
#(kk-1.0)*(self._genus-_sage_const_1 )+self._nu2()*int(floor(kk/_sage_const_4 ))+self._nu3*int(floor(kk/_sage_const_3 ))+kk/_sage_const_2 *self._ncusps()
return dim
### Overloaded operators
def __contains__(self,A):
r"""
Is A an element of self (this is an ineffective implementation if self._G is a permutation group)
EXAMPLES::
sage: G=MySubgroup(Gamma0(5))
sage: A=SL2Z([-69,-25,-80,-29])
sage: G.__contains__(A)
True
sage: A in G
True
sage: S=SymmetricGroup(7)
sage: pR=S([3,2,4,1,6,7,5]); pR
(1,3,4)(5,6,7)
sage: pS=S([1,3,2,5,4,7,6]); pS
(2,3)(4,5)(6,7)
sage: S,T=SL2Z.gens(); R=S*T
sage: A=S*T^4*S
sage: A in G
False
sage: A=S*T^6*S
sage: A in G
True
"""
if hasattr(A,"det"):
if A.det()<>1:
if self._verbose>3:
print "det(A)=",A.det()
return False
if not is_integer(A[0,0]):
if self._verbose>3:
print "A[0,0]=",A[0,0],type(A[0,0])
return False
if not is_integer(A[0,1]):
if self._verbose>3:
print "A[0,1]=",A[0,1],type(A[0,1])
return False
if not is_integer(A[1,0]):
if self._verbose>3:
print "A[1,0]=",A[1,0],type(A[1,0])
return False
if not is_integer(A[1,1]):
if self._verbose>3:
print "A[1,1]=",A[1,1],type(A[1,1])
return False
elif isinstance(A,list):
if len(A)>4:
return False
if A[0]*A[3]-A[1]*A[2]<>1:
return False
# # See if A has integer entries
if not is_integer(A[0]):
return False
if not is_integer(A[1]):
return False
if not is_integer(A[2]):
return False
if not is_integer(A[3]):
return False
p=self.permutation_action(A)
if self._verbose>1:
print "perm(A)=",p
if(p(1)==1 ):
return True
else:
return False
def cusps(self):
r"""
Returns the cusps of self as cusps
EXAMPLES::
sage: G=MySubgroup(Gamma0(5))
sage: G.cusps()
[Infinity, 0]
"""
if len(self._cusps_as_cusps)==0:
for c in self._cusps:
if c[1]<>0:
self._cusps_as_cusps.append(Cusp(QQ(c[0])/QQ(c[1])))
else:
self._cusps_as_cusps.append(Cusp(Infinity))
return self._cusps_as_cusps
def vertices(self):
r"""
Return the certices of the (current) fundamental domain of self.
"""
if len(self._vertices_as_cusps)==0:
for c in self._vertices:
if c[1]<>0:
self._vertices_as_cusps.append(Cusp(QQ(c[0])/QQ(c[1])))
else:
self._vertices_as_cusps.append(Cusp(Infinity))
return self._vertices_as_cusps
def nvertices(self):
return self._vertices
def cusp_width(self,cusp):
r"""
Returns the cusp width of cusp
EXAMPLES::
sage: G=MySubgroup(Gamma0(4))
sage: G.cusp_data(Cusp(1/2))
([-1 1]
[-4 3], 1, 1)
sage: G.cusp_width(Cusp(-1/2))
1
sage: G.cusp_width(Cusp(1/2))
1
sage: G.cusp_width(Cusp(0))
4
"""
p=None; q=None
if isinstance(cusp,Cusp):
p=cusp.numerator(); q=cusp.denominator()
elif isinstance(cusp,tuple):
p=cusp[0];q=cusp[1]
if (p,q) in self._cusps:
j = self._cusps.index((p,q))
return self._cusp_data[j]['width']
else:
print "cusp=",cusp
# if we are here we did not find the cusp in the list so we have to find an equivalent in the list
p,q=self.cusp_equivalent_to(cusp)
return self._cusp_data[(p,q)]['width']
raise ArithmeticError,"Could not find the width of %s" %cusp
def cusp_data(self,c):
r""":
Returns cuspdata in the same format as for the generic Arithmetic subgrou
EXAMPLES::
sage: G=MySubgroup(Gamma0(4))
sage: G.cusp_data(Cusp(1/2))
([-1 1]
[-4 3], 1, 1)
sage: G.cusp_data(Cusp(-1/2))
([ 3 1]
[-4 -1], 1, 1)
sage: G.cusp_data(Cusp(0))
([ 0 -1]
[ 1 0], 4, 1)
"""
(p,q),A=self.cusp_equivalent_to(c)
if (p,q) not in self._cusps:
return 0,0,0
i =self._cusps.index((p,q))
width = self._cusp_data[i]['width']
if A == [1,0,0,1]:
n = self._cusp_data[i]['normalizer']
else:
w = lift_to_sl2z(q, p, 0 )
n = SL2Z([w[3 ], w[1 ], w[2 ],w[0 ]])
return (n,width,1)
## try:
## # if we give a cusp already in the list we return stored values
## w=self.cusp_normalizer(c)
## d=self._cusp_width[c][0 ]
## e=self._cusp_width[c][1 ]
## g=w * SL2Z([e,d*e,0 ,e]) * (~w)
## return (self.cusp_normalizer(c),d*e,1)
## except:
## w = lift_to_sl2z(c.denominator(), c.numerator(), 0 )
## g = SL2Z([w[3 ], w[1 ], w[2 ],w[0 ]])
## for d in xrange(1 ,1 +self.index()):
## if g * SL2Z([1 ,d,0 ,1 ]) * (~g) in self:
## return (g * SL2Z([1 ,d,0 ,1 ]) * (~g), d, 1 )
## elif g * SL2Z([-1 ,-d,0 ,-1 ]) * (~g) in self:
## return (g * SL2Z([-1 ,-d,0 ,-1 ]) * (~g), d, -1 )
## raise ArithmeticError, "Can' t get here!"
## #
def cusp_equivalent_to(self,cusp):
r"""
Find a cusp in self._cusps which is equivalent to cusp
and returns the cusp, a map which maps the given point to the cusp
"""
p=None;q=None
if isinstance(cusp,tuple):
p=cusp[0];q=cusp[1]
else:
try:
cusp=Cusp(cusp)
p=cusp.numerator(); q=cusp.denominator()
except:
raise TypeError,"Could not coerce {0} to a cusp!".format(cusp)
if (p,q) in self._cusps:
one = SL2Z_elt(int(1),int(0),int(0),int(1))
return (p,q),one,one
print "p,q=",p,q,type(p),type(q)
w = lift_to_sl2z(q, p, 0 )
V = SL2Z_elt(w[3 ], w[1 ], w[2 ],w[0 ])
permv=self.permutation_action(V)
for i in range(self._ncusps):
W = self._cusp_data[i]['normalizer']
permw=self.permutation_action(W)
testi=(permw**-1)(1)
for k in range(0,self._index):
test=(permv*self.permT**k)(testi)
if test==1: ## v = C w with C = V*T**k*W**-1
Tk = SL2Z_elt(1,k,0,1)
mapping=V*Tk*W.inverse()
return w,mapping,W
raise ArithmeticError, "Could not find equivalent cusp!"
def cusp_normalizer(self,cusp):
r"""
Return the cusnormalizer of cusp
EXAMPLES::
sage: S=SymmetricGroup(6)
sage: pS=S([2,1,4,3,6,5])
sage: pR=S([3,1,2,5,6,4])
sage: G=MySubgroup(o2=pS,o3=pR)
sage: G.cusps()
[Infinity, 0, -1/2]
sage: G.cusp_normalizer(Cusp(0))
[ 0 -1]
[ 1 0]
sage: G.cusp_normalizer(Cusp(-1/2))
[-1 0]
[ 2 -1]
sage: G.cusp_normalizer(Cusp(Infinity))
[1 0]
[0 1]
"""
if isinstance(cusp,Cusp):
p=cusp.numerator(); q=cusp.denominator()
elif isinstance(cusp,tuple):
p=cusp[0];q=cusp[1]
if (p,q) in self._cusps:
return self._cusp_data[(p,q)]['normalizer']
else:
(p,q),A=self.cusp_equivalent_to(cusp)
if A==1:
return self._cusp_data[(p,q)]['normalizer']
else:
w = lift_to_sl2z(q, p, 0 )
g = SL2Z_elt(w[3 ], w[1 ], w[2 ],w[0 ])
return g
def normalize_to_cusp(self,x,y,c,inv=0):
r"""
Apply the cusp normalizing map of cusp c to x+iy
"""
xx=x.parent()(x); yy=y.parent()(y)
[d,b,c,a]=self.cusp_normalizer(c)
wi = G.cusp_widt(c)
if inv==1:
b=-b; c=-c; atmp=a;
a=d; d=a
if wi<>1:
wmul=self.cusp_widt(c)**-1
elif wi<>1:
wmul=x.parent()(self.cusp_widt(c))
xx=wmul*xx; yy=wmul*yy
xx,yy=apply_sl2z_map(xx,yy)
if wi<>1 and inv==1:
xx=xx/wmul; yy=yy/wmul
return xx,yy
def minimal_height(self):
r""" Computes the minimal (invariant) height of the fundamental region of self.
Note: Only guaranteed for Gamma_0(N)
EXAMPLES::
sage: G=MySubgroup(Gamma0(6))
sage: G.minimal_height()
0.144337567297406
sage: S=SymmetricGroup(6)
sage: pS=S([2,1,4,3,6,5])
sage: pR=S([3,1,2,5,6,4])
sage: G=MySubgroup(o2=pS,o3=pR)
sage: G.minimal_height()
0.216506350946110
"""
if self._is_congruence:
l=self.level()
if(self._G == Gamma0(l)):
return RR(sqrt(3.0))/RR(2*l)
# For all other groups we have have to locate the largest width
maxw=0
for i in range(self._ncusps):
l=self._cusp_data[i]['width']
if l>maxw:
maxw=l
return RR(sqrt(3.0))/RR(2*maxw)
def draw_fundamental_domain(self,model="H",axes=None,filename=None,**kwds):
r""" Draw fundamental domain
INPUT:
- ''model'' -- (default ''H'')
= ''H'' -- Upper halfplane
= ''D'' -- Disk model
- ''filename''-- filename to print to
- ''**kwds''-- additional arguments to matplotlib
- ''axes'' -- set geometry of output
=[x0,x1,y0,y1] -- restrict figure to [x0,x1]x[y0,y1]
EXAMPLES::
sage: G=MySubgroup(Gamma0(3))
sage: G.draw_fundamental_domain()
"""
from matplotlib.backends.backend_agg import FigureCanvasAgg
if(model=="D"):
g=draw_funddom_d(self._coset_reps,format,I)
else:
g=draw_funddom(self._coset_reps,format)
if(axes<>None):
[x0,x1,y0,y1]=axes
elif(model=="D"):
x0=-1 ; x1=1 ; y0=-1 ; y1=1
else:
# find the width of the fundamental domain
w=0 #self.cusp_width(Cusp(Infinity))
wmin=0 ; wmax=1
for V in self._coset_reps:
if V[2]==0 and V[0]==1:
if V[1]>wmax:
wmax=V[1]
if V[1]<wmin:
wmin=V[1]
#print "wmin,wmax=",wmin,wmax
#x0=-1; x1=1; y0=-0.2; y1=1.5
x0=wmin-1 ; x1=wmax+1 ; y0=-0.2 ; y1=1.5
g.set_aspect_ratio(1 )
g.set_axes_range(x0,x1,y0,y1)
if(filename<>None):
fig = g.matplotlib()
fig.set_canvas(FigureCanvasAgg(fig))
axes = fig.get_axes()[0 ]
axes.minorticks_off()
axes.set_yticks([])
fig.savefig(filename,**kwds)
else:
return g
def show_symmetry_props(self):
r"""
Display the symmetry properties of self.
"""
for i in range(self._ncusps):
print "Cusp Nr. {0} = {1}:{2}".format(i,self._cusps[i][0],self._cusps[i][1])
print "Normalizer is normalizer : {0}".format(self.cusp_normalizer_is_normalizer(i))
print "Can be symmetrized even/odd: {0}".format(self.is_symmetrizable_even_odd(i))
def test_normalize_pt_to_cusp(self,z,ci):
N=self._cusp_data[ci]['normalizer']
l=self._cusp_data[ci]['width']
print "N,l=",N,l
z1=N.acton(z*RR(l))
print "z1=",z1
x,y,A= self.pullback(RR(z1.real()),RR(z1.imag()))
z2=x+I*y
print "z2=",z2
cj,vj=self.closest_cusp(x,y,1)
print "cj,vj=",cj,vj
U = self._cusp_maps[vj]
z3=U.acton(z2)
print "z3=",z3
N2=self._cusp_data[cj]['normalizer']
l2=self._cusp_data[cj]['width']
z4 = (N2**-1).acton(z3)/RR(l2)
return z4
def _get_all_cusp_data(self,coset_reps,test=0):
r""" Return lists of vertices, inequivalent cusps, cusp normalizers, stabilisers and widths
from a list of right coset representatives.
Note: It is much more efficient to have it all here than using generic subgroutines.
OUTPUT:
-- [ns,ss,ws] - list of dictionaries with cusps p as keys.
ns : ns[p] = A in SL2Z with A(p)=infinity (cusp normalizer)
ss : ss[p] = A in SL2Z s.t. A(p)=p (cusp stabilizer)
ws : ws[p]= (w,s).
w = width of p and s = 1 if p is regular and -1 if not
EXAMPLES::
sage: S=SymmetricGroup(6)
sage: pS=S([2,1,4,3,6,5])
sage: pR=S([3,1,2,5,6,4])
sage: G=MySubgroup(o2=pS,o3=pR)
sage: l=G._get_cusp_data()
sage: l[0]
{0: [ 0 -1]
[ 1 0], Infinity: [1 1]
[0 1], -1/2: [-1 0]
[ 2 -1]}
sage: l[1]
{0: [ 1 0]
[-4 1], Infinity: [1 1]
[0 1], -1/2: [ 3 1]
[-4 -1]}
sage: l[2]
{0: (4, 1), Infinity: (1, 1), -1/2: (1, 1)}
"""
vertices=list()
cusps=list()
widths=dict()
normalizers=dict()
stabilizer=dict()
vertex_data=dict()
permT=self.permT
if self._verbose>0:
print "permT=",self.permT
lws=self.permT.to_cycles() #.cycle_tuples()
if self._verbose>0:
print "permT.cycles=",lws
## This is a set of all cusp widths which can occur
all_cusp_widths=map(len,lws)
cusp_widths={} #
## We get the width from the cycles:
for j in range(len(coset_reps)):
for c in lws:
if j+1 in c:
cusp_widths[j]=len(c)
break
gen_level=lcm(cusp_widths.values())
coset_perms=[MyPermutation(length=self._index)]
vertex_data=dict()
cusp_data=dict()
for j in range(1,len(coset_reps)):
V = coset_reps[j]
if self._verbose>0:
print "V[",j,"]=",V
perm=self.permutation_action(V,1)
if self._verbose>0:
print "perm(",j,")(1)=",perm(1)
coset_perms.append(perm)
# Recall that we have permutations for all groups here
# and that the widths can be read from self.permT
if self._verbose>0:
print "widths=",cusp_widths
print "reps=",coset_reps
Id=SL2Z_elt(1,0,0,1)
vi=0
## First populate the vertices
for j in range(len(coset_reps)):
if coset_reps[j][2]==0:
v=1,0
if v not in vertices:
vertices.append(v)
vertex_data[vi]={'cusp':0,'cusp_map':Id,'coset':[j],'width':int(cusp_widths[j])}
vi+=1
else:
vj = vertices.index(v)
vertex_data[vj]['coset'].append(j)
else:
v=(QQ(coset_reps[j][0])/QQ(coset_reps[j][2]))
v0 = v.numerator(); v1=v.denominator()
v=(v0,v1)
if v not in vertices:
vertices.append(v)
vertex_data[vi]={'cusp':-1,'cusp_map':Id,'coset':[j],'width':int(cusp_widths[j])}
vi+=1
else:
vj = vertices.index(v)
vertex_data[vj]['coset'].append(j)
if self._verbose>0:
print "vi=",vi
print "vertex_data=",vertex_data
# Then the cusps
if test==1:
return
ci=0
norm_perm={}
if (1,0) in vertices:
cusps=[(1,0)]
width = vertex_data[0]['width']
vertex_data[0]['cusp']=0
cusp_data[0]={'normalizer':Id,'width':int(width),'stabilizer':SL2Z_elt(1,width,0,1),'coset':[0]}
ci+=1
for j in range(len(vertices)):
v = vertices[j]
if self._verbose>0:
print "Test:",v
if v in cusps:
cii=cusps.index(v)
vertex_data[j]['cusp']=cii
#cusps.index(v)
if cusp_data[cii].has_key('vertices'):
cusp_data[cii]['vertices'].append(j)
else:
cusp_data[cii]['vertices']=[j]
continue
# Check which "canonical cusp" v is equivalent to.
W,U,p,q,l=self.get_equivalent_cusp(v[0],v[1])
if self._verbose>0:
if W<>0:
print "W,U,p,q,l=",list(W),list(U),p,q,l
else:
print "W,U,p,q,l=",W,U,p,q,l
print "cusps=",cusps
if (p,q) in cusps:
cii=cusps.index((p,q))
vertex_data[j]['cusp']=cii
vertex_data[j]['cusp_map']=U
cusp_data[cii]['vertices'].append(j)
continue
elif W==0: ## Check if this cusp is equivalent to another
do_cont=0
for pp,qq in cusps:
A=self._G.are_equivalent(Cusp(pp,qq),Cusp(v),True)
if self._verbose>0:
print "are eq:",Cusp(pp,qq),Cusp(v)
print "A=",A
if A:
a,b,c,d=A
cii=cusps.index((pp,qq))
vertex_data[j]['cusp']=cii
vertex_data[j]['cusp_map']=SL2Z_elt(d,-b,-c,a)
cusp_data[cii]['vertices'].append(j)
do_cont=1
break
if do_cont==1:
continue
# We add this vertex or the canonical rep.
cusp_data[ci]={}
cusp_data[ci]['vertices']=[]
vertex_data[j]['cusp']=ci
if p==0 and q==0:
if self._verbose>0:
print "1 setting cusp ",v
cusps.append(v)
vertex_data[j]['cusp_map']=Id
cusp_data[ci]['vertices'].append(j)
else:
if self._verbose>0:
print "2 setting cusp ",p,q
cusps.append((p,q))
vertex_data[j]['cusp_map']=U
cusp_data[ci]['vertices'].append(j)
if (p,q) not in vertices:
for vj in vertex_data[j]['coset']:
Vtmp = coset_reps[vj]
coset_reps[vj] = U*Vtmp
if self._verbose>0:
print "Changing rep from {0} to {1}".format(Vtmp,coset_reps[j])
vertices[j]=(p,q)
vertex_data[j]['cusp_map']=Id
# Setting the normalizer
if W<>0:
if l==0:
l = vertex_data[j]['width']
elif l<>vertex_data[j]['width']:
raise ArithmeticError,"Could not calculate width"
if self._verbose>0:
print "3 setting cusp ",p,q
print "width=",l
#S=W*SL2Z([1,l,0,1])*W**-1
if Cusp(p,q)==Cusp(-1,2):
#cusp_data[ci]['normalizer']=
W = SL2Z_elt(1,0,-2,1)
else:
W = U*W
cusp_data[ci]['normalizer']=W
S = W*SL2Z_elt(1,l,0,1) #S = mul_list_maps(W,[1,l,0,1])
S = S._mul(W,2) #S = mul_list_maps(S,W,inv=2)
cusp_data[ci]['width']=int(l)
cusp_data[ci]['stabilizer']=S
else:
coseti=vertex_data[j]['coset'][0]
permv=coset_perms[coseti]
if p==0 and q==0:
VV=coset_reps[coseti]
else:
VV=U*coset_reps[coseti]
cusp_data[ci]['normalizer']=VV
l = vertex_data[j]['width']
cusp_data[ci]['width']=int(l)
S = VV*SL2Z_elt(1,l,0,1)
S = S._mul(VV,2)
cusp_data[ci]['stabilizer']=S
ci+=1
# mul_list_maps(S,VV,2)
#'vertices':[j]}
#vertex_data[j]['cusp']=ci
#vertex_data[j]['cusp_map']=U #[U[0],U[1],U[2],U[3]]
#cusps.append((p,q))
#else:
# Use the one we have.
# First check if it is equiv to previous one
# coseti=vertex_data[j]['coset']
# permv=coset_perms[coseti]
# VV=coset_reps[coseti]
# if self._verbose>0:
# print "VV=",VV
# is_eq=0
# for cii in range(len(cusps)):
# W=cusp_data[cii]['normalizer']
# #permw=self.permutation_action(W,1)
# if not norm_perm.has_key(cii):
# norm_perm[cii]=self.permutation_action(W,1)
# permw=norm_perm[cii]
# #l=cusp_data[cii]['width']
# for k in all_cusp_widths:
# for ep in [1,-1]:
# if (permw.inverse())(((permT**(ep*k))(permv(1))))==1:
# U = VV*SL2Z_elt(1,ep*k,0,1)
# U = U._mul(W,2)
# #U = VV*SL2Z([1,ep*k,0,1])*W**-1
# if self._verbose>0:
# print vertices[j]," is equiv to ",cii
# vertex_data[j]['cusp']=cii
# vertex_data[j]['cusp_map']=U.inverse()
# is_eq=1
# break
# if is_eq==1:
# break
# if is_eq==1:
# break
# if is_eq==1:
# continue
#if self._verbose>0:
# print "2 setting cusp ",p,q
# print "width=",k
#if k in all_cusp_widths:
# all_cusp_widths.remove(k)
# cusps.append(v)
#print "Adding to cusps",v
#vertex_data[j]['cusp']=ci
# Need to get all the data for this cusp
# testi=permv(1)
# try:
# for k0 in all_cusp_widths: #range(1,gen_level+1):
# for ep in [1,-1]:
# k = k0*ep
# if self._verbose>2:
# print "trying width:",k
# print "(~permw)((self.permT**l)(permv(1)))",(permv*self._my_permT**k*(permv.inverse())).to_cycles()
# print "(~permw)((self.permT**l)(permv(1)))",(permv.inverse()*self._my_permT**k*(permv)).to_cycles()
# test=(permv.inverse())((self._my_permT**k)(testi))
# if test==1:
# if self._verbose>0:
# print "permv=",permv
# width=k
# S = VV*SL2Z_elt(1,width,0,1)
# S = S._mul(VV,2)
#mul_list_maps(S,VV,2)
#S=VV*SL2Z([1,width,0,1])*VV**-1
#cusp_data[ci]={'normalizer':VV,'width':int(abs(width)),'stabilizer':S,'vertices':[j]}
#if self._verbose>0:
# print "Setting cusp:",cusps[ci]
# print "width=",abs(width)
# raise StopIteration()
# raise ArithmeticError,"Could not compute data for cusp v={0}".format(v)
#except StopIteration:
# pass
#print "cusp_data[",ci,"]=",cusp_data[ci]
#if abs(width) in all_cusp_widths:
# all_cusp_widths.remove(abs(width))
#ci+=1
if self._verbose>0:
print "vertices",vertices
print "vertex_data=",vertex_data
print "cusps=",cusps
print "cusp_data=",cusp_data
#continue
# Small test:
#if len(cusps)<>len(cusp_widths):
# print "cusps=",cusps
# print "widths=",cusp_widths
# raise ArithmeticError,"Could not compute cusp data!"
return vertices,vertex_data,cusps,cusp_data
def PermGroup(self):
if self._perm_group==None:
self._perm_group = SymmetricGroup(self._index)
return self._perm_group
def coset_reps(self):
r""" Returns coset reps of self
EXAMPLES::
sage: S=SymmetricGroup(6)
sage: pS=S([2,1,4,3,6,5])
sage: pR=S([3,1,2,5,6,4])
sage: pS
(1,2)(3,4)(5,6)
sage: pR
(1,3,2)(4,5,6)
sage: G=MySubgroup(o2=pS,o3=pR)
sage: G.coset_reps()
[[1 0]
[0 1], [1 2]
[0 1], [1 1]
[0 1], [1 3]
[0 1], [1 5]
[0 1], [1 4]
[0 1], [ 4 -1]
[ 1 0]]
"""
return self._coset_reps
# def _get_perms_from_coset_reps(self):
# r""" Get permutations of order 2 and 3 from the coset representatives
# EXAMPLES::
# sage: S=SymmetricGroup(6)
# sage: pS=S([2,1,4,3,6,5])
# sage: pR=S([3,1,2,5,6,4])
# sage: G=MySubgroup(o2=pS,o3=pR)
# sage: G._get_perms_from_coset_reps()
# [(1,2)(3,4)(5,6), (1,3,2)(4,5,6)]
# sage: G=MySubgroup(Gamma0(6))
# sage: p=G._get_perms_from_coset_reps(); p[0]; p[1]
# (1,2)(3,4)(5,8)(6,9)(7,10)(11,12)
# (1,3,2)(4,5,9)(6,11,10)(7,12,8)
# """
# l=self._coset_reps
# li=list()
# n=len(l)
# G=self._G
# ps=range(1 ,self._index+1 )
# pr=range(1 ,self._index+1 )
# S,T=SL2Z.gens()
# R=S*T
# if isinstance(l[0],list):
# for i in range(n):
# li.append( SL2Z(l[i])**-1 )
# ixr=range(n)
# else:
# for i in range(n):
# li.append(l[i]**-1 )
# ixr=range(n)
# ixs=range(n)
# for i in range(n):
# [a,b,c,d]=l[i]
# VS=SL2Z([b,-a,d,-c]) # Vi*S
# VR=SL2Z([b,b-a,d,d-c]) # Vi*R=Vi*S*T
# for j in ixr:
# Vji=li[j] # Vj^-1
# if(VR*Vji in G):
# pr[i]=j+1
# ixr.remove(j)
# break
# for j in ixs:
# Vji=li[j]
# if(VS*Vji in G):
# ps[i]=j+1
# ixs.remove(j)
# break
# return [self._S(ps),self._S(pr)]
# # Now to public routines
def coset_rep(self,A):
r"""
Indata: A in PSL(2,Z)
Returns the coset representative of A in
PSL(2,Z)/self.G
EXAMPLES::
sage: G=MySubgroup(Gamma0(4))
sage: A=SL2Z([9,4,-16,-7])
sage: G.coset_rep(A)
[1 0]
[0 1]
sage: A=SL2Z([3,11,-26,-95])
sage: G.coset_rep(A)
[-1 0]
[ 2 -1]
sage: A=SL2Z([71,73,35,36])
sage: G.coset_rep(A)
[ 0 -1]
[ 1 0]
"""
for V in (self._coset_reps):
if( (A*V**-1 ) in self):
return V
raise ArithmeticError,"Did not find coset rep. for A=%s" %(A)
def pullback(self,x_in,y_in,ret_mat=0,prec=201):
r""" Find the pullback of a point in H to the fundamental domain of self
INPUT:
- ''x_in,y_in'' -- x_in+I*y_in is in the upper half-plane
- ''prec'' -- (default 201) precision in bits
- ret_mat -- set to 0 if you want to return a list instead of a matrix.
OUTPUT:
- [xpb,ypb,B] -- xpb+I*ypb=B(x_in+I*y_in) with B in self
xpb and ypb are complex numbers with precision prec
EXAMPLES::
sage: S=SymmetricGroup(6)
sage: pS=S([2,1,4,3,6,5])
sage: pR=S([3,1,2,5,6,4])
sage: G=MySubgroup(o2=pS,o3=pR)
sage: [x,y,B]=G.pullback(0.2,0.5,53); x,y;B
(-0.237623762376238, 0.123762376237624)
[-1 0]
[ 4 -1]
sage: (B**-1).acton(x+I*y)
0.200000000000000 + 0.500000000000000*I
"""
#x=deepcopy(x_in); y=deepcopy(y_in)
if self._is_Gamma0:
if isinstance(x_in,float):
xpb,ypb,a,b,c,d=pullback_to_Gamma0N_dp(self,x_in,y_in,self._verbose)
elif isinstance(x_in,Expression):
prec=round(RR(len(str(x_in).split(".")[1])/log(2,10)))
RF=RealField(prec)
x=RF(x_in); y=RF(y_in)
if prec<=53:
xpb,ypb,a,b,c,d=pullback_to_Gamma0N_dp(self,x,y,self._verbose)
else:
xpb,ypb,a,b,c,d=pullback_to_Gamma0N_mpfr(self,x,y)
else:
xpb,ypb,a,b,c,d=pullback_to_Gamma0N_mpfr(self,x_in,y_in)
if ret_mat==1:
return xpb,ypb,SL2Z_elt(a,b,c,d)
else:
return xpb,ypb,int(a),int(b),int(c),int(d)
else:
a,b,c,d=pullback_to_psl2z_mat(RR(x_in),RR(y_in))
A=SL2Z_elt(a,b,c,d) #.matrix()
try:
for V in self._coset_reps:
B=V*A
if B in self:
raise StopIteration
except StopIteration:
pass
else:
raise ArithmeticError,"Did not find coset rep. for A=%s" % A
#if ret_int==1:
# a,b,c,d=B[0,0],B[0,1],B[1,0],B[1,1]
if isinstance(x_in,float):
xpb,ypb=apply_sl2z_map_dp(x_in,y_in,B[0],B[1],B[2],B[3])
else:
xpb,ypb=apply_sl2z_map_mpfr(x_in,y_in,B[0],B[1],B[2],B[3])
if ret_mat==1:
return xpb,ypb,B.matrix()
else:
return xpb,ypb,B[0],B[1],B[2],B[3]
def is_congruence(self):
r""" Is self a congruence subgroup or not?
EXAMPLES::
sage: S=SymmetricGroup(6)
sage: pS=S([2,1,4,3,6,5])
sage: pR=S([3,1,2,5,6,4])
sage: G=MySubgroup(o2=pS,o3=pR)
sage: G.is_congruence()
True
sage: S=SymmetricGroup(7)
sage: pS=S([1,3,2,5,4,7,6]); pS
(2,3)(4,5)(6,7)
sage: pR=S([3,2,4,1,6,7,5]); pR
(1,3,4)(5,6,7)
sage: G=MySubgroup(o2=pS,o3=pR)
sage: G.is_congruence()
False
"""
try:
return self._is_congruence
except:
self._is_congruence=self._G.is_congruence()
return self._is_congruence
def is_Gamma0(self):
return self._is_Gamma0
def is_Hecke_triangle_group(self):
if self.is_Gamma0() and self.level()==1:
return True
else:
return False
def generalised_level(self):
r""" Generalized level of self
EXAMPLES::y
sage: S=SymmetricGroup(6)
sage: pS=S([2,1,4,3,6,5])
sage: pR=S([3,1,2,5,6,4])
sage: G=MySubgroup(o2=pS,o3=pR)
sage: G.generalised_level()
4
sage: S=SymmetricGroup(7)
sage: pS=S([1,3,2,5,4,7,6]); pS
(2,3)(4,5)(6,7)
sage: pR=S([3,2,4,1,6,7,5]); pR
(1,3,4)(5,6,7)
sage: G=MySubgroup(o2=pS,o3=pR)
sage: G.generalised_level()
6
"""
if self._generalised_level==None:
# compute the generalized level
self._generalised_level= lcm(map(len,self.permT.cycle_tuples()))
return self._generalised_level
#raise ArithmeticError, "Could not compute generalised level of %s" %(self)
def level(self):
r""" Level of self
EXAMPLES::
sage: G=MySubgroup(Gamma0(5));
sage: G.level()
5
"""
if(self._is_congruence):
return self.generalised_level()
else:
raise TypeError,"Group is not a congruence group! Use G.generalised_level() instead!"
def genus(self):
r""" Genus of self
EXAMPLES::
sage: G=MySubgroup(Gamma0(5));
sage: G.genus()
5
"""
return self._genus
def nu2(self):
r""" Number of elliptic fixed points of order 2 of self.
EXAMPLES::
sage: G=MySubgroup(Gamma0(5));
sage: G.genus()
5
"""
return self._nu2
def nu3(self):
r""" Number of elliptic fixed points of order 3 of self.
EXAMPLES::
sage: G=MySubgroup(Gamma0(5));
sage: G.genus()
5
"""
return self._nu3
# def gens(self):
# r""" Generators of self
# EXAMPLES::
# sage: G=MySubgroup(Gamma0(5));
# sage: G.gens()
# ([1 1]
# [0 1], [-1 0]
# [ 0 -1], [ 1 -1]
# [ 0 1], [1 0]
# [5 1], [1 1]
# [0 1], [-2 -1]
# [ 5 2], [-3 -1]
# [10 3], [-1 0]
# [ 5 -1], [ 1 0]
# [-5 1])
# sage: G3=MySubgroup(o2=Permutations(3)([1,2,3]),o3=Permutations(3)([2,3,1]))
# sage: G3.gens()
# ([1 3]
# [0 1], [ 0 -1]
# [ 1 0], [ 1 -2]
# [ 1 -1], [ 2 -5]
# [ 1 -2])
# """
# # do some reductions from the generators
# if self._gens:
# return self._gens
# #gens = self._G.gens()
# newgens=[]; gens=[]
# for A in self._G.gens():
# gens.append([A[0,0],A[0,1],A[1,0],A[1,1]])
# newgens.append([A[0,0],A[0,1],A[1,0],A[1,1]])
# #newgens=list(gens)
# if self._verbose>1:
# print "original gens=",newgens
# #m1=[-1,0,0,-1]
# for x in gens:
# if x not in newgens:
# continue
# if self._verbose>1:
# print "x:",x
# t=[-x[0],-x[1],-x[2],-x[3]] #mul_list_maps(m1,x)
# if t<>x and t in newgens:
# if self._verbose>1:
# print "remove -x:",t
# newgens.remove(t)
# t = [x[3],-x[1],-x[2],x[0]]
# #t=x**-1
# if t<>x and t in newgens:
# if self._verbose>1:
# print "remove x**-1:",t #x**-1
# newgens.remove(t)
# t=[-x[3],x[1],x[2],-x[0]] #t*m1
# if t<>x and t in newgens:
# if self._verbose>1:
# print "remove -x**-1:",t #m1*x**-1
# newgens.remove(t) #m1*x**-1)
# # also remove duplicate
# gens=newgens
# for x in gens:
# if gens.count(x)>1:
# newgens.remove(x)
# if self._verbose>1:
# print "newgens=",newgens
# self._gens=newgens
# #for t in newgens:
# # self._gens.append(SL2Z(t)) #=newgens
# return self._gens
def as_named_group(self):
r"""
Identify self as a group of type Gamma0, Gamma1 or Gamma
if possible.-
TODO: Check if we are conjugate to one of these groups
"""
if not self.is_congruence():
return None
conj=1
N = self.level()
# do a preliminary test to see if ST^NS or T^N is in the group
if self.permT(1)==1:
# could be Gamma_0(N)
if self._verbose>0:
print "try Gamma0N!"
G = Gamma0(N)
if G.index() <> self.index():
return None
Gtmp=G.as_permutation_group()
tmpS=MyPermutation( (Gtmp.L()*(~Gtmp.R())*Gtmp.L()).list())
tmpT=MyPermutation( Gtmp.L().list())
if tmpS==self.permS and tmpT==self.permT:
return G
elif (self.permT**N)(1)==1:
# could be Gamma^0, Gamma1 or Gamma
# try first Gamma1 and Gamma
G = Gamma1(N)
if G.index() == self.index():
if self._verbose>0:
print "try Gamma1N!"
Gtmp=G.as_permutation_group()
tmpS=MyPermutation( (Gtmp.L()*(~Gtmp.R())*Gtmp.L()).list())
tmpT=MyPermutation( Gtmp.L().list())
if tmpS==self.permS and tmpT==self.permT:
return G
G = Gamma(N)
if G.index() == self.index():
if self._verbose>0:
print "try GammaN!"
Gtmp=G.as_permutation_group()
tmpS=MyPermutation((Gtmp.L()*(~Gtmp.R())*Gtmp.L()).list())
tmpT=MyPermutation( Gtmp.L().list())
if tmpS==self.permS and tmpT==self.permT:
return G
# else try to conjugate to see if we have Gamma^0
# Recall that Gamma^0(N)=S*Gamma_0(N)*S
#cyc = self.permT.cycle_tuples() #perm_cycles(self.permT)
#j = cyc[1][0]
#pl=range(1,self._index+1)
#pl[0]=j
#pl[j-1]=1
#ptmp = MyPermutation(pl) # self._S((1,j))
#ptmp=self.permS
tmpL=self.permS*self.permT*self.permS.inverse()
tmpS=self.permS
if self._verbose>0:
print "tmpL=",tmpL
print "tmpP=",tmpP
G = Gamma0(N)
if G.index() <> self.index():
return None
Gtmp=G.as_permutation_group()
tmpS1=MyPermutation( (Gtmp.L()*(~Gtmp.R())*Gtmp.L()).list())
tmpT1=MyPermutation( Gtmp.L().list())
print "tmpS=",tmpS
print "tmpT=",tmpT
print "tmpS1=",tmpS1
print "tmpT1=",tmpT1
if tmpS1==tmpS and tmpT1==tmpT:
return "Gamma^0(N)"
## def block_systems(self):
## r"""
## Return a list of possible Block systems and overgroups for the group G.
## INDATA: G = subgroup of the modular group
## OUTDATA res['blocksystems']= Block systems
## res['overgroups'] = Overgroups corresponding to the blocks
## in the block systems
## EXAMPLES::
## """
## return get_block_systems(self.permS,self.permR,False)
def get_equivalent_cusp(self,p,q):
r"""
Get an equivalent cusp and a cusp-normalizing map
which is, if possible, an Atkin-Lehner involution.
"""
if not self._is_Gamma0:
return 0,0,0,0,0
Id = SL2Z_elt(1,0,0,1)
if q==0:
WQ=Id
A =Id
l = 1
return (WQ,A,p,q,l)
if p==0:
WQ=SL2Z_elt(0,-1,1,0)
A =Id
l = self._level
return (WQ,A,p,q,l)
N = self._level
if self._verbose>0:
print "p=",p
print "q=",q
print "N=",N
if N % q==0:
Q = N.divide_knowing_divisible_by(q)*p
if Q<0:
Q=-Q
#q=abs(q)
#p=abs(p)
if Q.divides(N):
if self._verbose>0:
print "Q0=",Q
N1 = N.divide_knowing_divisible_by(Q)
g,s,t=xgcd(Q,N1)
if g==1:
A=[1,0,0,1]
if self._verbose>0:
print "s,t=",s,t
# a = Q; b =-t; c=N; d=s*Q
if Q>0:
WQ=SL2Z_elt(1,-t,N1,Q*s)
else:
WQ=SL2Z_elt(-1,t,-N1,-Q*s)
if Q<0:
return (WQ,A,abs(p),abs(q),abs(Q))
divs=[]
#for Q in self._level.divisors():
# divs.append(Q)
for Q in self._level.divisors():
divs.append(-Q)
#divs.append(-Q)
res=[]
for Q in divs:
if self._verbose>0:
print "Q=",Q
c1 = Cusp(QQ(Q)/QQ(N)) #Cusp(QQ(Q)/QQ(N))
c2 = Cusp(QQ(p)/QQ(q))
t,A=Cusp.is_gamma0_equiv(c1, c2, self._level, transformation='matrix')
if self._verbose>0:
#print "c1=",c1
#print "c2=",c2
print "t=",t,A
if t:
U=SL2Z_elt(A[1,1],-A[0,1],-A[1,0],A[0,0])
#U=A**-1
if self._verbose>0:
print "c1=",c1
print "c2=",c2
pp=c1.numerator()
qq=c1.denominator()
g,s,t=xgcd( Q,ZZ(QQ(N)/QQ(Q)))
if g<>1:
# We can not get Atkin-Lehner but at least we get
# a canonical representative of the form Q/N
# and if we have a cusp of the form p/q, q|N
# (p,q)=1 then we get the width from Iwaniec "Topics in Classical..., Sect. 2.4"
# for Gamma_0(N) at least
if self._is_Gamma0:
if q % N==0:
l = N.divide_knowing_divisible_by(gcd(N,q**2))
elif qq % N==0:
l = N.divide_knowing_divisible_by(gcd(N,qq**2))
else:
if self._verbose>0:
print "q%N=",(q%N)
print "qq%N=",(qq%N)
l=0 # self._G.cusp_width(c2)
else:
l=self._G.cusp_width(c2)
## Return a non-normalizer (but maybe twisted) map W
if pp==1:
W=SL2Z_elt(1,0,int(qq),1)
else:
w = lift_to_sl2z(q, p, 0 )
W = SL2Z_elt(w[3 ], w[1 ], w[2 ],w[0 ])
return W,U,pp,qq,l
a = Q; b =-t; c=N; d=s*Q
if self._verbose>0:
print "a,b,c,d=",a,b,c,d
## We should see if (a b ; c d) = A rho with A in SL2Z
for l in gcd(a,c).divisors():
aa = a.divide_knowing_divisible_by(l)
cc = c.divide_knowing_divisible_by(l)
if aa*d-cc*b==1:
WQ=SL2Z_elt(aa,b,cc,d)
pp=numerator(Q/N)
qq=denominator(Q/N)
#if c1==c2:
return (WQ,U,pp,qq,l)
#res.append((WQ,U,pp,qq,l))
break
if len(res)==1:
return res[0]
if len(res)>1:
# Pick the best one
if self._verbose>0:
print "res>1=",res
lista= map(lambda x:sum(map(abs,x[1].matrix().list())),res)
mina=min(lista)
i=lista.index(mina)
return res[i]
return 0,0,0,0,0
def show_symmetry_props(self):
r"""
Display the symmetry properties of self.
"""
for i in range(self._ncusps):
print "Cusp Nr. {0} = {1}:{2}".format(i,self._cusps[i][0],self._cusps[i][1])
print "Normalizer is normalizer : {0}".format(self.cusp_normalizer_is_normalizer(i))
print "Can be symmetrized even/odd: {0}".format(self.is_symmetrizable_even_odd(i))
def test_cusp_data(self):
for i in range(self._ncusps):
p,q = self._cusps[i]
N = self._cusp_data[i]['normalizer']
for j in range(self._ncusps):
if i==j:
continue
x=Cusp(self._cusps[j])
if self.are_equivalent_cusps(Cusp(p,q),x):
raise ArithmeticError, "Cusps {0} and {1} are equivalent!".format(Cusp(p,q),x)
if q==0:
c = Infinity
t1 = N[0]==p and N[2]==0
else:
c=QQ(p)/QQ(q)
t1 = c==QQ(N[0])/QQ(N[2])
if not t1:
raise ArithmeticError, "{0} is not normalizer of cusp nr.{1}: {2}".format(N,i,c)
A = self._cusp_data[i]['stabilizer']
if q==0:
t2 = A[0]<>0 and A[2]==0
else:
t2 = c== acton_list_maps(A,c)
if not t2:
raise ArithmeticError, "{0} is does not stabilize cusp nr. {1}: {2}".format(A,i,c)
TT = mul_list_maps(N,A,1)
TT = mul_list_maps(TT,N)
#TT = N**-1*A*N
S = [0,-1,1,0]; T=[1,1,0,1]
#S,T=SL2Z.gens()
l = self._cusp_data[i]['width']
if TT<>[1,l,0,1]:
raise ArithmeticError, "Width {0} is not correct width for cusp nr. {1}: {2}".format(l,i,c)
for i in range(self._nvertices):
vp,vq = self._vertices[i]
if vq==0:
v = Infinity
else:
v = QQ(vp)/QQ(vq)
j = self._vertex_data[i]['cusp']
p,q = self._cusps[j]
if q==0:
c=Infinity
else:
c = QQ(p)/QQ(q)
# Want to see that it maps to the correct cusp
A = self._vertex_data[i]['cusp_map']
if vq==0:
if q==0:
t3 = A[0]<>0 and A[2]==0
else:
t3 = QQ(A[0])/QQ(A[2])==c
else:
if q==0:
t3 = (A[0]*v+A[2])<>0 and (A[2]*v+A[3])==0
else:
#print "Av=",A.acton(v)
#print "c=",c
t3 = acton_list_maps(A,v)==c
if not t3:
raise ArithmeticError,"The map {0} does not map the vertex nr. {1}: {2} to the cusp nr. {3}: {4}".format(A,i,v,j,c)
# Also check that the correct number of coset reps maps to this vertex
cnt=0
for vj in self._vertex_data[i]['coset']:
V = self._coset_reps[vj]
a = V.a(); c=V.c()
if Cusp(a,c)<>Cusp(vp,vq):
raise ArithmeticError,"Coset rep {0} do not map to the vertex {1}!".format(V,v)
else:
cnt+=1
if cnt>self._vertex_data[i]['width']:
raise ArithmeticError,"Too many coset reps. maps to the vertex {0}! ".format(v)
def test_coset_reps(self):
r"""
Test if the coset representatives are independent.
"""
for j in range(len(self._coset_reps)):
A=self._coset_reps_list[j]
#print "A=",A,type(A)
for k in range(len(self._coset_reps)):
B=self._coset_reps_list[k]
#print "B=",B,type(B)
#if A==B:
if A[0]==B[0] and A[1]==B[1] and A[2]==B[2] and A[3]==B[3]:
continue
BB = mul_list_maps(A,B,2)
if self._is_Gamma0:
t = BB[2] % self._level == 0
else:
t = BB in self
if t:
print "A[",j,"]=",A
print "B[",k,"]=",B
print "AB^-1=",BB
raise ArithmeticError,"Coset representatives are not correct!"
def test_normalize_pt_to_cusp(self,z,ci):
assert isinstance(ci,(int,Integer))
assert z.imag()>0
N=self._cusp_data[ci]['normalizer']
l=self._cusp_data[ci]['width']
print "N,l=",N,l
z1=N.acton(z*RR(l))
print "z1=",z1
x,y,A= self.pullback(RR(z1.real()),RR(z1.imag()))
z2=x+I*y
print "z2=",z2
cj,vj=self.closest_cusp(x,y,1)
print "cj,vj=",cj,vj
U = self._cusp_maps[vj]
z3=U.acton(z2)
print "z3=",z3
N2=self._cusp_data[cj]['normalizer']
l2=self._cusp_data[cj]['width']
z4 = (N2**-1).acton(z3)/RR(l2)
return z4
### Hecke triangle groups
class HeckeTriangleGroup(SageObject):
def __init__(self,q=3,prec=53,verbose=0):
r"""
Hecke triangle groups.
NOTE: For now we don't have subgroups.
"""
if not isinstance(q,(int,Integer)):
raise ValueError,"Need an integer q!"
self._q=q
self._prec=prec
self._verbose=verbose
RF=RealField(prec)
self._lambdaq=RF(2)*(RF.pi()/RF(q)).cos()
self._coset_reps = [1]
self._vertices = [(1,0)] # List of vertices corresponding to the coset reps.
self._cusps = [(1,0)] # Subset of representatives
self._cusps_as_cusps=[Cusp(Infinity)]
self._S=None
self._R=None
self._T=None
self._index=1
self._ncusps=1
self._nvertices=1
#A = Matrix(ZZ,2,2,[1,0,0,1])
self._vertex_data=dict()
self._level=1 # Should be lambdaq?
self._vertex_data[0]={'cusp':0,'cusp_map':[1,0,0,1],'coset':[0]}
self._cusp_data=dict()
Tl=matrix(RR,2,2,[1,self._lambdaq,0,1])
self._cusp_data[0]={'width':self._lambdaq,'normalizer':[1,0,0,1],'stabilizer':Tl}
self._vertex_widths=dict()
self._vertex_widths=[self._lambdaq]
self._vertex_maps=[[1,0,0,1]]
self._cusp_maps=[[1,0,0,1]]
self._is_Hecke_triangle_group=True
self._is_Gamma0=False
self._is_congruence=True
self._symmetrizable_cusp={0:1}
self._cusp_normalizer_is_normalizer={0:(1,1)}
self.class_name='HeckeTriangleGroup'
def __repr__(self):
return 'Hecke Triangle group G_{0}'.format(self._q)
def closest_cusp(self,x,y,vertex=0):
if vertex==1:
return (1,0),0
else:
return (1,0)
def ncusps(self):
return self._ncusps
def nu2(self):
return 1
def nu3(self):
if self._q<>3:
return 0
else:
return 1
def is_congruence(self):
return True # It is a congruence group of itself...
def is_Hecke_triangle_group(self):
return True
def __rep__(self):
s="Hecke triangle group G_{0}".format(self._q)
return s
def level(self):
return self._level
def index(self):
return self._index
def cusps(self):
return self._cusps
def minimal_height(self):
return (RR.pi()/self._q).sin()
def pullback(self,x_in,y_in,prec=201 ):
r""" Find the pullback of a point in H to the fundamental domain of self
INPUT:
- ''x_in,y_in'' -- x_in+I*y_in is in the upper half-plane
- ''prec'' -- (default 201) precision in bits
OUTPUT:
- [xpb,ypb,B] -- xpb+I*ypb=B(x_in+I*y_in) with B in self
xpb and ypb are complex numbers with precision prec
EXAMPLES::
"""
x=deepcopy(x_in); y=deepcopy(y_in)
RF=RealField(prec)
a,b,c,d=pullback_to_hecke_triangle_mat_dp(x,y,RR(self._lambdaq))
xpb=RR(x_in); ypb=RR(y_in)
#print a,b,c,d
xpb,ypb=apply_sl2r_map_dp(x_in,y_in,a,b,c,d)
return [xpb,ypb,[a,b,c,d]] #Matrix(RR,2,2,[a,b,c,d])
# def factor_matrix_in_sl2z_in_S_and_T(A_in):
# r"""
# Factor A in SL2Z in generators S=[[0,-1],[1,0]] and T=[[1,1],[0,1]]
# INPUT:
# - ''A_in'' -- Matrix in SL2Z
# OUTPUT:
# - ''[[a0,a1,...,an],ep] with a0 in ZZ, ai in ZZ \ {0,\pm1}, ep=1,-1
# Determined by:
# A=ep*(T^a0*S*T^a1*S*...*S*T^an)
# The algorithm uses the Nearest integer Continued Fraction expansion. Note that there due to relations in SL2Z the sequence a_j is not unique
# (see example below)
# EXAMPLES::
# sage: nearest_integer_continued_fraction(0.5);cf
# [1, 2]
# sage: A=ncf_to_matrix_in_SL2Z(cf); A
# [1 1]
# [1 2]
# sage: factor_matrix_in_sl2z_in_S_and_T(A)
# [[1, 2], 1]
# An example where we do not get back the same sequence::
# sage: cf=nearest_integer_continued_fraction(pi.n(100),nmax=10);cf
# [3, -7, 16, 294, 3, 4, 5, 15, -3, -2, 2]
# sage: A=ncf_to_matrix_in_SL2Z(cf); A
# [ -411557987 -1068966896]
# [ -131002976 -340262731]
# sage: factor_matrix_in_sl2z_in_S_and_T(A)
# [[3, -7, 16, 294, 3, 4, 5, 15, -2, 2, 3], -1]
# """
# if A_in not in SL2Z:
# raise TypeError, "%s must be an element of SL2Z" %A_in
# S,T=SL2Z.gens()
# # If A is not member of SL(2,Z) but a plain matrix
# # we cast it to a member of SL2Z
# A = SL2Z(A_in)
# if(A.matrix()[1 ,0 ] == 0 ):
# return [[A.matrix()[0 ,1 ]],1 ]
# x = Rational(A.matrix()[0 ,0 ] / A.matrix()[1 ,0 ])
# cf = nearest_integer_continued_fraction(x)
# B = ncf_to_matrix_in_SL2Z(cf)
# # we know that A(oo) = x = B*S (oo) and that A and BS differ at most by a translation T^j
# Tj = S**-1 * B**-1 * A
# sgn=1
# if(Tj.matrix()[0 ,0 ]<0 ):
# j=-Tj.matrix()[0 ,1 ]
# sgn=-1
# #Tj=SL2Z([1,j,0,1])
# else:
# j=Tj.matrix()[0 ,1 ]
# # if Tj = Id i.e. j=0 then A=BS otherwise A=BST^j
# cf.append(j)
# # To make sure we test
# C = B*S*Tj
# try:
# for ir in range(2):
# for ik in range(2):
# if(C[ir,ik]<>A[ir,ik] and C[ir,ik]<>-A[ir,ik]):
# raise StopIteration
# except StopIteration:
# print "ERROR: factorization failed %s <> %s " %(C,A)
# print "Cf(A)=",cf
# raise ArithmeticError," Could not factor matrix A=%s" % A_in
# if(C.matrix()[0 ,0 ]==-A.matrix()[0 ,0 ] and C.matrix()[0 ,1 ]==-A.matrix()[0 ,1 ]):
# sgn=-1
# return [cf,sgn]
# def list_factor_matrix_in_sl2z_in_S_and_T(A):
# r"""
# Factor A in SL2Z in generators S=[[0,-1],[1,0]] and T=[[1,1],[0,1]]
# INPUT:
# - ''A_in'' -- Matrix in SL2Z
# OUTPUT:
# - ''[[a0,a1,...,an],ep] with a0 in ZZ, ai in ZZ \ {0,\pm1}, ep=1,-1
# Determined by:
# A=ep*(T^a0*S*T^a1*S*...*S*T^an)
# The algorithm uses the Nearest integer Continued Fraction expansion. Note that there due to relations in SL2Z the sequence a_j is not unique
# (see example below)
# EXAMPLES::
# sage: nearest_integer_continued_fraction(0.5);cf
# [1, 2]
# sage: A=ncf_to_matrix_in_SL2Z(cf); A
# [1 1]
# [1 2]
# sage: factor_matrix_in_sl2z_in_S_and_T(A)
# [[1, 2], 1]
# An example where we do not get back the same sequence::
# sage: cf=nearest_integer_continued_fraction(pi.n(100),nmax=10);cf
# [3, -7, 16, 294, 3, 4, 5, 15, -3, -2, 2]
# sage: A=ncf_to_matrix_in_SL2Z(cf); A
# [ -411557987 -1068966896]
# [ -131002976 -340262731]
# sage: factor_matrix_in_sl2z_in_S_and_T(A)
# [[3, -7, 16, 294, 3, 4, 5, 15, -2, 2, 3], -1]
# """
# #if A_in not in SL2Z:
# if not isinstance(A,list) or not (A[0]*A[3]-A[1]*A[2]==1):
# raise TypeError, "%s must be an element of SL2Z" %A_in
# S = [0,-1,1,0]; T=[1,1,0,1]
# #S,T=SL2Z.gens()
# # If A is not member of SL(2,Z) but a plain matrix
# # we cast it to a member of SL2Z
# #A = SL2Z(A_in)
# if(A[2] == 0 ):
# return [[ b ],1 ]
# x = Rational(A[0] / A[2])
# cf = nearest_integer_continued_fraction(x)
# B = list_ncf_to_matrix_in_SL2Z(cf)
# # we know that A(oo) = x = B*S (oo) and that A and BS differ at most by a translation T^j
# Tj = mul_list_maps(B,A,1)
# Tj = mul_list_maps(S,Tj,1)
# #Tj = S**-1 * B**-1 * A
# sgn=1
# if Tj[0]<0:
# j=-Tj[1]
# sgn=-1
# #Tj=SL2Z([1,j,0,1])
# else:
# j=Tj[1]
# # if Tj = Id i.e. j=0 then A=BS otherwise A=BST^j
# cf.append(j)
# # To make sure we test
# C = mul_list_maps(B,S)
# C = mul_list_maps(C,Tj)
# #C = B*S*Tj
# try:
# for ir in range(4):
# if C[ir]<>A[ir] and C[ir]<>-A[ir]:
# raise StopIteration
# #for ik in range(2):
# # if(C[ir,ik]<>A[ir,ik] and C[ir,ik]<>-A[ir,ik]):
# # raise StopIteration
# except StopIteration:
# print "ERROR: factorization failed %s <> %s " %(C,A)
# print "Cf(A)=",cf
# raise ArithmeticError," Could not factor matrix A=%s" % A_in
# if (C[0]==-A[0] and C[1]==-A[1]):
# sgn=-1
# return [cf,sgn]
def nearest_integer_continued_fraction(x,nmax=None):
r""" Nearest integer continued fraction of x
where x is a rational number, and at n digits
EXAMPLES::
sage: nearest_integer_continued_fraction(0.5)
[1, 2]
nearest_integer_continued_fraction(pi.n(100),nmax=10)
[3, -7, 16, 294, 3, 4, 5, 15, -3, -2, 2]
"""
if(nmax == None):
if(x in QQ):
nmax=10000
else:
nmax=100 # For non-rational numbrs we don't want so many convergents
jj=0
cf=list()
n=nearest_integer(x)
cf.append(n)
if(x in QQ):
x1=Rational(x-n)
while jj<nmax and x1<>0 :
n=nearest_integer(-1 /x1)
x1=Rational(-1 /x1-n)
cf.append(n)
jj=jj+1
return cf
else:
try:
RF=x.parent()
x1=RF(x-n)
while jj<nmax and x1<>0 :
n=nearest_integer(RF(-1 )/x1)
x1=RF(-1 )/x1-RF(n)
cf.append(n)
jj=jj+1
return cf
except AttributeError:
raise ValueError,"Could not determine type of input x=%s" %x
def nearest_integer(x):
r""" Returns the nearest integer to x: [x]
using the convention that
[1/2]=0 and [-1/2]=0
EXAMPLES::
sage: nearest_integer(0)
0
sage: nearest_integer(0.5)
1
sage: nearest_integer(-0.5)
0
sage: nearest_integer(-0.500001)
-1
"""
return floor(x+ 0.5)
def _get_perms_from_str(st):
r""" Construct permutations frm the string st of the form
st='[a1_a2_..._an]-[b1_...bn]'
EXAMPLES::
sage: G=MySubgroup(Gamma0(5))
sage: s=G._get_uid();s
'[2_1_4_3_5_6]-[3_1_2_5_6_4]-Gamma0(5)'
sage: _get_perms_from_str(s)
[(1,2)(3,4), (1,3,2)(4,5,6)]
sage: S=SymmetricGroup(7)
sage: pS=S([1,3,2,5,4,7,6]); pS
(2,3)(4,5)(6,7)
sage: pR=S([3,2,4,1,6,7,5]); pR
(1,3,4)(5,6,7)
sage: G=MySubgroup(Gamma0(4))
sage: G=MySubgroup(o2=pS,o3=pR)
sage: s=G._get_uid();s
'[1_3_2_5_4_7_6]-[3_2_4_1_6_7_5]'
sage: _get_perms_from_str(s)
[(2,3)(4,5)(6,7), (1,3,4)(5,6,7)]
"""
(s1,sep,s2)=s.partition("-")
if(len(sep)==0 ):
raise ValueError,"Need to supply string of correct format!"
if(s2.count("-")>0 ):
# split again
(s21,sep,s22)=s2.partition("-")
s2=s21
ix=s1.count("_")+ZZ(1)
pS=list(range(ix))
pR=list(range(ix))
s1=s1.strip("["); s1=s1.strip("]");
s2=s2.strip("["); s2=s2.strip("]");
vs1=s1.split("_")
vs2=s2.split("_")
P=SymmetricGroup(ix)
for n in range(ix):
pS[n]=int(vs1[n])
pR[n]=int(vs2[n])
return [P(pS),P(pR)]
def get_perms_from_cycle_str(s,N,sep=' ',deb=False):
r""" Construct permutations frm the string st of the form
st='[(a1;a2;...;an)(b1;...;bn)'
where ';' can be replaced by any separator.
EXAMPLES::
"""
# First get the cycles (and remove the beginning and end of the string)
cycles = s[1:-1].split(")(")
perm = range(1,N+1)
if deb:
print "N=",N
for c in cycles:
if deb:
print "c=",c
l=map(int,c.split(sep)) # elements of the cycle are separated by "sep"
nn = len(l)-1
if nn>0:
for i in range(nn):
perm[l[i]-1]=l[i+1]
perm[l[nn]-1]=l[0]
S=SymmetricGroup(N)
return S(perm)
### Algorithms which deal with lists of groups
def get_list_of_valid_signatures(index,nc=None,ne2=None,ne3=None,ng=None):
r"""
Returns a list of all signatures , i.e.tuples:
(index,h,e2,e3,g)
with
h = number of cusps
e2 = number of order 2 elliptic points
e2 = number of order 3 elliptic points
g = genus
of subgroups of PSL(2,Z) of gien index
INPUT:
- ''index'' -- a positive integer
- ''nc'' -- number of cusps desired (default None)
- ''ne2'' -- number of elliptic points of order 2 desired (default None)
- ''ne3'' -- number of elliptic points of order 2 desired (default None)
- ''ng'' -- genus desired (default None)
EXAMPLES::
sage: get_list_of_valid_signatures(2)
[[2, 1, 0, 2, 0]]
sage: get_list_of_valid_signatures(5)
[[5, 1, 1, 2, 0]]
sage: get_list_of_valid_signatures(6)
[[6, 1, 0, 0, 1], [6, 1, 0, 3, 0], [6, 1, 4, 0, 0], [6, 2, 2, 0, 0], [6, 3, 0, 0, 0]]
"""
if(index not in ZZ or index <=0):
raise TypeError, "index must be a positive integer! Got: %s"%index
res=list()
for h in range(1,index+1):
if(nc<>None and h<>nc):
continue
for e2 in range(0,index+1):
if(ne2<>None and ne2<>e2):
continue
for e3 in range(0,index+1):
if(ne3<>None and ne3<>e3):
continue
g=12+index-6*h-3*e2-4*e3
if(ng<>None and g<>ng):
continue
if( (g>=0) and ((g % 12)==0)): # we have a valid type
g=g/12
res.append([index,h,e2,e3,g])
return res
def perm_cycles(perm):
c=perm.cycle_tuples()
#if sum(map(lambda x:len(x),c))<>len(e.list()):
# If there are fixed points we add them
l = perm.list()
for i in range(len(l)):
if l[i]==i+1:
c.append((i+1,))
return c
def mul_list_maps(l1,l2,inv=0):
r"""
A*B= (a b) (x y)
(c d) (z w)
If inv == 1 invert A
If inv == 2 invert B
"""
a,b,c,d=l1
x,y,z,w=l2
if inv ==1:
tmp=a
a=d
d=tmp
b=-b; c=-c
if inv==2:
tmp=x
x=w
w=tmp
y=-y; z=-z
aa=a*x+b*z
bb=a*y+b*w
cc=c*x+d*z
dd=c*y+d*w
return [aa,bb,cc,dd]
def acton_list_maps(A,c):
return (A[0]*c+A[1])/(A[2]*c+A[3])
def test_gamma0N(N1,N2):
for N in range(N1,N2):
print "N=",N
G=MySubgroup(Gamma0(N))
G.test_cusp_data()
return 1
def is_integer(x):
if isinstance(x,(int,Integer)):
return True
elif isinstance(x,Rational):
if x.denominator()==1:
return True
elif isinstance(x,(float,RealNumber)):
if ceil(x)==floor(x):
return True
return False
def is_Hecke_triangle_group(G):
if not hasattr(G,"is_Hecke_triangle_group"):
return False
return G.is_Hecke_triangle_group()
| Python |
Subsets and Splits
SQL Console for ajibawa-2023/Python-Code-Large
Provides a useful breakdown of language distribution in the training data, showing which languages have the most samples and helping identify potential imbalances across different language groups.