Ticket #9223: trac_9223.patch

File trac_9223.patch, 16.8 KB (added by Alex Ghitza, 12 years ago)
  • sage/databases/cremona.py

    # HG changeset patch
    # User Alexandru Ghitza <aghitza@alum.mit.edu>
    # Date 1276334838 -36000
    # Node ID 8bf4016b44b9c7b3cddaedc187778d5e7dc2eb96
    # Parent  2cffe66bd64266c6a64d31ca37ad81d8d5390af8
    trac #9223: improve doctest coverage of databases/cremona.py
    
    diff -r 2cffe66bd642 -r 8bf4016b44b9 sage/databases/cremona.py
    a b  
    99included by default with Sage.  It contains Weierstrass
    1010equations, rank, and torsion for curves up to conductor 10000.
    1111
    12 The large database includes all curves of conductor up to 120,000
     12The large database includes all curves of conductor up to 130,000
    1313(!). It also includes data related to the BSD conjecture and
    1414modular degrees for all of these curves, and generators for the
    1515Mordell-Weil groups. To install it type the following in Sage:
    16 !sage -i database_cremona_ellcurve-2005.11.03
    17 
    18 The name of the database may change as it is updated. Type "!sage
    19 -optional" to see the latest package names.
     16!sage -i database_cremona_ellcurve
    2017"""
    2118
    2219#*****************************************************************************
     
    9390   
    9491    EXAMPLES::
    9592   
    96         False
    9793        sage: is_optimal_id('b1')
    9894        True
    9995        sage: is_optimal_id('bb1')
     
    347343       
    348344        INPUT:
    349345       
    350        
    351346        -  ``read_only`` - bool (default: True), if True, then
    352347           the database is read_only and changes cannot be committed to
    353348           disk.
     349
     350        TESTS::
     351
     352            sage: from sage.databases.cremona import LargeCremonaDatabase  # optional - database_cremona_ellcurves
     353            sage: c = LargeCremonaDatabase()                               # optional - database_cremona_ellcurves
     354            sage: c.read_only                                              # optional - database_cremona_ellcurves
     355            True
     356            sage: c.name                                                   # optional - database_cremona_ellcurves
     357            'cremona'
    354358        """
    355359        sage.databases.db.Database.__init__(self,
    356360             name="cremona", read_only=read_only)
     
    359363        """
    360364        Returns an iterator through all EllipticCurve objects in the
    361365        Cremona database.
     366
     367        TESTS::
     368
     369            sage: it = CremonaDatabase().__iter__()
     370            sage: it.next()
     371            Elliptic Curve defined by y^2 + y = x^3 - x^2 - 10*x - 20 over Rational Field
     372            sage: it.next()
     373            Elliptic Curve defined by y^2 + y = x^3 - x^2 - 7820*x - 263580 over Rational Field
    362374        """
    363         return self.iter(11, self.largest_conductor()+1)
     375        return self.iter([11, self.largest_conductor()+1])
    364376   
    365377    def __getitem__(self, N):
    366378        """
     
    370382       
    371383        INPUT:
    372384       
    373        
    374385        -  ``N`` - int or str
    375386       
    376        
    377387        OUTPUT: dict (if N is an int) or EllipticCurve (if N is a str)
     388
     389        TESTS::
     390
     391            sage: c = CremonaDatabase()
     392            sage: c[11]['a']['a2']
     393            [[0, -1, 1, -7820, -263580], 0, 1]
     394            sage: c['11a2']
     395            Elliptic Curve defined by y^2 + y = x^3 - x^2 - 7820*x - 263580 over Rational Field
    378396        """
    379397        if isinstance(N, str) and len(N) > 0:
    380398            if N[0].isalpha():
     
    397415
    398416    def __repr__(self):
    399417        """
    400         String representation of this database. OUTPUT: str
     418        String representation of this database.
     419       
     420        TESTS::
     421
     422            sage: from sage.databases.cremona import LargeCremonaDatabase  # optional - database_cremona_ellcurves
     423            sage: c = LargeCremonaDatabase()                               # optional - database_cremona_ellcurves
     424            sage: c.__repr__()                                             # optional - database_cremona_ellcurves
     425            "Cremona's database of elliptic curves"
    401426        """
    402427        return "Cremona's database of elliptic curves"
    403428
     
    406431        r"""
    407432        Return the allbsd table for conductor N. The entries are::
    408433       
    409                         [id, tamagawa_product, Omega_E, L, Reg_E, Sha_an(E)],
    410                    
     434            [id, tamagawa_product, Omega_E, L, Reg_E, Sha_an(E)],       
    411435       
    412436        where id is the isogeny class (letter) followed by a number, e.g.,
    413437        b3, and L is `L^r(E,1)/r!`, where E has rank r.
    414438       
    415439        INPUT:
    416440       
    417        
    418441        -  ``N`` - int, the conductor
    419442       
    420        
    421         OUTPUT: dict
     443        OUTPUT: dict containing the allbsd table for each isogeny class
     444        in conductor N
     445
     446        EXAMPLES::
     447
     448            sage: c = CremonaDatabase()
     449            sage: c.allbsd(12)
     450            {}
     451            sage: c.allbsd(19)['a3']      # optional - database_cremona_ellcurve
     452            ['1', '4.0792792004649324322', '0.45325324449610360358', '1', '1']
     453            sage: c.allbsd(12001)['a1']   # optional - database_cremona_ellcurve
     454            ['2', '3.2760813524872187381', '1.5491014309050596354', '0.23642597118795194508', '1']
    422455        """
    423456        try:
    424457            return self[int(N)][_map['allbsd']]
     
    432465       
    433466        INPUT:
    434467       
    435        
    436468        -  ``N`` - int, the conductor
    437469       
    438        
    439470        OUTPUT:
    440471       
    441        
    442472        -  ``dict`` - id:[ainvs, rank, tor], ...
     473
     474        EXAMPLES::
     475
     476            sage: c = CremonaDatabase()
     477            sage: c.allcurves(11)['a3']
     478            [[0, -1, 1, 0, 0], 0, 5]
     479            sage: c.allcurves(12)
     480            {}
     481            sage: c.allcurves(12001)['a1']   # optional - database_cremona_ellcurve
     482            [[1, 0, 0, -101, 382], 1, 1]
    443483        """
    444484        try:
    445485            return self[int(N)][_map['allcurves']]
     
    452492       
    453493        INPUT:
    454494       
    455        
    456495        -  ``N`` - int, the conductor
    457496       
    458        
    459497        OUTPUT:
    460498       
     499        -  ``dict`` - id:[points, ...], ...
    461500       
    462         -  ``dict`` - id:[points, ...], ...
     501        EXAMPLES::
     502
     503            sage: c = CremonaDatabase()
     504            sage: c.allgens(12)
     505            {}
     506            sage: c.allgens(1001)['a1']    # optional - database_cremona_ellcurve
     507            [[61, 181, 1]]
     508            sage: c.allgens(12001)['a1']   # optional - database_cremona_ellcurve
     509            [[7, 2, 1]]
    463510        """
    464511        try:
    465512            return self[int(N)][_map['allgens']]
     
    472519       
    473520        INPUT:
    474521       
    475        
    476522        -  ``N`` - int, the conductor
    477523       
    478        
    479524        OUTPUT:
    480525       
    481526        -  ``dict`` - id:[ainvs, rank, tor], ...
     
    492537       
    493538            sage: list(sorted(CremonaDatabase().curves(990).keys()))
    494539            ['a1', 'b1', 'c1', 'd1', 'e1', 'f1', 'g1', 'h3', 'i1', 'j1', 'k1', 'l1']
     540
     541        TESTS::
     542
     543            sage: c = CremonaDatabase()
     544            sage: c.curves(12001)['a1']   # optional - database_cremona_ellcurve
     545            [[1, 0, 0, -101, 382], 1, 1]
    495546        """
    496547        A = self.allcurves(N)
    497548        if N != 990:
     
    505556       
    506557        INPUT:
    507558       
    508        
    509559        -  ``N`` - int, the conductor
    510560       
    511        
    512561        OUTPUT:
    513562       
    514        
    515563        -  ``dict`` - id:degphi, ...
     564
     565        EXAMPLES::
     566
     567            sage: c = CremonaDatabase()
     568            sage: c.degphi(11)      # optional - database_cremona_ellcurve
     569            {'a1': 1}
     570            sage: c.degphi(12001)['c1']   # optional - database_cremona_ellcurve
     571            1640
    516572        """
    517         return self[int(N)][_map['degphi']]
     573        try:
     574            return self[int(N)][_map['degphi']]
     575        except KeyError:
     576            return {}
    518577
    519578    def elliptic_curve_from_ainvs(self, N, ainvs):
    520579        """
     
    524583       
    525584        INPUT:
    526585       
    527        
    528586        -  ``N`` - int
    529587       
    530588        -  ``ainvs`` - list (5-tuple of int's); the minimal
    531589           Weierstrass model for an elliptic curve of conductor N
    532590       
    533        
    534591        OUTPUT: EllipticCurve
     592
     593        EXAMPLES::
     594
     595            sage: c = CremonaDatabase()
     596            sage: c.elliptic_curve_from_ainvs(11, [0, -1, 1, -10, -20])
     597            Elliptic Curve defined by y^2 + y = x^3 - x^2 - 10*x - 20 over Rational Field
     598            sage: c.elliptic_curve_from_ainvs(12001, [1, 0, 0, -101, 382])  # optional - database_cremona_ellcurve
     599            Elliptic Curve defined by y^2 + x*y = x^3 - 101*x + 382 over Rational Field                         
    535600        """
    536601        for id, e in self.allcurves(N).iteritems():
    537602            if e[0] == ainvs:
     
    546611       
    547612        INPUT:
    548613       
    549        
    550614        -  ``label`` - str (Cremona label)
    551615       
    552        
    553616        OUTPUT: EllipticCurve
     617
     618        EXAMPLES::
     619
     620            sage: c = CremonaDatabase()
     621            sage: c.elliptic_curve('11a1')
     622            Elliptic Curve defined by y^2 + y = x^3 - x^2 - 10*x - 20 over Rational Field
     623            sage: c.elliptic_curve('12001a1')    # optional - database_cremona_ellcurve
     624            Elliptic Curve defined by y^2 + x*y = x^3 - 101*x + 382 over Rational Field
    554625        """
    555626        N, iso, num = parse_cremona_label(label)
    556627        v = self[N]
     
    599670       
    600671        INPUT:
    601672       
    602        
    603673        -  ``conductors`` - list or generator of ints
    604674       
    605        
    606675        OUTPUT: generator that iterates over EllipticCurve objects.
     676
     677        EXAMPLES::
     678
     679            sage: [e.cremona_label() for e in CremonaDatabase().iter([11..15])]
     680            ['11a1', '11a2', '11a3', '14a1', '14a2', '14a3', '14a4', '14a5',
     681             '14a6', '15a1', '15a2', '15a3', '15a4', '15a5', '15a6', '15a7', '15a8']
    607682        """
    608683        for N in conductors:
    609684            K = self.allcurves(N).keys()
     
    617692        elliptic curves in the database of given conductor as a list of
    618693        lists, one for each isogeny class. The curve with number 1 is
    619694        always listed first.
     695
     696        EXAMPLES::
     697
     698            sage: c = CremonaDatabase()
     699            sage: c.isogeny_classes(11)
     700            [[[[0, -1, 1, -10, -20], 0, 5],
     701             [[0, -1, 1, -7820, -263580], 0, 1],
     702             [[0, -1, 1, 0, 0], 0, 5]]]
     703            sage: c.isogeny_classes(12001)   # optional - database_cremona_ellcurve
     704            [[[[1, 0, 0, -101, 382], 1, 1]],
     705             [[[0, 0, 1, -247, 1494], 1, 1]],
     706             [[[0, 0, 1, -4, -18], 1, 1]],
     707             [[[0, 1, 1, -10, 18], 1, 1]]]
    620708        """
    621709        conductor=int(conductor)
    622710        classes = []
     
    641729       
    642730        -  ``label`` - string
    643731       
    644        
    645732        OUTPUT:
    646733       
    647734        -  ``list`` - list of EllipticCurve objects.
     735
     736        EXAMPLES::
     737
     738            sage: c = CremonaDatabase()
     739            sage: c.isogeny_class('11a1')
     740            [Elliptic Curve defined by y^2 + y = x^3 - x^2 - 10*x - 20 over Rational Field,
     741             Elliptic Curve defined by y^2 + y = x^3 - x^2 over Rational Field,
     742             Elliptic Curve defined by y^2 + y = x^3 - x^2 - 7820*x - 263580 over Rational Field]
     743            sage: c.isogeny_class('12001a1')   # optional - database_cremona_ellcurve
     744            [Elliptic Curve defined by y^2 + x*y = x^3 - 101*x + 382 over Rational Field]
    648745        """
    649746        conductor, iso, num = parse_cremona_label(label)
    650747        A = self.allcurves(conductor)
     
    699796        OUTPUT:
    700797       
    701798        - list of EllipticCurve objects.
     799
     800        EXAMPLES::
     801
     802            sage: CremonaDatabase().list([37])
     803            [Elliptic Curve defined by y^2 + y = x^3 - x over Rational Field,
     804             Elliptic Curve defined by y^2 + y = x^3 + x^2 - 23*x - 50 over Rational Field,
     805             Elliptic Curve defined by y^2 + y = x^3 + x^2 - 1873*x - 31833 over Rational Field,
     806             Elliptic Curve defined by y^2 + y = x^3 + x^2 - 3*x + 1 over Rational Field]
    702807        """
    703808        return list(self.iter(conductors))
    704809       
     
    735840       
    736841       
    737842        EXAMPLES::
    738        
    739             sage: CremonaDatabase().largest_conductor()   # random -- depends on size of installed database
    740             9999
     843
     844            sage: from sage.databases.cremona import LargeCremonaDatabase    # optional - database_cremona_ellcurve       
     845            sage: c = LargeCremonaDatabase()                                # optional - database_cremona_ellcurve       
     846            sage: c.largest_conductor()                                     # optional - database_cremona_ellcurve       
     847            130000
    741848        """
    742849        try:
    743850            return sage.databases.db.Database.__getitem__(self, 'largest_conductor')
     
    762869       
    763870        OUTPUT:
    764871       
    765        
    766872        -  ``int`` - smallest conductor
    767873       
    768        
    769874        EXAMPLES::
    770875       
    771876            sage: CremonaDatabase().smallest_conductor()
     
    779884       
    780885        OUTPUT:
    781886       
    782        
    783887        -  ``int`` - smallest cond
    784888       
    785889        -  ``int`` - largest conductor plus one
    786890       
    787        
    788891        EXAMPLES::
    789892       
    790             sage: CremonaDatabase().conductor_range()     # random -- depends on database installed
    791             (1, 10000)
     893            sage: from sage.databases.cremona import LargeCremonaDatabase    # optional - database_cremona_ellcurve
     894            sage: c = LargeCremonaDatabase()                                 # optional - database_cremona_ellcurve
     895            sage: c.conductor_range()                                        # optional - database_cremona_ellcurve
     896            (1, 130001)
    792897        """
    793898        return 1, self.largest_conductor()+1
    794899
     
    11041209    A mini version of the Cremona database that contains only the
    11051210    Weierstrass equations, rank and torsion of elliptic curves of
    11061211    conductor up to 10000 and nothing else.
     1212
     1213    TESTS::
     1214
     1215    Many of the following only work if the large Cremona database is
     1216    installed.  Given only the mini version, we expect them to fail
     1217    gracefully::
     1218
     1219        sage: from sage.databases.cremona import MiniCremonaDatabase
     1220        sage: c = MiniCremonaDatabase()
     1221        sage: c.allbsd(11)
     1222        {}
     1223        sage: c.allbsd(12001)
     1224        {}
     1225        sage: c.allcurves(12001)
     1226        {}
     1227        sage: c.allgens(11)
     1228        {}
     1229        sage: c.allgens(12001)
     1230        {}
     1231        sage: c.curves(12001)
     1232        {}
     1233        sage: c.degphi(11)
     1234        {}
     1235        sage: c.degphi(12001)
     1236        {}
     1237        sage: c.elliptic_curve('12001a1')
     1238        Traceback (most recent call last):
     1239        ...
     1240        RuntimeError: There is no elliptic curve with label 12001a1 in the default database; try installing the optional package database_cremona_ellcurve-20071019 which contains all curves of conductor up to 130000
     1241        sage: c.elliptic_curve_from_ainvs(12001, [1, 0, 0, -101, 382])
     1242        Traceback (most recent call last):
     1243        ...
     1244        RuntimeError: No elliptic curve of conductor N (=12001) and ainvs (=[1, 0, 0, -101, 382]) in the database.
     1245        sage: c.isogeny_class('12001a1')
     1246        []
     1247        sage: c.isogeny_classes(12001)
     1248        []
     1249        sage: c.number_of_curves(12001)
     1250        0
     1251        sage: c.number_of_isogeny_classes(12001)
     1252        0
    11071253    """
    11081254    def __init__(self, read_only=True):
    11091255        """
     
    11111257       
    11121258        INPUT:
    11131259       
    1114        
    11151260        -  ``read_only`` - bool (default: True), if True, then
    11161261           the database is read_only and changes cannot be committed to
    11171262           disk.
     1263
     1264        TESTS::
     1265
     1266            sage: from sage.databases.cremona import MiniCremonaDatabase
     1267            sage: c = MiniCremonaDatabase()
     1268            sage: c.read_only
     1269            True
     1270            sage: c.name
     1271            'cremona_mini'
     1272            sage: c.conductor_range()
     1273            (1, 10000)
     1274            sage: c.largest_conductor()
     1275            9999
     1276            sage: c.number_of_curves(0)
     1277            64687
     1278            sage: c.number_of_isogeny_classes(0)
     1279            38042
    11181280        """
    11191281        sage.databases.db.Database.__init__(self,
    11201282             name="cremona_mini", read_only=read_only)
     
    11251287        self._init_allcurves(ftpdata, 10000)
    11261288
    11271289    def __repr__(self):
     1290        """
     1291        Return a string description of this database.
     1292
     1293        TESTS::
     1294
     1295            sage: from sage.databases.cremona import MiniCremonaDatabase
     1296            sage: c = MiniCremonaDatabase()
     1297            sage: c.__repr__()
     1298            'A mini version of the Cremona database'
     1299        """
    11281300        return "A mini version of the Cremona database"
    11291301
    11301302
    11311303_db = None
    11321304def CremonaDatabase():
     1305    """
     1306    Initialize the large Cremona database, if available; otherwise initialize
     1307    the default mini Cremona database.
     1308
     1309    TESTS::
     1310
     1311        sage: c = CremonaDatabase()
     1312        sage: from sage.databases.cremona import LargeCremonaDatabase
     1313        sage: c is LargeCremonaDatabase()    # optional - database_cremona_ellcurve
     1314        True
     1315    """
    11331316    global _db
    11341317    if _db != None:
    11351318        return _db