summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorXavier Caruso <xavier.caruso@univ-rennes1.fr>2018-03-06 01:13:40 +0100
committerJulian Rüth <julian.rueth@fsfe.org>2018-03-06 01:13:40 +0100
commitb2b82e87e40f69b4f211598e82f6de2f647df9d7 (patch)
treeb80552b78f0e68826f7dfe020dd30e7ed8862d01
parentUpdated SageMath version to 8.2.beta7 (diff)
Lattice precision for p-adicsu/saraedum/lattice_precision
In several recent papers, David Roe, Tristan Vaccon, and Xavier Caruso explain that lattices allow a sharp track of precision. This approach is implemented here in a first experimental version. Co-authored-by: David Roe <roed.math@gmail.com> Co-authored-by: Julian Rüth <julian.rueth@fsfe.org>
-rw-r--r--src/doc/en/reference/references/index.rst7
-rw-r--r--src/sage/categories/pushout.py7
-rw-r--r--src/sage/rings/padics/all.py4
-rw-r--r--src/sage/rings/padics/factory.py651
-rw-r--r--src/sage/rings/padics/generic_nodes.py465
-rw-r--r--src/sage/rings/padics/lattice_precision.py2835
-rw-r--r--src/sage/rings/padics/local_generic.py79
-rw-r--r--src/sage/rings/padics/local_generic_element.pyx6
-rw-r--r--src/sage/rings/padics/misc.py4
-rw-r--r--src/sage/rings/padics/padic_base_generic.py40
-rw-r--r--src/sage/rings/padics/padic_base_leaves.py274
-rw-r--r--src/sage/rings/padics/padic_generic.py50
-rw-r--r--src/sage/rings/padics/padic_lattice_element.py1311
-rw-r--r--src/sage/rings/padics/padic_printing.pyx7
14 files changed, 5581 insertions, 159 deletions
diff --git a/src/doc/en/reference/references/index.rst b/src/doc/en/reference/references/index.rst
index 1cf229a..52190cf 100644
--- a/src/doc/en/reference/references/index.rst
+++ b/src/doc/en/reference/references/index.rst
@@ -673,6 +673,13 @@ REFERENCES:
.. [Crossproduct] Algebraic Properties of the Cross Product
:wikipedia:`Cross_product`
+.. [CRV2018] Xavier Caruso, David Roe and Tristan Vaccon.
+ *ZpL: a p-adic precision package*, (2018) :arxiv:`1802.08532`.
+
+.. [CRV2014] Xavier Caruso, David Roe and Tristan Vaccon.
+ *Tracking p-adic precision*,
+ LMS J. Comput. Math. **17** (2014), 274-294.
+
.. [CS1986] \J. Conway and N. Sloane. *Lexicographic codes:
error-correcting codes from game theory*, IEEE
Trans. Infor. Theory **32** (1986) 337-348.
diff --git a/src/sage/categories/pushout.py b/src/sage/categories/pushout.py
index 602117f..bccd0b5 100644
--- a/src/sage/categories/pushout.py
+++ b/src/sage/categories/pushout.py
@@ -2318,7 +2318,7 @@ class CompletionFunctor(ConstructionFunctor):
"""
rank = 4
_real_types = ['Interval', 'Ball', 'MPFR', 'RDF', 'RLF', 'RR']
- _dvr_types = [None, 'fixed-mod','floating-point','capped-abs','capped-rel','lazy']
+ _dvr_types = [None, 'fixed-mod', 'floating-point', 'capped-abs', 'capped-rel', 'lattice-cap', 'lattice-float']
def __init__(self, p, prec, extras=None):
"""
@@ -2329,14 +2329,15 @@ class CompletionFunctor(ConstructionFunctor):
- ``prec``: an integer, yielding the precision in bits. Note that
if ``p`` is prime then the ``prec`` is the *capped* precision,
while it is the *set* precision if ``p`` is ``+Infinity``.
+ In the ``lattice-cap`` precision case, ``prec`` will be a tuple instead.
- ``extras`` (optional dictionary): Information on how to print elements, etc.
If 'type' is given as a key, the corresponding value should be a string among the following:
- 'RDF', 'Interval', 'RLF', or 'RR' for completions at infinity
- - 'capped-rel', 'capped-abs', 'fixed-mod' or 'lazy' for completions at a finite place
- or ideal of a DVR.
+ - 'capped-rel', 'capped-abs', 'fixed-mod', 'lattice-cap' or 'lattice-float'
+ for completions at a finite place or ideal of a DVR.
TESTS::
diff --git a/src/sage/rings/padics/all.py b/src/sage/rings/padics/all.py
index 3e361a9..0c6d31d 100644
--- a/src/sage/rings/padics/all.py
+++ b/src/sage/rings/padics/all.py
@@ -1,7 +1,7 @@
from __future__ import absolute_import
from .generic_nodes import is_pAdicField, is_pAdicRing
-from .factory import Zp, Zq, Zp as pAdicRing, ZpCR, ZpCA, ZpFM, ZpFP, ZqCR, ZqCA, ZqFM, ZqFP #, ZpL, ZqL
-from .factory import Qp, Qq, Qp as pAdicField, QpCR, QpFP, QqCR, QqFP #, QpL, QqL
+from .factory import Zp, Zq, Zp as pAdicRing, ZpCR, ZpCA, ZpFM, ZpFP, ZpLC, ZpLF, ZqCR, ZqCA, ZqFM, ZqFP #, ZpL, ZqL
+from .factory import Qp, Qq, Qp as pAdicField, QpCR, QpFP, QpLC, QpLF, QqCR, QqFP #, QpL, QqL
from .factory import pAdicExtension
from .padic_generic import local_print_mode
from .pow_computer import PowComputer
diff --git a/src/sage/rings/padics/factory.py b/src/sage/rings/padics/factory.py
index 291172c..d3916b7 100644
--- a/src/sage/rings/padics/factory.py
+++ b/src/sage/rings/padics/factory.py
@@ -1,4 +1,4 @@
-"""
+r"""
Factory
This file contains the constructor classes and functions for `p`-adic rings and fields.
@@ -6,6 +6,15 @@ This file contains the constructor classes and functions for `p`-adic rings and
AUTHORS:
- David Roe
+
+TESTS::
+
+ sage: R = ZpLC(2)
+ doctest:...: FutureWarning: This class/method/function is marked as experimental. It, its functionality or its interface might change without a formal deprecation.
+ See http://trac.sagemath.org/23505 for details.
+ sage: R = ZpLF(2)
+ sage: R = QpLC(2)
+ sage: R = QpLF(2)
"""
#*****************************************************************************
@@ -20,8 +29,11 @@ AUTHORS:
#*****************************************************************************
from __future__ import absolute_import, print_function
+from sage.misc.superseded import experimental
+
from sage.structure.factory import UniqueFactory
from sage.rings.integer import Integer
+from sage.rings.infinity import Infinity
from sage.structure.factorization import Factorization
from sage.rings.integer_ring import ZZ
from sage.rings.polynomial.polynomial_ring_constructor import PolynomialRing
@@ -31,8 +43,10 @@ from .padic_base_leaves import (pAdicRingCappedRelative,
pAdicRingCappedAbsolute,
pAdicRingFixedMod,
pAdicRingFloatingPoint,
+ pAdicRingLattice,
pAdicFieldCappedRelative,
- pAdicFieldFloatingPoint)
+ pAdicFieldFloatingPoint,
+ pAdicFieldLattice)
from . import padic_printing
######################################################
@@ -47,35 +61,30 @@ from functools import reduce
ext_table = {}
ext_table['e', pAdicFieldCappedRelative] = EisensteinExtensionFieldCappedRelative
-#ext_table['e', pAdicFieldLazy] = EisensteinExtensionFieldLazy
ext_table['e', pAdicRingCappedAbsolute] = EisensteinExtensionRingCappedAbsolute
ext_table['e', pAdicRingCappedRelative] = EisensteinExtensionRingCappedRelative
ext_table['e', pAdicRingFixedMod] = EisensteinExtensionRingFixedMod
#ext_table['e', pAdicRingFloatingPoint] = EisensteinExtensionRingFloatingPoint
#ext_table['e', pAdicFieldFloatingPoint] = EisensteinExtensionFieldFloatingPoint
-#ext_table['e', pAdicRingLazy] = EisensteinExtensionRingLazy
#ext_table['p', pAdicFieldCappedRelative] = pAdicGeneralExtensionFieldCappedRelative
-#ext_table['p', pAdicFieldLazy] = pAdicGeneralExtensionFieldLazy
#ext_table['p', pAdicRingCappedAbsolute] = pAdicGeneralExtensionRingCappedAbsolute
#ext_table['p', pAdicRingCappedRelative] = pAdicGeneralExtensionRingCappedRelative
#ext_table['p', pAdicRingFixedMod] = pAdicGeneralExtensionRingFixedMod
-#ext_table['p', pAdicRingLazy] = pAdicGeneralExtensionRingLazy
ext_table['u', pAdicFieldCappedRelative] = UnramifiedExtensionFieldCappedRelative
-#ext_table['u', pAdicFieldLazy] = UnramifiedExtensionFieldLazy
ext_table['u', pAdicRingCappedAbsolute] = UnramifiedExtensionRingCappedAbsolute
ext_table['u', pAdicRingCappedRelative] = UnramifiedExtensionRingCappedRelative
ext_table['u', pAdicRingFixedMod] = UnramifiedExtensionRingFixedMod
ext_table['u', pAdicRingFloatingPoint] = UnramifiedExtensionRingFloatingPoint
ext_table['u', pAdicFieldFloatingPoint] = UnramifiedExtensionFieldFloatingPoint
-#ext_table['u', pAdicRingLazy] = UnramifiedExtensionRingLazy
def _default_show_prec(type, print_mode):
- """
+ r"""
Returns the default show_prec value for a given type and printing mode.
INPUT:
- - ``type`` -- a string: ``'capped-rel'``, ``'capped-abs'``, ``'fixed-mod'`` or ``'floating-point'``
+ - ``type`` -- a string: ``'capped-rel'``, ``'capped-abs'``, ``'fixed-mod'``, ``'floating-point'``,
+ ``'lattice-cap'`` or ``'lattice-float'``
- ``print_mode`` -- a string: ``'series'``, ``'terse'``, ``'val-unit'``, ``'digits'``, ``'bars'``
EXAMPLES::
@@ -95,8 +104,8 @@ def _default_show_prec(type, print_mode):
else:
return False
-def get_key_base(p, prec, type, print_mode, names, ram_name, print_pos, print_sep, print_alphabet, print_max_terms, show_prec, check, valid_non_lazy_types):
- """
+def get_key_base(p, prec, type, print_mode, names, ram_name, print_pos, print_sep, print_alphabet, print_max_terms, show_prec, check, valid_types, label=None):
+ r"""
This implements create_key for Zp and Qp: moving it here prevents code duplication.
It fills in unspecified values and checks for contradictions in the input. It also standardizes irrelevant options so that duplicate parents are not created.
@@ -105,19 +114,61 @@ def get_key_base(p, prec, type, print_mode, names, ram_name, print_pos, print_se
sage: from sage.rings.padics.factory import get_key_base
sage: get_key_base(11, 5, 'capped-rel', None, None, None, None, ':', None, None, False, True, ['capped-rel'])
- (11, 5, 'capped-rel', 'series', '11', True, '|', (), -1, False)
+ (11, 5, 'capped-rel', 'series', '11', True, '|', (), -1, False, None)
sage: get_key_base(12, 5, 'capped-rel', 'digits', None, None, None, None, None, None, True, False, ['capped-rel'])
- (12, 5, 'capped-rel', 'digits', '12', True, '|', ('0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B'), -1, True)
+ (12,
+ 5,
+ 'capped-rel',
+ 'digits',
+ '12',
+ True,
+ '|',
+ ('0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B'),
+ -1,
+ True,
+ None)
"""
- if prec is None:
- prec = DEFAULT_PREC
if check:
if not isinstance(p, Integer):
p = Integer(p)
- if not isinstance(prec, Integer):
- prec = Integer(prec)
if not p.is_prime():
raise ValueError("p must be prime")
+ if type == 'lattice-cap':
+ relative_cap = absolute_cap = None
+ if prec is not None:
+ try:
+ relative_cap, absolute_cap = prec
+ except (ValueError, TypeError):
+ relative_cap = prec
+ if relative_cap is not None:
+ if relative_cap is not Infinity:
+ try:
+ relative_cap = Integer(relative_cap)
+ except TypeError:
+ raise TypeError("relative cap must be either a positive integer or infinity")
+ if relative_cap <= 0:
+ raise ValueError("relative cap must be positive")
+ if absolute_cap is not None:
+ try:
+ absolute_cap = Integer(absolute_cap)
+ except TypeError:
+ raise TypeError("absolute cap must be an integer")
+ if relative_cap is None and absolute_cap is None:
+ relative_cap = DEFAULT_PREC
+ absolute_cap = 2 * DEFAULT_PREC
+ elif relative_cap is None:
+ relative_cap = Infinity
+ elif absolute_cap is None:
+ absolute_cap = 2 * relative_cap
+ prec = (relative_cap, absolute_cap)
+ else:
+ if prec is not None:
+ prec = Integer(prec)
+ if prec is None:
+ if type == 'lattice-cap':
+ prec = (DEFAULT_PREC, 2*DEFAULT_PREC)
+ else:
+ prec = DEFAULT_PREC
print_ram_name = ram_name
if isinstance(print_mode, dict):
if 'pos' in print_mode:
@@ -185,11 +236,10 @@ def get_key_base(p, prec, type, print_mode, names, ram_name, print_pos, print_se
name = str(names)
if show_prec is None:
show_prec = _default_show_prec(type, print_mode)
- if type in valid_non_lazy_types:
- key = (p, prec, type, print_mode, name, print_pos, print_sep, tuple(print_alphabet), print_max_terms, show_prec)
+ if type in valid_types:
+ key = (p, prec, type, print_mode, name, print_pos, print_sep, tuple(print_alphabet), print_max_terms, show_prec, label)
else:
- print(type)
- raise ValueError("type must be %s"%(", ".join(valid_non_lazy_types)))
+ raise ValueError("type must be %s"%(", ".join(valid_types)))
return key
#######################################################################################################
@@ -197,7 +247,7 @@ def get_key_base(p, prec, type, print_mode, names, ram_name, print_pos, print_se
# p-Adic Fields
# Qp -- base field
# Qq -- unramified extension field of Qp
-# QpCR, QpL, QqCR, QqL -- shortcuts for capped relative and lazy versions of Qp and Qq
+# QpCR, QpLC, QpLF, QqCR -- shortcuts for capped relative and lattice versions of Qp and Qq
#
#######################################################################################################
@@ -205,7 +255,7 @@ def get_key_base(p, prec, type, print_mode, names, ram_name, print_pos, print_se
padic_field_cache = {}
DEFAULT_PREC = Integer(20)
class Qp_class(UniqueFactory):
- """
+ r"""
A creation function for `p`-adic fields.
INPUT:
@@ -213,12 +263,15 @@ class Qp_class(UniqueFactory):
- ``p`` -- integer: the `p` in `\mathbb{Q}_p`
- ``prec`` -- integer (default: ``20``) the precision cap of the field.
- Individual elements keep track of their own precision. See
- TYPES and PRECISION below.
+ In the lattice capped case, ``prec`` can either be a
+ pair (``relative_cap``, ``absolute_cap``) or an integer
+ (understood at relative cap).
+ Except in the floating point case, individual elements keep track of
+ their own precision. See TYPES and PRECISION below.
- ``type`` -- string (default: ``'capped-rel'``) Valid types are
- ``'capped-rel'``, ``'floating-point'`` and ``'lazy'`` (though ``'lazy'`` currently
- doesn't work). See TYPES and PRECISION below
+ ``'capped-rel'``, ``'floating-point'``, ``'lattice-cap'``, ``'lattice-float'``.
+ See TYPES and PRECISION below
- ``print_mode`` -- string (default: ``None``). Valid modes are 'series',
'val-unit', 'terse', 'digits', and 'bars'. See PRINTING below
@@ -248,6 +301,9 @@ class Qp_class(UniqueFactory):
Non-prime input may cause seg-faults (but can also be useful for
base n expansions for example)
+ - ``label`` -- string (default ``None``) used for lattice precision to
+ create parents with different lattices.
+
OUTPUT:
- The corresponding `p`-adic field.
@@ -270,7 +326,7 @@ class Qp_class(UniqueFactory):
22
There are three types of `p`-adic fields: capped relative fields,
- floating point fields and lazy fields.
+ floating point fields and lattice precision fields.
In the capped relative case, the relative precision of an element
is restricted to be at most a certain value, specified at the
@@ -291,8 +347,9 @@ class Qp_class(UniqueFactory):
precision, but the relative precision of elements is truncated
during arithmetic to the precision cap of the field.
- The lazy case will eventually support elements that can increase
- their precision upon request. It is not currently implemented.
+ In the lattice case, precision on elements is tracked by a global
+ lattice that is updated after every operation, yielding better
+ precision behavior at the cost of higher memory and runtime usage.
PRINTING:
@@ -430,9 +487,9 @@ class Qp_class(UniqueFactory):
'...444444444444444341.33'
Observe that the significant 0's are printed even if they are
- located in front of the number. On the contrary, unknown digits
+ located in front of the number. On the contrary, unknown digits
located after the comma appears as question marks.
- The precision can therefore be read in this mode as well.
+ The precision can therefore be read in this mode as well.
Here are more examples::
sage: p = 7
@@ -537,8 +594,9 @@ class Qp_class(UniqueFactory):
"""
def create_key(self, p, prec = None, type = 'capped-rel', print_mode = None,
names = None, ram_name = None, print_pos = None,
- print_sep = None, print_alphabet = None, print_max_terms = None, show_prec=None, check = True):
- """
+ print_sep = None, print_alphabet = None, print_max_terms = None, show_prec = None, check = True,
+ label = None): # specific to Lattice precision
+ r"""
Creates a key from input parameters for ``Qp``.
See the documentation for ``Qp`` for more information.
@@ -546,7 +604,7 @@ class Qp_class(UniqueFactory):
TESTS::
sage: Qp.create_key(5,40)
- (5, 40, 'capped-rel', 'series', '5', True, '|', (), -1, True)
+ (5, 40, 'capped-rel', 'series', '5', True, '|', (), -1, True, None)
"""
if isinstance(names, (int, Integer)):
# old pickle; names is what used to be halt.
@@ -556,10 +614,12 @@ class Qp_class(UniqueFactory):
print_alphabet = print_max_terms
print_max_terms = check
check = True
- return get_key_base(p, prec, type, print_mode, names, ram_name, print_pos, print_sep, print_alphabet, print_max_terms, show_prec, check, ['capped-rel', 'floating-point'])
+ if label is not None and type not in ['lattice-cap','lattice-float']:
+ raise ValueError("label keyword only supported for lattice precision")
+ return get_key_base(p, prec, type, print_mode, names, ram_name, print_pos, print_sep, print_alphabet, print_max_terms, show_prec, check, ['capped-rel', 'floating-point', 'lattice-cap', 'lattice-float'], label)
def create_object(self, version, key):
- """
+ r"""
Creates an object using a given key.
See the documentation for ``Qp`` for more information.
@@ -575,11 +635,9 @@ class Qp_class(UniqueFactory):
elif version[0] < 8:
p, prec, type, print_mode, name, print_pos, print_sep, print_alphabet, print_max_terms = key
show_prec = None
+ label = None
else:
- p, prec, type, print_mode, name, print_pos, print_sep, print_alphabet, print_max_terms, show_prec = key
- if isinstance(type, Integer):
- # lazy
- raise NotImplementedError("lazy p-adics need more work. Sorry.")
+ p, prec, type, print_mode, name, print_pos, print_sep, print_alphabet, print_max_terms, show_prec, label = key
if (version[0] < 4 or (len(version) > 1 and version[0] == 4 and version[1] < 5) or
(len(version) > 2 and version[0] == 4 and version[1] == 5 and version[2] < 3)):
# keys changed in order to reduce irrelevant duplications: e.g. two Qps with print_mode 'series'
@@ -592,7 +650,7 @@ class Qp_class(UniqueFactory):
return obj
except KeyError:
pass
- p, prec, type, print_mode, name, print_pos, print_sep, print_alphabet, print_max_terms, show_prec = key
+ p, prec, type, print_mode, name, print_pos, print_sep, print_alphabet, print_max_terms, show_prec, label = key
if type == 'capped-rel':
if print_mode == 'terse':
@@ -608,6 +666,14 @@ class Qp_class(UniqueFactory):
else:
return pAdicFieldFloatingPoint(p, prec, {'mode': print_mode, 'pos': print_pos, 'sep': print_sep, 'alphabet': print_alphabet,
'ram_name': name, 'max_ram_terms': print_max_terms, 'show_prec': show_prec}, name)
+ elif type[:8] == 'lattice-':
+ subtype = type[8:]
+ if print_mode == 'terse':
+ return pAdicFieldLattice(p, prec, subtype, {'mode': print_mode, 'pos': print_pos, 'sep': print_sep, 'alphabet': print_alphabet,
+ 'ram_name': name, 'max_terse_terms': print_max_terms, 'show_prec': show_prec}, name, label)
+ else:
+ return pAdicFieldLattice(p, prec, subtype, {'mode': print_mode, 'pos': print_pos, 'sep': print_sep, 'alphabet': print_alphabet,
+ 'ram_name': name, 'max_ram_terms': print_max_terms, 'show_prec': show_prec}, name, label)
else:
raise ValueError("unexpected type")
@@ -622,7 +688,7 @@ def Qq(q, prec = None, type = 'capped-rel', modulus = None, names=None,
print_mode=None, ram_name = None, res_name = None, print_pos = None,
print_sep = None, print_max_ram_terms = None,
print_max_unram_terms = None, print_max_terse_terms = None, show_prec=None, check = True, implementation = 'FLINT'):
- """
+ r"""
Given a prime power `q = p^n`, return the unique unramified
extension of `\mathbb{Q}_p` of degree `n`.
@@ -639,8 +705,8 @@ def Qq(q, prec = None, type = 'capped-rel', modulus = None, names=None,
TYPES and PRECISION below.
- ``type`` -- string (default: ``'capped-rel'``) Valid types are
- ``'capped-rel'``, ``'floating-point'`` and ``'lazy'`` (though ``'lazy'``
- doesn't currently work). See TYPES and PRECISION below
+ ``'capped-rel'``, ``'floating-point'``, ``'lattice-cap'``
+ and ``'lattice-float'``. See TYPES and PRECISION below
- ``modulus`` -- polynomial (default ``None``) A polynomial defining an
unramified extension of `\mathbb{Q}_p`. See MODULUS below.
@@ -703,8 +769,8 @@ def Qq(q, prec = None, type = 'capped-rel', modulus = None, names=None,
sage: b.precision_absolute()
22
- There are three types of unramified `p`-adic fields: capped relative
- fields, floating point fields and lazy fields.
+ There are two types of unramified `p`-adic fields: capped relative
+ fields, floating point fields.
In the capped relative case, the relative precision of an element
is restricted to be at most a certain value, specified at the
@@ -725,9 +791,6 @@ def Qq(q, prec = None, type = 'capped-rel', modulus = None, names=None,
precision, but the relative precision of elements is truncated
during arithmetic to the precision cap of the field.
- The lazy case will eventually support elements that can increase
- their precision upon request. It is not currently implemented.
-
MODULUS:
The modulus needs to define an unramified extension of `\mathbb{Q}_p`: when it
@@ -1154,7 +1217,7 @@ def Qq(q, prec = None, type = 'capped-rel', modulus = None, names=None,
######################################################
def QpCR(p, prec = None, *args, **kwds):
- """
+ r"""
A shortcut function to create capped relative `p`-adic fields.
Same functionality as ``Qp``. See documentation for ``Qp`` for a
@@ -1168,7 +1231,7 @@ def QpCR(p, prec = None, *args, **kwds):
return Qp(p, prec, 'capped-rel', *args, **kwds)
def QpFP(p, prec = None, *args, **kwds):
- """
+ r"""
A shortcut function to create floating point `p`-adic fields.
Same functionality as ``Qp``. See documentation for ``Qp`` for a
@@ -1182,7 +1245,7 @@ def QpFP(p, prec = None, *args, **kwds):
return Qp(p, prec, 'floating-point', *args, **kwds)
def QqCR(q, prec = None, *args, **kwds):
- """
+ r"""
A shortcut function to create capped relative unramified `p`-adic
fields.
@@ -1197,7 +1260,7 @@ def QqCR(q, prec = None, *args, **kwds):
return Qq(q, prec, 'capped-rel', *args, **kwds)
def QqFP(q, prec = None, *args, **kwds):
- """
+ r"""
A shortcut function to create floating point unramified `p`-adic
fields.
@@ -1211,17 +1274,49 @@ def QqFP(q, prec = None, *args, **kwds):
"""
return Qq(q, prec, 'floating-point', *args, **kwds)
+@experimental(23505)
+def QpLC(p, prec = None, *args, **kwds):
+ r"""
+ A shortcut function to create `p`-adic fields with lattice precision.
+
+ See :func:`ZpLC` for more information about this model of precision.
+
+ EXAMPLES::
+
+ sage: R = QpLC(2)
+ sage: R
+ 2-adic Field with lattice-cap precision
+
+ """
+ return Qp(p, prec, 'lattice-cap', *args, **kwds)
+
+@experimental(23505)
+def QpLF(p, prec = None, *args, **kwds):
+ r"""
+ A shortcut function to create `p`-adic fields with lattice precision.
+
+ See :func:`ZpLC` for more information about this model of precision.
+
+ EXAMPLES::
+
+ sage: R = QpLF(2)
+ sage: R
+ 2-adic Field with lattice-float precision
+ """
+ return Qp(p, prec, 'lattice-float', *args, **kwds)
+
+
#######################################################################################################
#
# p-Adic Rings
# Zp -- base rings
# Zq -- unramified extension ring of Zp
-# ZpCR, ZpCA, ZpFM, ZpL, ZqCR, ZqCA, ZqFM, ZqL -- shortcuts for capped relative and lazy versions of Zp and Zq
+# ZpCR, ZpCA, ZpFM, ZpL, ZqCR, ZqCA, ZqFM, ZqL -- shortcuts for precision-type versions of Zp and Zq
#
#######################################################################################################
class Zp_class(UniqueFactory):
- """
+ r"""
A creation function for `p`-adic rings.