diff --git a/src/sage/algebras/askey_wilson.py b/src/sage/algebras/askey_wilson.py index db81fa63051..db0bca83696 100644 --- a/src/sage/algebras/askey_wilson.py +++ b/src/sage/algebras/askey_wilson.py @@ -800,10 +800,10 @@ def __init__(self, domain, on_generators, position=0, codomain=None, INPUT: - ``domain`` -- an Askey-Wilson algebra - - ``on_generators`` -- a list of length 6 corresponding to + - ``on_generators`` -- list of length 6 corresponding to the images of the generators - ``codomain`` -- (optional) the codomain - - ``position`` -- (default: 0) integer + - ``position`` -- integer (default: 0) - ``category`` -- (optional) category OUTPUT: module morphism diff --git a/src/sage/algebras/clifford_algebra.py b/src/sage/algebras/clifford_algebra.py index 54eb15c01ad..c1df4488018 100644 --- a/src/sage/algebras/clifford_algebra.py +++ b/src/sage/algebras/clifford_algebra.py @@ -1412,7 +1412,7 @@ class ExteriorAlgebra(CliffordAlgebra): - ``R`` -- the base ring, *or* the free module whose exterior algebra is to be computed - - ``names`` -- a list of strings to name the generators of the + - ``names`` -- list of strings to name the generators of the exterior algebra; this list can either have one entry only (in which case the generators will be called ``e + '0'``, ``e + '1'``, ..., ``e + 'n-1'``, with ``e`` being said entry), or have ``n`` entries diff --git a/src/sage/algebras/cluster_algebra.py b/src/sage/algebras/cluster_algebra.py index e93ec042f6a..f81ca3747fa 100644 --- a/src/sage/algebras/cluster_algebra.py +++ b/src/sage/algebras/cluster_algebra.py @@ -902,7 +902,7 @@ def c_vector(self, j) -> tuple: INPUT: - - ``j`` -- an integer in ``range(self.parent().rank())``; + - ``j`` -- integer in ``range(self.parent().rank())``; the index of the c-vector to return EXAMPLES:: @@ -953,7 +953,7 @@ def g_vector(self, j) -> tuple: INPUT: - - ``j`` -- an integer in ``range(self.parent().rank())``; + - ``j`` -- integer in ``range(self.parent().rank())``; the index of the g-vector to return EXAMPLES:: @@ -984,7 +984,7 @@ def F_polynomial(self, j): INPUT: - - ``j`` -- an integer in ``range(self.parent().rank())``; + - ``j`` -- integer in ``range(self.parent().rank())``; the index of the F-polynomial to return EXAMPLES:: @@ -1015,7 +1015,7 @@ def cluster_variable(self, j): INPUT: - - ``j`` -- an integer in ``range(self.parent().rank())``; + - ``j`` -- integer in ``range(self.parent().rank())``; the index of the cluster variable to return EXAMPLES:: @@ -1226,13 +1226,13 @@ class ClusterAlgebra(Parent, UniqueRepresentation): - ``cluster_variable_prefix`` -- string (default ``'x'``); it needs to be a valid variable name - - ``cluster_variable_names`` -- a list of strings; each element needs + - ``cluster_variable_names`` -- list of strings; each element needs to be a valid variable name; supersedes ``cluster_variable_prefix`` - ``coefficient_prefix`` -- string (default ``'y'``); it needs to be a valid variable name. - - ``coefficient_names`` -- a list of strings; each element needs + - ``coefficient_names`` -- list of strings; each element needs to be a valid variable name; supersedes ``cluster_variable_prefix`` - ``principal_coefficients`` -- boolean (default ``False``); supersedes any @@ -2112,7 +2112,7 @@ def coefficient(self, j): INPUT: - - ``j`` -- an integer in ``range(self.parent().rank())``; + - ``j`` -- integer in ``range(self.parent().rank())``; the index of the coefficient to return EXAMPLES:: @@ -2168,7 +2168,7 @@ def initial_cluster_variable(self, j): INPUT: - - ``j`` -- an integer in ``range(self.parent().rank())``; + - ``j`` -- integer in ``range(self.parent().rank())``; the index of the cluster variable to return EXAMPLES:: diff --git a/src/sage/algebras/commutative_dga.py b/src/sage/algebras/commutative_dga.py index f5c1f2a287f..82634588e68 100644 --- a/src/sage/algebras/commutative_dga.py +++ b/src/sage/algebras/commutative_dga.py @@ -114,7 +114,7 @@ def sorting_keys(element): INPUT: - - ``element`` -- A CohomologyClass + - ``element`` -- a CohomologyClass OUTPUT: its coordinates in the corresponding ``cohomology_raw`` quotient vector space @@ -3498,7 +3498,7 @@ def GradedCommutativeAlgebra(ring, names=None, degrees=None, max_degree=None, - ``ring`` -- a graded commutative algebra - - ``relations`` -- a list or tuple of elements of ``ring`` + - ``relations`` -- list or tuple of elements of ``ring`` EXAMPLES: @@ -4222,7 +4222,7 @@ def total_degree(deg): INPUT: - - ``deg`` -- an element of a free abelian group. + - ``deg`` -- an element of a free abelian group In fact, ``deg`` could be an integer, a Python int, a list, a tuple, a vector, etc. This function returns the sum of the diff --git a/src/sage/algebras/finite_dimensional_algebras/finite_dimensional_algebra.py b/src/sage/algebras/finite_dimensional_algebras/finite_dimensional_algebra.py index b6239c88b85..2e2df68f219 100644 --- a/src/sage/algebras/finite_dimensional_algebras/finite_dimensional_algebra.py +++ b/src/sage/algebras/finite_dimensional_algebras/finite_dimensional_algebra.py @@ -36,7 +36,7 @@ class FiniteDimensionalAlgebra(UniqueRepresentation, Algebra): - ``k`` -- a field - - ``table`` -- a list of matrices + - ``table`` -- list of matrices - ``names`` -- string (default: ``'e'``); names for the basis elements diff --git a/src/sage/algebras/finite_gca.py b/src/sage/algebras/finite_gca.py index a8702c3a47d..148c1eb0db3 100644 --- a/src/sage/algebras/finite_gca.py +++ b/src/sage/algebras/finite_gca.py @@ -79,7 +79,7 @@ class FiniteGCAlgebra(CombinatorialFreeModule): of the generators; if omitted, each generator is given degree 1, and if both ``names`` and ``degrees`` are omitted, an error is raised. - - ``max_degree`` -- the maximal degree of the graded algebra. + - ``max_degree`` -- the maximal degree of the graded algebra - ``mul_symbol`` -- (optional) symbol used for multiplication. If omitted, the string "*" is used. - ``mul_latex_symbol`` -- (optional) latex symbol used for multiplication. diff --git a/src/sage/algebras/free_algebra.py b/src/sage/algebras/free_algebra.py index 00b0dfdafa7..acdc3181143 100644 --- a/src/sage/algebras/free_algebra.py +++ b/src/sage/algebras/free_algebra.py @@ -411,7 +411,7 @@ class FreeAlgebra_generic(CombinatorialFreeModule): INPUT: - ``R`` -- a ring - - ``n`` -- an integer + - ``n`` -- integer - ``names`` -- the generator names - ``degrees`` -- (optional) a tuple or list specifying the degrees of all the generators, if omitted, the algebra is not diff --git a/src/sage/algebras/fusion_rings/f_matrix.py b/src/sage/algebras/fusion_rings/f_matrix.py index 15e8e63405f..6a104e161b8 100644 --- a/src/sage/algebras/fusion_rings/f_matrix.py +++ b/src/sage/algebras/fusion_rings/f_matrix.py @@ -1227,14 +1227,11 @@ def start_worker_pool(self, processes=None): INPUT: - - ``processes`` -- an integer indicating the number of workers - in the pool; if left unspecified, the number of workers is + - ``processes`` -- integer indicating the number of workers + in the pool; if left unspecified, the number of workers equals the number of processors available - OUTPUT: - - This method returns a boolean indicating whether a worker pool - was successfully initialized. + OUTPUT: boolean; whether a worker pool was successfully initialized EXAMPLES:: @@ -1399,7 +1396,7 @@ def get_orthogonality_constraints(self, output=True): INPUT: - - ``output`` -- a boolean + - ``output`` -- boolean OUTPUT: @@ -1621,7 +1618,7 @@ def equations_graph(self, eqns=None): INPUT: - - ``eqns`` -- a list of polynomials + - ``eqns`` -- list of polynomials Each polynomial is either an object in the ring returned by :meth:`get_poly_ring` or it is a tuple of pairs representing @@ -1783,8 +1780,8 @@ def _get_component_variety(self, var, eqns): INPUT: - - ``var`` -- a list of variable indices - - ``eqns`` -- a list of polynomial equations in the internal + - ``var`` -- list of variable indices + - ``eqns`` -- list of polynomial equations in the internal tuple of pairs representation EXAMPLES:: diff --git a/src/sage/algebras/fusion_rings/shm_managers.pyx b/src/sage/algebras/fusion_rings/shm_managers.pyx index 40d2eb9c805..9b8fd913b86 100644 --- a/src/sage/algebras/fusion_rings/shm_managers.pyx +++ b/src/sage/algebras/fusion_rings/shm_managers.pyx @@ -54,8 +54,8 @@ cdef class KSHandler: - ``n_slots`` -- the total number of F-symbols - ``field`` -- F-matrix's base cyclotomic field - - ``use_mp`` -- a boolean indicating whether to construct a shared - memory block to back ``self``. + - ``use_mp`` -- boolean indicating whether to construct a shared + memory block to back ``self`` - ``init_data`` -- a dictionary or :class:`KSHandler` object containing known squares for initialization, e.g., from a solver checkpoint - ``name`` -- the name of a shared memory object (used by child processes @@ -398,7 +398,7 @@ cdef class FvarsHandler: of ``FusionRing`` elements - ``init_data`` -- a dictionary or :class:`FvarsHandler` object containing known squares for initialization, e.g., from a solver checkpoint - - ``use_mp`` -- an integer indicating the number of child processes + - ``use_mp`` -- integer indicating the number of child processes used for multiprocessing; if running serially, use 0. - ``pids_name`` -- the name of a ``ShareableList`` contaning the process ``pid``'s for every process in the pool (including the diff --git a/src/sage/algebras/hecke_algebras/cubic_hecke_algebra.py b/src/sage/algebras/hecke_algebras/cubic_hecke_algebra.py index fc8c8f9001a..faa4ac5ebb2 100644 --- a/src/sage/algebras/hecke_algebras/cubic_hecke_algebra.py +++ b/src/sage/algebras/hecke_algebras/cubic_hecke_algebra.py @@ -314,7 +314,7 @@ def matrix(self, subdivide=False, representation_type=None, original=False): INPUT: - - ``subdivide`` -- boolean (default: ``False``): this boolean is passed + - ``subdivide`` -- boolean (default: ``False``); this boolean is passed to the block_matrix function - ``representation_type`` -- instance of enum :class:`RepresentationType`; this can be obtained by the attribute :attr:`CubicHeckeAlgebra.repr_type` @@ -327,7 +327,7 @@ def matrix(self, subdivide=False, representation_type=None, original=False): - default: ``SplitIrredChevie`` taken if GAP3 and CHEVIE are installed on the system, otherwise the default will be ``SplitIrredMarin`` - - ``original`` -- boolean (default: ``False``): if set to true the base + - ``original`` -- boolean (default: ``False``); if set to ``True`` the base ring of the matrix will be the generic base_ring resp. generic extension ring (for the split versions) of the parent of ``self`` diff --git a/src/sage/algebras/letterplace/free_algebra_letterplace.pyx b/src/sage/algebras/letterplace/free_algebra_letterplace.pyx index 4d2289d6e49..e92afb882e5 100644 --- a/src/sage/algebras/letterplace/free_algebra_letterplace.pyx +++ b/src/sage/algebras/letterplace/free_algebra_letterplace.pyx @@ -650,8 +650,8 @@ cdef class FreeAlgebra_letterplace(Parent): INPUT: - - ``g`` -- a list of elements of this free algebra. - - ``d`` -- an integer. + - ``g`` -- list of elements of this free algebra + - ``d`` -- integer OUTPUT: diff --git a/src/sage/algebras/lie_algebras/lie_algebra.py b/src/sage/algebras/lie_algebras/lie_algebra.py index 760bb7f3b91..08b7311320a 100644 --- a/src/sage/algebras/lie_algebras/lie_algebra.py +++ b/src/sage/algebras/lie_algebras/lie_algebra.py @@ -708,10 +708,10 @@ def _from_dict(self, d, coerce=False, remove_zeros=True): index of a basis element and each ``coeff`` belongs to the coefficient ring ``self.base_ring()`` - - ``coerce`` -- a boolean (default: ``False``), whether to coerce the + - ``coerce`` -- boolean (default: ``False``); whether to coerce the ``coeff`` to the coefficient ring - - ``remove_zeros`` -- a boolean (default: ``True``), if some + - ``remove_zeros`` -- boolean (default: ``True``); if some ``coeff`` may be zero and should therefore be removed EXAMPLES:: diff --git a/src/sage/algebras/lie_algebras/nilpotent_lie_algebra.py b/src/sage/algebras/lie_algebras/nilpotent_lie_algebra.py index 8c25193c38f..c48138c1a9d 100644 --- a/src/sage/algebras/lie_algebras/nilpotent_lie_algebra.py +++ b/src/sage/algebras/lie_algebras/nilpotent_lie_algebra.py @@ -174,8 +174,8 @@ class FreeNilpotentLieAlgebra(NilpotentLieAlgebra_dense): INPUT: - ``R`` -- the base ring - - ``r`` -- an integer; the number of generators - - ``s`` -- an integer; the nilpotency step of the algebra + - ``r`` -- integer; the number of generators + - ``s`` -- integer; the nilpotency step of the algebra - ``names`` -- (optional) a string or a list of strings used to name the basis elements; if ``names`` is a string, then names for the basis will be autogenerated as determined by the ``naming`` parameter diff --git a/src/sage/algebras/lie_algebras/subalgebra.py b/src/sage/algebras/lie_algebras/subalgebra.py index e65a8440b8f..12702e76b3a 100644 --- a/src/sage/algebras/lie_algebras/subalgebra.py +++ b/src/sage/algebras/lie_algebras/subalgebra.py @@ -35,7 +35,7 @@ class LieSubalgebra_finite_dimensional_with_basis(Parent, UniqueRepresentation): INPUT: - ``ambient`` -- the Lie algebra containing the subalgebra - - ``gens`` -- a list of generators of the subalgebra + - ``gens`` -- list of generators of the subalgebra - ``ideal`` -- boolean (default: ``False``); if ``True``, then ``gens`` is interpreted as the generating set of an ideal instead of a subalgebra - ``order`` -- (optional) the key used to sort the indices of ``ambient`` diff --git a/src/sage/algebras/lie_conformal_algebras/abelian_lie_conformal_algebra.py b/src/sage/algebras/lie_conformal_algebras/abelian_lie_conformal_algebra.py index b70bc9cbbaf..79426633a53 100644 --- a/src/sage/algebras/lie_conformal_algebras/abelian_lie_conformal_algebra.py +++ b/src/sage/algebras/lie_conformal_algebras/abelian_lie_conformal_algebra.py @@ -33,11 +33,10 @@ class AbelianLieConformalAlgebra(GradedLieConformalAlgebra): - ``R`` -- a commutative ring; the base ring of this Lie conformal algebra - - ``ngens`` -- a positive integer (default: ``1``); the number + - ``ngens`` -- a positive integer (default: `1`); the number of generators of this Lie conformal algebra - - ``weights`` -- a list of positive rational numbers (default: - ``1`` for each - generator); the weights of the generators. The resulting + - ``weights`` -- list of positive rational numbers (default: + `1` for each generator); the weights of the generators. The resulting Lie conformal algebra is `H`-graded. - ``parity`` -- ``None`` or a list of ``0`` or ``1`` (default: ``None``); The parity of the generators. If not ``None`` the diff --git a/src/sage/algebras/lie_conformal_algebras/affine_lie_conformal_algebra.py b/src/sage/algebras/lie_conformal_algebras/affine_lie_conformal_algebra.py index 8c6671aa1a0..d18817735cd 100644 --- a/src/sage/algebras/lie_conformal_algebras/affine_lie_conformal_algebra.py +++ b/src/sage/algebras/lie_conformal_algebras/affine_lie_conformal_algebra.py @@ -48,8 +48,8 @@ class AffineLieConformalAlgebra(GradedLieConformalAlgebra): root_system.cartan_type>`; the Cartan Type for the corresponding finite dimensional Lie algebra. It must correspond to a simple finite dimensional Lie algebra. - - ``names`` -- a list of ``str`` or ``None`` (default: ``None``) - ; alternative names for the generators. If ``None`` the + - ``names`` -- list of ``str`` or ``None`` (default: ``None``); + alternative names for the generators. If ``None`` the generators are labeled by the corresponding root and coroot vectors. - ``prefix`` -- a ``str``; parameter passed to diff --git a/src/sage/algebras/lie_conformal_algebras/bosonic_ghosts_lie_conformal_algebra.py b/src/sage/algebras/lie_conformal_algebras/bosonic_ghosts_lie_conformal_algebra.py index 5f88bcded94..2284fa9e1be 100644 --- a/src/sage/algebras/lie_conformal_algebras/bosonic_ghosts_lie_conformal_algebra.py +++ b/src/sage/algebras/lie_conformal_algebras/bosonic_ghosts_lie_conformal_algebra.py @@ -41,11 +41,11 @@ class BosonicGhostsLieConformalAlgebra(GradedLieConformalAlgebra): INPUT: - - ``R`` -- a commutative ring. + - ``R`` -- a commutative ring - ``ngens`` -- an even positive Integer (default: ``2``); the number of non-central generators of this Lie conformal algebra. - - ``names`` -- a list of ``str``; alternative names for the + - ``names`` -- list of ``str``; alternative names for the generators - ``index_set`` -- an enumerated set; An indexing set for the generators. diff --git a/src/sage/algebras/lie_conformal_algebras/free_bosons_lie_conformal_algebra.py b/src/sage/algebras/lie_conformal_algebras/free_bosons_lie_conformal_algebra.py index 677e9ea585d..7baab87be28 100644 --- a/src/sage/algebras/lie_conformal_algebras/free_bosons_lie_conformal_algebra.py +++ b/src/sage/algebras/lie_conformal_algebras/free_bosons_lie_conformal_algebra.py @@ -43,8 +43,8 @@ class FreeBosonsLieConformalAlgebra(GradedLieConformalAlgebra): INPUT: - - ``R`` -- a commutative ring. - - ``ngens`` -- a positive Integer (default ``1``); the number of + - ``R`` -- a commutative ring + - ``ngens`` -- a positive Integer (default `1`); the number of non-central generators of this Lie conformal algebra. - ``gram_matrix``: a symmetric square matrix with coefficients in ``R`` (default: ``identity_matrix(ngens)``); the Gram diff --git a/src/sage/algebras/lie_conformal_algebras/lie_conformal_algebra.py b/src/sage/algebras/lie_conformal_algebras/lie_conformal_algebra.py index 29c6ddb98f1..f4da3629d06 100644 --- a/src/sage/algebras/lie_conformal_algebras/lie_conformal_algebra.py +++ b/src/sage/algebras/lie_conformal_algebras/lie_conformal_algebra.py @@ -249,13 +249,13 @@ class LieConformalAlgebra(UniqueRepresentation, Parent): In addition we accept the following keywords: - - ``graded`` -- a boolean (default: ``False``); + - ``graded`` -- boolean (default: ``False``); if ``True``, the returned algebra is H-Graded. If ``weights`` is not specified, all non-central generators are assigned degree `1`. This keyword is ignored if ``weights`` is specified - - ``super`` -- a boolean (default: ``False``); + - ``super`` -- boolean (default: ``False``); if ``True``, the returned algebra is a super Lie conformal algebra even if all generators are even. If ``parity`` is not specified, all generators are diff --git a/src/sage/algebras/lie_conformal_algebras/lie_conformal_algebra_with_structure_coefs.py b/src/sage/algebras/lie_conformal_algebras/lie_conformal_algebra_with_structure_coefs.py index 25b688b19ff..18cb2ef0d1b 100644 --- a/src/sage/algebras/lie_conformal_algebras/lie_conformal_algebra_with_structure_coefs.py +++ b/src/sage/algebras/lie_conformal_algebras/lie_conformal_algebra_with_structure_coefs.py @@ -39,7 +39,7 @@ class LieConformalAlgebraWithStructureCoefficients( conformal algebra. Behaviour is undefined if it is not a field of characteristic zero. - - ``s_coeff`` -- Dictionary (Default: ``None``); + - ``s_coeff`` -- dictionary (Default: ``None``); a dictionary containing the `\lambda` brackets of the generators of this Lie conformal algebra. The family encodes a dictionary whose keys diff --git a/src/sage/algebras/lie_conformal_algebras/weyl_lie_conformal_algebra.py b/src/sage/algebras/lie_conformal_algebras/weyl_lie_conformal_algebra.py index 3c319db7ca3..03bc5bec8f9 100644 --- a/src/sage/algebras/lie_conformal_algebras/weyl_lie_conformal_algebra.py +++ b/src/sage/algebras/lie_conformal_algebras/weyl_lie_conformal_algebra.py @@ -52,7 +52,7 @@ class WeylLieConformalAlgebra(LieConformalAlgebraWithStructureCoefficients): of non-central generators of this Lie conformal algebra. - ``gram_matrix``: a matrix (default: ``None``); A non-singular skew-symmetric square matrix with coefficients in `R`. - - ``names`` -- a list or tuple of ``str``; alternative names + - ``names`` -- list or tuple of ``str``; alternative names for the generators - ``index_set`` -- an enumerated set; alternative indexing set for the generators diff --git a/src/sage/algebras/quantum_groups/fock_space.py b/src/sage/algebras/quantum_groups/fock_space.py index aff82cd445f..534d68b9f62 100644 --- a/src/sage/algebras/quantum_groups/fock_space.py +++ b/src/sage/algebras/quantum_groups/fock_space.py @@ -759,7 +759,7 @@ def e(self, *data): INPUT: - - ``*data`` -- a list of indices or pairs `(i, p)` + - ``*data`` -- list of indices or pairs `(i, p)` EXAMPLES:: @@ -855,7 +855,7 @@ def f(self, *data): INPUT: - - ``*data`` -- a list of indices or pairs `(i, p)` + - ``*data`` -- list of indices or pairs `(i, p)` EXAMPLES:: diff --git a/src/sage/algebras/quatalg/quaternion_algebra.py b/src/sage/algebras/quatalg/quaternion_algebra.py index b7bdb80fca9..7905090d194 100644 --- a/src/sage/algebras/quatalg/quaternion_algebra.py +++ b/src/sage/algebras/quatalg/quaternion_algebra.py @@ -1346,7 +1346,7 @@ def ideal(self, gens, left_order=None, right_order=None, check=True, **kwds): INPUT: - - ``gens`` -- a list of elements of this quaternion order + - ``gens`` -- list of elements of this quaternion order - ``check`` -- boolean (default: ``True``) @@ -1725,7 +1725,7 @@ def gen(self, n): INPUT: - - ``n`` -- an integer between 0 and 3, inclusive. + - ``n`` -- integer between 0 and 3, inclusive EXAMPLES:: @@ -2072,7 +2072,7 @@ def left_ideal(self, gens, check=True, *, is_basis=False): INPUT: - - ``gens`` -- a list of elements of this quaternion order + - ``gens`` -- list of elements of this quaternion order - ``check`` -- boolean (default: ``True``) @@ -2115,7 +2115,7 @@ def right_ideal(self, gens, check=True, *, is_basis=False): INPUT: - - ``gens`` -- a list of elements of this quaternion order + - ``gens`` -- list of elements of this quaternion order - ``check`` -- boolean (default: ``True``) @@ -3352,7 +3352,7 @@ def multiply_by_conjugate(self, J): INPUT: - - ``J`` -- a quaternion ideal. + - ``J`` -- a quaternion ideal OUTPUT: a quaternionic fractional ideal @@ -3575,7 +3575,7 @@ def is_equivalent(self, J, B=10, certificate=False, side=None): - ``certificate`` -- if ``True`` returns an element alpha such that alpha*J = I or J*alpha = I for right and left ideals respectively - - ``side`` -- If ``'left'`` performs left equivalence test. If ``'right' + - ``side`` -- if ``'left'`` performs left equivalence test. If ``'right' ``or ``None`` performs right ideal equivalence test OUTPUT: bool, or (bool, alpha) if ``certificate`` is ``True`` @@ -4112,8 +4112,8 @@ def normalize_basis_at_p(e, p, B=QuaternionAlgebraElement_abstract.pair): INPUT: - - ``e`` -- list; basis of a `\ZZ` module. - WARNING: will be modified! + - ``e`` -- list; basis of a `\ZZ` module + (WARNING: will be modified!) - ``p`` -- prime for at which the basis should be normalized diff --git a/src/sage/algebras/quatalg/quaternion_algebra_cython.pyx b/src/sage/algebras/quatalg/quaternion_algebra_cython.pyx index b645d7280b2..2b9b230242c 100644 --- a/src/sage/algebras/quatalg/quaternion_algebra_cython.pyx +++ b/src/sage/algebras/quatalg/quaternion_algebra_cython.pyx @@ -51,7 +51,7 @@ def integral_matrix_and_denom_from_rational_quaternions(v, reverse=False): INPUT: - - ``v`` -- a list of quaternions in a rational quaternion algebra + - ``v`` -- list of quaternions in a rational quaternion algebra - ``reverse`` -- whether order of the coordinates as well as the order of the list ``v`` should be reversed @@ -131,7 +131,7 @@ def rational_matrix_from_rational_quaternions(v, reverse=False): INPUT: - - ``v`` -- a list of quaternions in a rational quaternion algebra + - ``v`` -- list of quaternions in a rational quaternion algebra - ``reverse`` -- whether order of the coordinates as well as the order of the list ``v`` should be reversed diff --git a/src/sage/algebras/shuffle_algebra.py b/src/sage/algebras/shuffle_algebra.py index 2db55513d66..5f9bb2f21fd 100644 --- a/src/sage/algebras/shuffle_algebra.py +++ b/src/sage/algebras/shuffle_algebra.py @@ -241,7 +241,7 @@ def product_on_basis(self, w1, w2): INPUT: - - ``w1``, ``w2`` -- Basis elements + - ``w1``, ``w2`` -- basis elements EXAMPLES:: @@ -285,7 +285,7 @@ def gen(self, i): INPUT: - - ``i`` -- an integer + - ``i`` -- integer EXAMPLES:: diff --git a/src/sage/algebras/steenrod/steenrod_algebra.py b/src/sage/algebras/steenrod/steenrod_algebra.py index 86a59d4632b..6bea7b763a8 100644 --- a/src/sage/algebras/steenrod/steenrod_algebra.py +++ b/src/sage/algebras/steenrod/steenrod_algebra.py @@ -818,7 +818,7 @@ def _repr_term(self, t): INPUT: - - ``t`` -- tuple, representing basis element in the current basis. + - ``t`` -- tuple, representing basis element in the current basis OUTPUT: string @@ -909,7 +909,7 @@ def _latex_term(self, t): INPUT: - - ``t`` -- tuple, representing basis element in the current basis. + - ``t`` -- tuple, representing basis element in the current basis OUTPUT: string @@ -1563,7 +1563,7 @@ def _milnor_on_basis(self, t): INPUT: - - ``t`` -- tuple, representing basis element in the current basis. + - ``t`` -- tuple, representing basis element in the current basis OUTPUT: element of the Steenrod algebra with the Milnor basis @@ -1742,7 +1742,7 @@ def _change_basis_on_basis(self, t, basis='milnor'): INPUT: - - ``t`` -- tuple, representing basis element in the current basis. + - ``t`` -- tuple, representing basis element in the current basis - ``basis`` -- string, the basis to which to convert, optional (default 'milnor') @@ -1824,7 +1824,7 @@ def _change_basis(self, x, basis='milnor'): INPUT: - - ``x`` -- an element of this algebra. + - ``x`` -- an element of this algebra - ``basis`` -- string, the basis to which to convert, optional (default 'milnor') @@ -1860,7 +1860,7 @@ def degree_on_basis(self, t): INPUT: - - ``t`` -- tuple, representing basis element in the current basis. + - ``t`` -- tuple, representing basis element in the current basis OUTPUT: integer, the degree of the corresponding element @@ -3287,7 +3287,7 @@ def change_basis(self, basis='milnor'): INPUT: - - ``basis`` -- string, basis in which to work. + - ``basis`` -- string, basis in which to work OUTPUT: representation of self in given basis diff --git a/src/sage/algebras/weyl_algebra.py b/src/sage/algebras/weyl_algebra.py index 0fb9e52e284..7c12d6122b8 100644 --- a/src/sage/algebras/weyl_algebra.py +++ b/src/sage/algebras/weyl_algebra.py @@ -43,7 +43,7 @@ def repr_from_monomials(monomials, term_repr, use_latex=False) -> str: INPUT: - - ``monomials`` -- a list of pairs ``[m, c]`` where ``m`` is the index + - ``monomials`` -- list of pairs ``[m, c]`` where ``m`` is the index and ``c`` is the coefficient - ``term_repr`` -- a function which returns a string given an index (can be ``repr`` or ``latex``, for example) diff --git a/src/sage/arith/functions.pyx b/src/sage/arith/functions.pyx index 6e8f3db88a5..53d25f7ffbf 100644 --- a/src/sage/arith/functions.pyx +++ b/src/sage/arith/functions.pyx @@ -30,7 +30,7 @@ def lcm(a, b=None): - ``a``, ``b`` -- two elements of a ring with lcm or - - ``a`` -- a list, tuple or iterable of elements of a ring with lcm + - ``a`` -- list, tuple or iterable of elements of a ring with lcm OUTPUT: diff --git a/src/sage/arith/misc.py b/src/sage/arith/misc.py index 035440fd06c..a39541a49fc 100644 --- a/src/sage/arith/misc.py +++ b/src/sage/arith/misc.py @@ -72,10 +72,10 @@ def algdep(z, degree, known_bits=None, use_bits=None, known_digits=None, - ``degree`` -- an integer - - ``height_bound`` -- an integer (default: ``None``) specifying the maximum + - ``height_bound`` -- an integer (default: ``None``); specifying the maximum coefficient size for the returned polynomial - - ``proof`` -- a boolean (default: ``False``), requires height_bound to be set + - ``proof`` -- boolean (default: ``False``); requires height_bound to be set EXAMPLES:: @@ -284,7 +284,7 @@ def bernoulli(n, algorithm='default', num_threads=1): INPUT: - - ``n`` -- an integer + - ``n`` -- integer - ``algorithm``: - ``'default'`` -- use 'flint' for n <= 20000, then 'arb' for n <= 300000 @@ -581,7 +581,7 @@ def is_pseudoprime(n): INPUT: - - ``n`` -- an integer + - ``n`` -- integer .. note:: @@ -617,7 +617,7 @@ def is_prime_power(n, get_data=False): INPUT: - - ``n`` -- an integer + - ``n`` -- integer - ``get_data`` -- if set to ``True``, return a pair ``(p,k)`` such that this integer equals ``p^k`` instead of ``True`` or ``(self,0)`` instead of @@ -814,12 +814,12 @@ def prime_powers(start, stop=None): INPUT: - - ``start`` -- an integer. If two inputs are given, a lower bound + - ``start`` -- integer; if two inputs are given, a lower bound for the returned set of prime powers. If this is the only input, then it is an upper bound. - - ``stop`` -- an integer (default: ``None``). An upper bound for the - returned set of prime powers. + - ``stop`` -- integer (default: ``None``); an upper bound for the + returned set of prime powers OUTPUT: @@ -1034,12 +1034,12 @@ def primes(start=2, stop=None, proof=None): INPUT: - - ``start`` -- an integer (default: 2) lower bound for the primes + - ``start`` -- integer (default: 2); lower bound for the primes - - ``stop`` -- an integer (or infinity) upper (open) bound for the + - ``stop`` -- integer (or infinity); upper (open) bound for the primes - - ``proof`` -- bool or ``None`` (default: ``None``) If ``True``, the + - ``proof`` -- bool or ``None`` (default: ``None``); If ``True``, the function yields only proven primes. If ``False``, the function uses a pseudo-primality test, which is much faster for really big numbers but does not provide a proof of primality. If ``None``, uses the global @@ -1389,14 +1389,14 @@ def random_prime(n, proof=None, lbound=2): INPUT: - - ``n`` -- an integer `\geq 2`. + - ``n`` -- integer `\geq 2` - - ``proof`` -- bool or ``None`` (default: ``None``) If ``False``, the function uses a - pseudo-primality test, which is much faster for really big numbers but - does not provide a proof of primality. If ``None``, uses the global default - (see :mod:`sage.structure.proof.proof`) + - ``proof`` -- bool or ``None`` (default: ``None``); if ``False``, the function uses a + pseudo-primality test, which is much faster for really big numbers but + does not provide a proof of primality. If ``None``, uses the global default + (see :mod:`sage.structure.proof.proof`) - - ``lbound`` -- an integer `\geq 2`, lower bound for the chosen primes + - ``lbound`` -- integer; `\geq 2`, lower bound for the chosen primes EXAMPLES:: @@ -1736,7 +1736,7 @@ def gcd(a, b=None, **kwargs): - ``a``, ``b`` -- two elements of a ring with gcd or - - ``a`` -- a list or tuple of elements of a ring with gcd + - ``a`` -- list or tuple of elements of a ring with gcd Additional keyword arguments are passed to the respectively called methods. @@ -2090,7 +2090,7 @@ def xkcd(n=""): INPUT: - - ``n`` -- an integer (optional) + - ``n`` -- integer (optional) OUTPUT: a fragment of HTML @@ -2319,7 +2319,7 @@ def rational_reconstruction(a, m, algorithm='fast'): INPUT: - - ``a`` -- an integer + - ``a`` -- integer - ``m`` -- a modulus @@ -2841,9 +2841,9 @@ def prime_to_m_part(n, m): INPUT: - - ``n`` -- Integer (nonzero) + - ``n`` -- integer (nonzero) - - ``m`` -- Integer + - ``m`` -- integer OUTPUT: integer @@ -2884,7 +2884,7 @@ def is_square(n, root=False): INPUT: - - ``n`` -- an integer + - ``n`` -- integer - ``root`` -- whether or not to also return a square root (default: ``False``) @@ -3175,7 +3175,7 @@ def carmichael_lambda(n): INPUT: - - ``n`` -- a positive integer. + - ``n`` -- a positive integer OUTPUT: the Carmichael function of ``n`` @@ -5343,7 +5343,7 @@ def two_squares(n): INPUT: - - ``n`` -- an integer + - ``n`` -- integer OUTPUT: a tuple `(a,b)` of nonnegative integers such that `n = a^2 + b^2` with `a <= b`. @@ -5465,7 +5465,7 @@ def three_squares(n): INPUT: - - ``n`` -- an integer + - ``n`` -- integer OUTPUT: a tuple `(a,b,c)` of nonnegative integers such that `n = a^2 + b^2 + c^2` with `a <= b <= c`. @@ -5610,7 +5610,7 @@ def four_squares(n): INPUT: - - ``n`` -- an integer + - ``n`` -- integer OUTPUT: a tuple `(a,b,c,d)` of nonnegative integers such that `n = a^2 + b^2 + c^2 + d^2` with `a <= b <= c <= d`. @@ -5688,7 +5688,7 @@ def sum_of_k_squares(k, n): - ``k`` -- a nonnegative integer - - ``n`` -- an integer + - ``n`` -- integer OUTPUT: a tuple `(x_1, ..., x_k)` of nonnegative integers such that their squares sum to `n`. @@ -6013,7 +6013,7 @@ def fundamental_discriminant(D): INPUT: - - ``D`` -- an integer + - ``D`` -- integer OUTPUT: an integer, the fundamental discriminant diff --git a/src/sage/arith/multi_modular.pyx b/src/sage/arith/multi_modular.pyx index 036576cec37..aee5b8bd321 100644 --- a/src/sage/arith/multi_modular.pyx +++ b/src/sage/arith/multi_modular.pyx @@ -134,10 +134,8 @@ cdef class MultiModularBasis_base(): (their product will be at least 2*val) as list, tuple or generator a list of prime moduli to start with - - ``l_bound`` -- an integer: lower bound for the random primes - (default: 2^10) - - ``u_bound`` -- an integer: upper bound for the random primes - (default: 2^15) + - ``l_bound`` -- integer (default: 2^10); lower bound for the random primes + - ``u_bound`` -- integer (default: 2^15); upper bound for the random primes EXAMPLES:: @@ -647,7 +645,7 @@ cdef class MultiModularBasis_base(): INPUT: - - ``b`` -- a list of length at most self.n + - ``b`` -- list of length at most self.n OUTPUT: diff --git a/src/sage/calculus/desolvers.py b/src/sage/calculus/desolvers.py index 09903edf95f..9344c7f8865 100644 --- a/src/sage/calculus/desolvers.py +++ b/src/sage/calculus/desolvers.py @@ -47,7 +47,7 @@ - :func:`desolve_mintides` -- Numerical solution of a system of 1st order ODEs via the Taylor series integrator method implemented in TIDES. -- :func:`desolve_tides_mpfr` -- Arbitrary precision Taylor series integrator implemented in TIDES. +- :func:`desolve_tides_mpfr` -- Arbitrary precision Taylor series integrator implemented in TIDES AUTHORS: @@ -674,7 +674,7 @@ def desolve_laplace(de, dvar, ics=None, ivar=None): `x`), which must be specified if there is more than one independent variable in the equation. - - ``ics`` -- a list of numbers representing initial conditions, (e.g. + - ``ics`` -- list of numbers representing initial conditions, (e.g. ``f(0)=1``, ``f'(0)=2`` corresponds to ``ics = [0,1,2]``) OUTPUT: solution of the ODE as symbolic expression @@ -1508,7 +1508,7 @@ def desolve_odeint(des, ics, times, dvars, ivar=None, compute_jac=False, args=() - ``dvars`` -- dependent variables. ATTENTION: the order must be the same as in ``des``, that means: ``d(dvars[i])/dt=des[i]`` - - ``ivar`` -- independent variable, optional. + - ``ivar`` -- independent variable, optional - ``compute_jac`` -- boolean. If True, the Jacobian of ``des`` is computed and used during the integration of stiff systems. Default value is False. @@ -1697,17 +1697,17 @@ def desolve_mintides(f, ics, initial, final, delta, tolrel=1e-16, tolabs=1e-16): - ``f`` -- symbolic function. Its first argument will be the independent variable. Its output should be de derivatives of the dependent variables. - - ``ics`` -- a list or tuple with the initial conditions. + - ``ics`` -- list or tuple with the initial conditions - - ``initial`` -- the starting value for the independent variable. + - ``initial`` -- the starting value for the independent variable - - ``final`` -- the final value for the independent value. + - ``final`` -- the final value for the independent value - - ``delta`` -- the size of the steps in the output. + - ``delta`` -- the size of the steps in the output - - ``tolrel`` -- the relative tolerance for the method. + - ``tolrel`` -- the relative tolerance for the method - - ``tolabs`` -- the absolute tolerance for the method. + - ``tolabs`` -- the absolute tolerance for the method OUTPUT: list with the positions of the IVP @@ -1786,19 +1786,19 @@ def desolve_tides_mpfr(f, ics, initial, final, delta, tolrel=1e-16, tolabs=1e-16 - ``f`` -- symbolic function. Its first argument will be the independent variable. Its output should be de derivatives of the dependent variables. - - ``ics`` -- a list or tuple with the initial conditions. + - ``ics`` -- list or tuple with the initial conditions - - ``initial`` -- the starting value for the independent variable. + - ``initial`` -- the starting value for the independent variable - - ``final`` -- the final value for the independent value. + - ``final`` -- the final value for the independent value - - ``delta`` -- the size of the steps in the output. + - ``delta`` -- the size of the steps in the output - - ``tolrel`` -- the relative tolerance for the method. + - ``tolrel`` -- the relative tolerance for the method - - ``tolabs`` -- the absolute tolerance for the method. + - ``tolabs`` -- the absolute tolerance for the method - - ``digits`` -- the digits of precision used in the computation. + - ``digits`` -- the digits of precision used in the computation OUTPUT: list with the positions of the IVP diff --git a/src/sage/calculus/interpolation.pyx b/src/sage/calculus/interpolation.pyx index c2acab64fd9..550e5ef258c 100644 --- a/src/sage/calculus/interpolation.pyx +++ b/src/sage/calculus/interpolation.pyx @@ -309,7 +309,7 @@ cdef class Spline: INPUT: - - ``x`` -- value at which to evaluate the derivative. + - ``x`` -- value at which to evaluate the derivative - ``order`` (default: 1) -- order of the derivative. Must be 1 or 2. @@ -352,9 +352,9 @@ cdef class Spline: INPUT: - - ``a`` -- Lower bound for the integral. + - ``a`` -- lower bound for the integral - - ``b`` -- Upper bound for the integral. + - ``b`` -- upper bound for the integral EXAMPLES: diff --git a/src/sage/calculus/riemann.pyx b/src/sage/calculus/riemann.pyx index bd9a7b00c2b..928f5f9d9b5 100644 --- a/src/sage/calculus/riemann.pyx +++ b/src/sage/calculus/riemann.pyx @@ -86,14 +86,14 @@ cdef class Riemann_Map: INPUT: - - ``fs`` -- A list of the boundaries of the region, given as + - ``fs`` -- list of the boundaries of the region, given as complex-valued functions with domain `0` to `2*pi`. Note that the outer boundary must be parameterized counter clockwise (i.e. ``e^(I*t)``) while the inner boundaries must be clockwise (i.e. ``e^(-I*t)``). - - ``fprimes`` -- A list of the derivatives of the boundary functions. - Must be in the same order as ``fs``. + - ``fprimes`` -- list of the derivatives of the boundary functions + (Must be in the same order as ``fs``) - ``a`` -- Complex, the center of the Riemann map. Will be mapped to the origin of the unit disc. Note that ``a`` MUST be within @@ -1071,7 +1071,7 @@ cdef comp_pt(clist, loop=True): INPUT: - - ``clist`` -- a list of complex numbers. + - ``clist`` -- list of complex numbers - ``loop`` -- boolean (default: ``True``); controls whether or not the first point will be added as the last to plot a closed circle. @@ -1155,15 +1155,15 @@ cpdef complex_to_spiderweb(np.ndarray[COMPLEX_T, ndim = 2] z_values, INPUT: - - ``z_values`` -- A grid of complex numbers, as a list of lists. + - ``z_values`` -- A grid of complex numbers, as a list of lists - - ``dr`` -- grid of floats, the r derivative of ``z_values``. + - ``dr`` -- grid of floats, the r derivative of ``z_values`` Used to determine precision. - - ``dtheta`` -- grid of floats, the theta derivative of ``z_values``. + - ``dtheta`` -- grid of floats, the theta derivative of ``z_values`` Used to determine precision. - - ``spokes`` -- integer; the number of equally spaced radial lines to plot. + - ``spokes`` -- integer; the number of equally spaced radial lines to plot - ``circles`` -- integer; the number of equally spaced circles about the center to plot. @@ -1273,7 +1273,7 @@ cpdef complex_to_rgb(np.ndarray[COMPLEX_T, ndim = 2] z_values): INPUT: - - ``z_values`` -- A Numpy array of complex numbers. + - ``z_values`` -- Numpy array of complex numbers OUTPUT: @@ -1381,7 +1381,7 @@ cpdef analytic_boundary(FLOAT_T t, int n, FLOAT_T epsilon): - ``t`` -- The boundary parameter, from 0 to 2*pi - - ``n`` -- integer; the number of terms to include. + - ``n`` -- integer; the number of terms to include 10 is fairly accurate, 20 is very accurate. - ``epsilon`` -- float; the skew of the ellipse (0 is circular) @@ -1431,9 +1431,9 @@ cpdef cauchy_kernel(t, args): - ``epsilon`` -- float; the skew of the ellipse (0 is circular) - - ``z`` -- complex; the point to be mapped. + - ``z`` -- complex; the point to be mapped - - ``n`` -- integer; the number of terms to include. + - ``n`` -- integer; the number of terms to include 10 is fairly accurate, 20 is very accurate. - ``part`` -- will return the real ('r'), imaginary ('i') or @@ -1473,10 +1473,10 @@ cpdef analytic_interior(COMPLEX_T z, int n, FLOAT_T epsilon): INPUT: - - ``z`` -- complex; the point to be mapped. + - ``z`` -- complex; the point to be mapped - - ``n`` -- integer; the number of terms to include. - 10 is fairly accurate, 20 is very accurate. + - ``n`` -- integer; the number of terms to include + (10 is fairly accurate, 20 is very accurate) TESTS: diff --git a/src/sage/calculus/transforms/fft.pyx b/src/sage/calculus/transforms/fft.pyx index 9dd91f717a1..b03abe1c081 100644 --- a/src/sage/calculus/transforms/fft.pyx +++ b/src/sage/calculus/transforms/fft.pyx @@ -32,8 +32,8 @@ def FastFourierTransform(size, base_ring=None): INPUT: - - ``size`` -- The size of the array - - ``base_ring`` -- Unused (2013-03) + - ``size`` -- the size of the array + - ``base_ring`` -- unused (2013-03) EXAMPLES: @@ -95,8 +95,8 @@ cdef class FastFourierTransform_complex(FastFourierTransform_base): INPUT: - - ``n`` -- An integer, the size of the array - - ``stride`` -- The stride to be applied when manipulating the array. + - ``n`` -- integer, the size of the array + - ``stride`` -- the stride to be applied when manipulating the array EXAMPLES:: @@ -146,8 +146,8 @@ cdef class FastFourierTransform_complex(FastFourierTransform_base): INPUT: - - ``i`` -- An integer, the index. - - ``xy`` -- An object to store as `i`-th element of the array ``self[i]``. + - ``i`` -- integer; the index + - ``xy`` -- an object to store as `i`-th element of the array ``self[i]`` EXAMPLES:: @@ -228,9 +228,9 @@ cdef class FastFourierTransform_complex(FastFourierTransform_base): INPUT: - - ``xmin`` -- The lower bound of the slice to plot. - - ``xmax`` -- The upper bound of the slice to plot. - - ``**args`` -- passed on to the line plotting function. + - ``xmin`` -- the lower bound of the slice to plot + - ``xmax`` -- the upper bound of the slice to plot + - ``**args`` -- passed on to the line plotting function OUTPUT: a plot of the array interpreting each element as polar coordinates @@ -266,9 +266,9 @@ cdef class FastFourierTransform_complex(FastFourierTransform_base): INPUT: - - ``xmin`` -- The lower bound of the slice to plot. - - ``xmax`` -- The upper bound of the slice to plot. - - ``**args`` -- passed on to the line plotting function. + - ``xmin`` -- the lower bound of the slice to plot + - ``xmax`` -- the upper bound of the slice to plot + - ``**args`` -- passed on to the line plotting function OUTPUT: a plot of the array @@ -296,16 +296,16 @@ cdef class FastFourierTransform_complex(FastFourierTransform_base): """ Plot a slice of the array. - - ``style`` -- Style of the plot, options are ``"rect"`` or ``"polar"`` + - ``style`` -- style of the plot, options are ``"rect"`` or ``"polar"`` - ``"rect"`` -- height represents real part, color represents imaginary part. - ``"polar"`` -- height represents absolute value, color represents argument. - - ``xmin`` -- The lower bound of the slice to plot. 0 by default. - - ``xmax`` -- The upper bound of the slice to plot. ``len(self)`` by default. - - ``**args`` -- passed on to the line plotting function. + - ``xmin`` -- the lower bound of the slice to plot; 0 by default + - ``xmax`` -- the upper bound of the slice to plot; ``len(self)`` by default + - ``**args`` -- passed on to the line plotting function OUTPUT: a plot of the array diff --git a/src/sage/categories/action.pyx b/src/sage/categories/action.pyx index 0f49a368f3e..97e4f8079d1 100644 --- a/src/sage/categories/action.pyx +++ b/src/sage/categories/action.pyx @@ -200,9 +200,9 @@ cdef class Action(Functor): INPUT: - - ``g`` -- an object with parent ``self.G``. + - ``g`` -- an object with parent ``self.G`` - - ``x`` -- an object with parent ``self.US()``. + - ``x`` -- an object with parent ``self.US()`` .. WARNING:: diff --git a/src/sage/categories/additive_monoids.py b/src/sage/categories/additive_monoids.py index 3d76c87113b..70a195f582e 100644 --- a/src/sage/categories/additive_monoids.py +++ b/src/sage/categories/additive_monoids.py @@ -56,7 +56,7 @@ def sum(self, args): INPUT: - - ``args`` -- a list (or iterable) of elements of ``self`` + - ``args`` -- list (or iterable) of elements of ``self`` EXAMPLES:: diff --git a/src/sage/categories/category.py b/src/sage/categories/category.py index 4ed28a925bd..8d01059511e 100644 --- a/src/sage/categories/category.py +++ b/src/sage/categories/category.py @@ -930,7 +930,7 @@ def all_super_categories(self, proper=False): INPUT: - - ``proper`` -- a boolean (default: ``False``); whether to exclude this category. + - ``proper`` -- boolean (default: ``False``); whether to exclude this category Since :issue:`11943`, the order of super categories is determined by Python's method resolution order C3 algorithm. @@ -1474,9 +1474,9 @@ def _make_named_class(self, name, method_provider, cache=False, picklable=True): ``self`` that provides methods for the new class (in addition to those coming from the super categories). E.g. "ParentMethods" - - ``cache`` -- a boolean or ``ignore_reduction`` (default: ``False``) + - ``cache`` -- boolean or ``ignore_reduction`` (default: ``False``) (passed down to dynamic_class; for internal use only) - - ``picklable`` -- a boolean (default: ``True``) + - ``picklable`` -- boolean (default: ``True``) ASSUMPTION: @@ -1816,7 +1816,7 @@ def or_subcategory(self, category=None, join=False): - ``category`` -- a sub category of ``self``, tuple/list thereof, or ``None`` - - ``join`` -- a boolean (default: ``False``) + - ``join`` -- boolean (default: ``False``) OUTPUT: a category @@ -2083,7 +2083,7 @@ def _with_axioms(self, axioms): INPUT: - - ``axioms`` -- a list of strings, the names of the axioms + - ``axioms`` -- list of strings; the names of the axioms EXAMPLES:: @@ -2180,7 +2180,7 @@ def _without_axioms(self, named=False): INPUT: - - ``named`` -- a boolean (default: ``False``) + - ``named`` -- boolean (default: ``False``) .. TODO:: Improve this explanation. @@ -2213,7 +2213,7 @@ def _sort(categories): INPUT: - - ``categories`` -- a list (or iterable) of non-join categories + - ``categories`` -- list (or iterable) of non-join categories OUTPUT: a sorted tuple of categories, possibly with repeats @@ -2294,8 +2294,8 @@ def join(categories, as_list=False, ignore_axioms=(), axioms=()): INPUT: - - ``categories`` -- a list (or iterable) of categories - - ``as_list`` -- a boolean (default: ``False``); + - ``categories`` -- list (or iterable) of categories + - ``as_list`` -- boolean (default: ``False``); whether the result should be returned as a list - ``axioms`` -- a tuple of strings; the names of some supplementary axioms @@ -2622,7 +2622,7 @@ def category_graph(categories=None): INPUT: - - ``categories`` -- a list (or iterable) of categories + - ``categories`` -- list (or iterable) of categories If ``categories`` is specified, then the graph contains the mentioned categories together with all their super @@ -2944,9 +2944,9 @@ def __init__(self, super_categories, **kwds): INPUT: - - ``super_categories`` -- Categories to join. This category will + - ``super_categories`` -- categories to join; this category will consist of objects and morphisms that lie in all of these - categories. + categories - ``name`` -- ignored @@ -3030,7 +3030,7 @@ def _subcategory_hook_(self, category): INPUT: - - ``category`` -- a category. + - ``category`` -- a category .. note:: @@ -3137,7 +3137,7 @@ def _without_axioms(self, named=False): INPUT: - - ``named`` -- a boolean (default: ``False``) + - ``named`` -- boolean (default: ``False``) See :meth:`Category._without_axioms` for the description of the ``named`` parameter. @@ -3223,7 +3223,7 @@ def _repr_(self, as_join=False): INPUT: - - ``as_join`` -- a boolean (default: ``False``) + - ``as_join`` -- boolean (default: ``False``) EXAMPLES:: diff --git a/src/sage/categories/category_cy_helper.pyx b/src/sage/categories/category_cy_helper.pyx index 913a1c4d2b7..40353b2713f 100644 --- a/src/sage/categories/category_cy_helper.pyx +++ b/src/sage/categories/category_cy_helper.pyx @@ -47,7 +47,7 @@ cpdef tuple _sort_uniq(categories): INPUT: - - ``categories`` -- a list (or iterable) of categories + - ``categories`` -- list (or iterable) of categories OUTPUT: a sorted tuple of mutually incomparable categories @@ -79,9 +79,9 @@ cpdef tuple _flatten_categories(categories, ClasscallMetaclass JoinCategory): INPUT: - - ``categories`` -- a list (or iterable) of categories + - ``categories`` -- list (or iterable) of categories - - ``JoinCategory`` -- A type such that instances of that type will be + - ``JoinCategory`` -- a type such that instances of that type will be replaced by its super categories. Usually, this type is :class:`JoinCategory`. diff --git a/src/sage/categories/category_with_axiom.py b/src/sage/categories/category_with_axiom.py index 19e3b2a9e91..d5bd98633a3 100644 --- a/src/sage/categories/category_with_axiom.py +++ b/src/sage/categories/category_with_axiom.py @@ -2219,7 +2219,7 @@ def _repr_object_names_static(category, axioms): INPUT: - ``base_category`` -- a category - - ``axioms`` -- a list or iterable of strings + - ``axioms`` -- list or iterable of strings EXAMPLES:: diff --git a/src/sage/categories/commutative_rings.py b/src/sage/categories/commutative_rings.py index 42674107964..896604ec7ba 100644 --- a/src/sage/categories/commutative_rings.py +++ b/src/sage/categories/commutative_rings.py @@ -151,12 +151,12 @@ def over(self, base=None, gen=None, gens=None, name=None, names=None): - ``gen`` -- a generator of this extension (over its base) or ``None`` (default: ``None``); - - ``gens`` -- a list of generators of this extension (over its base) + - ``gens`` -- list of generators of this extension (over its base) or ``None`` (default: ``None``); - ``name`` -- a variable name or ``None`` (default: ``None``) - - ``names`` -- a list or a tuple of variable names or ``None`` + - ``names`` -- list or a tuple of variable names or ``None`` (default: ``None``) EXAMPLES: diff --git a/src/sage/categories/complete_discrete_valuation.py b/src/sage/categories/complete_discrete_valuation.py index 7f291c43e37..c525165af24 100644 --- a/src/sage/categories/complete_discrete_valuation.py +++ b/src/sage/categories/complete_discrete_valuation.py @@ -138,7 +138,7 @@ def lift_to_precision(self, absprec=None): INPUT: - - ``absprec`` -- an integer or ``None`` (default: ``None``), the + - ``absprec`` -- integer or ``None`` (default: ``None``); the absolute precision of the result. If ``None``, lifts to the maximum precision allowed. diff --git a/src/sage/categories/complex_reflection_or_generalized_coxeter_groups.py b/src/sage/categories/complex_reflection_or_generalized_coxeter_groups.py index efa0ddbeccd..70842e4614a 100644 --- a/src/sage/categories/complex_reflection_or_generalized_coxeter_groups.py +++ b/src/sage/categories/complex_reflection_or_generalized_coxeter_groups.py @@ -560,7 +560,7 @@ def distinguished_reflection(self, i): INPUT: - - ``i`` -- an element of the index set of the distinguished reflections. + - ``i`` -- an element of the index set of the distinguished reflections .. SEEALSO:: @@ -650,7 +650,7 @@ def from_reduced_word(self, word, word_type='simple'): INPUT: - - ``word`` -- a list (or iterable) of elements of the + - ``word`` -- list (or iterable) of elements of the index set of ``self`` (resp. of the distinguished or of all reflections) - ``word_type`` -- (default: ``'simple'``): diff --git a/src/sage/categories/coxeter_group_algebras.py b/src/sage/categories/coxeter_group_algebras.py index 03b6b39d71e..0b1a5339984 100644 --- a/src/sage/categories/coxeter_group_algebras.py +++ b/src/sage/categories/coxeter_group_algebras.py @@ -23,7 +23,7 @@ def demazure_lusztig_operator_on_basis(self, w, i, q1, q2, - ``w`` -- an element of the Coxeter group - ``i`` -- an element of the index set - ``q1``, ``q2`` -- two elements of the ground ring - - ``bar`` -- a boolean (default ``False``) + - ``bar`` -- boolean (default ``False``) See :meth:`demazure_lusztig_operators` for details. @@ -79,7 +79,7 @@ def demazure_lusztig_operators(self, q1, q2, side="right", affine=True): - ``q1``, ``q2`` -- two elements of the ground ring `K` - ``side`` -- ``"left"`` or ``"right"`` (default: ``"right"``); which side to act upon - - ``affine`` -- a boolean (default: ``True``) + - ``affine`` -- boolean (default: ``True``) The Demazure-Lusztig operator `T_i` is the linear map `R \to R` obtained by interpolating between the diff --git a/src/sage/categories/coxeter_groups.py b/src/sage/categories/coxeter_groups.py index 17deb20759f..c58a6aff9bd 100644 --- a/src/sage/categories/coxeter_groups.py +++ b/src/sage/categories/coxeter_groups.py @@ -262,7 +262,7 @@ def braid_orbit_iter(self, word): INPUT: - - ``word`` -- a list (or iterable) of indices in + - ``word`` -- list (or iterable) of indices in ``self.index_set()`` OUTPUT: @@ -893,7 +893,7 @@ def simple_projections(self, side='right', length_increasing=True): - ``self`` -- a Coxeter group `W` - ``side`` -- 'left' or 'right' (default: 'right') - - ``length_increasing`` -- a boolean (default: ``True``); whether + - ``length_increasing`` -- boolean (default: ``True``); whether the operator increases or decreases length This returns the simple projections of `W`, as a family. @@ -1539,7 +1539,7 @@ def descents(self, side='right', index_set=None, positive=False): - ``index_set`` -- a subset (as a list or iterable) of the nodes of the Dynkin diagram; (default: all of them) - ``side`` -- 'left' or 'right' (default: 'right') - - ``positive`` -- a boolean (default: ``False``) + - ``positive`` -- boolean (default: ``False``) The ``index_set`` option can be used to restrict to the parabolic subgroup indexed by ``index_set``. @@ -2323,7 +2323,7 @@ def apply_simple_projection(self, i, side='right', length_increasing=True): - ``i`` -- an element of the index set of the Coxeter group - ``side`` -- 'left' or 'right' (default: 'right') - - ``length_increasing`` -- a boolean (default: ``True``); + - ``length_increasing`` -- boolean (default: ``True``); specifying the direction of the projection See :meth:`CoxeterGroups.ParentMethods.simple_projections` @@ -2791,8 +2791,8 @@ def weak_covers(self, side='right', index_set=None, positive=False): INPUT: - side -- 'left' or 'right' (default: 'right') - - positive -- a boolean (default: ``False``) - - index_set -- a list of indices or None + - positive -- boolean (default: ``False``) + - index_set -- list of indices or None OUTPUT: list @@ -2838,7 +2838,7 @@ def coxeter_sorting_word(self, c): INPUT: - - ``c`` -- a Coxeter element. + - ``c`` -- a Coxeter element OUTPUT: @@ -2883,7 +2883,7 @@ def is_coxeter_sortable(self, c, sorting_word=None): INPUT: - ``c`` -- a Coxeter element - - ``sorting_word`` -- sorting word (default: ``None``) used to + - ``sorting_word`` -- sorting word (default: ``None``); used to not recompute the `c`-sorting word if already computed OUTPUT: is ``self`` `c`-sortable @@ -2961,7 +2961,7 @@ def apply_demazure_product(self, element, side='right', applied. If ``side`` is 'left' then the operation is applied on the left. - - ``length_increasing`` -- a boolean (default: ``True``) + - ``length_increasing`` -- boolean (default: ``True``) whether to act length increasingly or decreasingly EXAMPLES:: @@ -3205,7 +3205,7 @@ def lower_covers(self, side='right', index_set=None): INPUT: - ``side`` -- ``'left'`` or ``'right'`` (default: ``'right'``) - - ``index_set`` -- a list of indices or ``None`` + - ``index_set`` -- list of indices or ``None`` OUTPUT: list @@ -3241,7 +3241,7 @@ def upper_covers(self, side='right', index_set=None): INPUT: - ``side`` -- ``'left'`` or ``'right'`` (default: ``'right'``) - - ``index_set`` -- a list of indices or ``None`` + - ``index_set`` -- list of indices or ``None`` OUTPUT: list diff --git a/src/sage/categories/crystals.py b/src/sage/categories/crystals.py index aa2227c3b7c..54aaa8a2959 100644 --- a/src/sage/categories/crystals.py +++ b/src/sage/categories/crystals.py @@ -124,8 +124,8 @@ def example(self, choice="highwt", **kwds): INPUT: - - ``choice`` -- str [default: 'highwt']. Can be either 'highwt' - for the highest weight crystal of type A, or 'naive' for an + - ``choice`` -- string (default: ``'highwt'``); an be either ``'highwt'`` + for the highest weight crystal of type A, or ``'naive'`` for an example of a broken crystal. - ``**kwds`` -- keyword arguments passed onto the constructor for the diff --git a/src/sage/categories/drinfeld_modules.py b/src/sage/categories/drinfeld_modules.py index 25412ab5d6f..f14c07559a1 100644 --- a/src/sage/categories/drinfeld_modules.py +++ b/src/sage/categories/drinfeld_modules.py @@ -527,7 +527,7 @@ def random_object(self, rank): INPUT: - - ``rank`` -- an integer, the rank of the Drinfeld module + - ``rank`` -- integer; the rank of the Drinfeld module EXAMPLES:: diff --git a/src/sage/categories/euclidean_domains.py b/src/sage/categories/euclidean_domains.py index 91f5bd2a5f1..6bae8de6f6f 100644 --- a/src/sage/categories/euclidean_domains.py +++ b/src/sage/categories/euclidean_domains.py @@ -71,7 +71,7 @@ def gcd_free_basis(self, elts): INPUT: - - ``elts`` -- A sequence of elements of ``self``. + - ``elts`` -- a sequence of elements of ``self`` OUTPUT: diff --git a/src/sage/categories/examples/semigroups.py b/src/sage/categories/examples/semigroups.py index 4d9466ede64..c7e4643fdb5 100644 --- a/src/sage/categories/examples/semigroups.py +++ b/src/sage/categories/examples/semigroups.py @@ -428,7 +428,7 @@ def lift(self, x): INPUT: - - ``x`` -- an element of ``self``. + - ``x`` -- an element of ``self`` OUTPUT: diff --git a/src/sage/categories/finite_coxeter_groups.py b/src/sage/categories/finite_coxeter_groups.py index a842936996a..d79240ef42d 100644 --- a/src/sage/categories/finite_coxeter_groups.py +++ b/src/sage/categories/finite_coxeter_groups.py @@ -399,7 +399,7 @@ def weak_poset(self, side="right", facade=False): INPUT: - ``side`` -- "left", "right", or "twosided" (default: "right") - - ``facade`` -- a boolean (default: ``False``) + - ``facade`` -- boolean (default: ``False``) Returns the left (resp. right) poset for weak order. In this poset, `u` is smaller than `v` if some reduced word diff --git a/src/sage/categories/finite_dimensional_algebras_with_basis.py b/src/sage/categories/finite_dimensional_algebras_with_basis.py index 22a86763f7e..b34d27b72fd 100644 --- a/src/sage/categories/finite_dimensional_algebras_with_basis.py +++ b/src/sage/categories/finite_dimensional_algebras_with_basis.py @@ -959,7 +959,7 @@ def peirce_decomposition(self, idempotents=None, check=True): INPUT: - - ``idempotents`` -- a list of orthogonal idempotents + - ``idempotents`` -- list of orthogonal idempotents `(e_i)_{i=0,\ldots,n}` of the algebra that sum to `1` (default: the idempotents returned by :meth:`orthogonal_idempotents_central_mod_radical`) @@ -1035,7 +1035,7 @@ def is_identity_decomposition_into_orthogonal_idempotents(self, l): INPUT: - - ``l`` -- a list or iterable of elements of ``self`` + - ``l`` -- list or iterable of elements of ``self`` EXAMPLES:: diff --git a/src/sage/categories/finite_dimensional_graded_lie_algebras_with_basis.py b/src/sage/categories/finite_dimensional_graded_lie_algebras_with_basis.py index fa53cb36ed2..e2c99f509a2 100644 --- a/src/sage/categories/finite_dimensional_graded_lie_algebras_with_basis.py +++ b/src/sage/categories/finite_dimensional_graded_lie_algebras_with_basis.py @@ -52,7 +52,7 @@ def _test_grading(self, **options): INPUT: - - ``options`` -- any keyword arguments accepted by :meth:`_tester`. + - ``options`` -- any keyword arguments accepted by :meth:`_tester` EXAMPLES:: diff --git a/src/sage/categories/finite_dimensional_lie_algebras_with_basis.py b/src/sage/categories/finite_dimensional_lie_algebras_with_basis.py index 430a93d9045..3ffd3eeeeeb 100644 --- a/src/sage/categories/finite_dimensional_lie_algebras_with_basis.py +++ b/src/sage/categories/finite_dimensional_lie_algebras_with_basis.py @@ -1007,7 +1007,7 @@ def subalgebra(self, *gens, **kwds): INPUT: - - ``gens`` -- a list of generators of the subalgebra + - ``gens`` -- list of generators of the subalgebra - ``category`` -- (optional) a subcategory of subobjects of finite dimensional Lie algebras with basis @@ -1048,7 +1048,7 @@ def ideal(self, *gens, **kwds): INPUT: - - ``gens`` -- a list of generators of the ideal + - ``gens`` -- list of generators of the ideal - ``category`` -- (optional) a subcategory of subobjects of finite dimensional Lie algebras with basis diff --git a/src/sage/categories/finite_dimensional_modules_with_basis.py b/src/sage/categories/finite_dimensional_modules_with_basis.py index 9602bfed7f8..fd91efa6350 100644 --- a/src/sage/categories/finite_dimensional_modules_with_basis.py +++ b/src/sage/categories/finite_dimensional_modules_with_basis.py @@ -308,7 +308,7 @@ def echelon_form(self, elements, row_reduced=False, order=None): INPUT: - - ``elements`` -- a list or finite iterable of elements of ``self`` + - ``elements`` -- list or finite iterable of elements of ``self`` - ``row_reduced`` -- boolean (default: ``False``); whether to compute the basis for the row reduced echelon form - ``order`` -- (optional) either something that can @@ -481,7 +481,7 @@ def twisted_invariant_module(self, G, chi, INPUT: - ``G`` -- a finitely-generated group - - ``chi`` -- a list/tuple of character values or an instance of + - ``chi`` -- list/tuple of character values or an instance of :class:`~sage.groups.class_function.ClassFunction_gap` - ``action`` -- a function (default: :obj:`operator.mul`) - ``action_on_basis`` -- (optional) define the action of ``g`` diff --git a/src/sage/categories/finite_dimensional_semisimple_algebras_with_basis.py b/src/sage/categories/finite_dimensional_semisimple_algebras_with_basis.py index efae7191e10..d0fd5d42d00 100644 --- a/src/sage/categories/finite_dimensional_semisimple_algebras_with_basis.py +++ b/src/sage/categories/finite_dimensional_semisimple_algebras_with_basis.py @@ -45,7 +45,7 @@ def radical_basis(self, **keywords): r""" Return a basis of the Jacobson radical of this algebra. - - ``keywords`` -- for compatibility; ignored. + - ``keywords`` -- for compatibility; ignored OUTPUT: the empty list since this algebra is semisimple @@ -121,7 +121,7 @@ def _orthogonal_decomposition(self, generators=None): INPUT: - - ``generators`` -- a list of generators of + - ``generators`` -- list of generators of ``self`` (default: the basis of ``self``) OUTPUT: diff --git a/src/sage/categories/finite_enumerated_sets.py b/src/sage/categories/finite_enumerated_sets.py index 326f6820745..82db418c52a 100644 --- a/src/sage/categories/finite_enumerated_sets.py +++ b/src/sage/categories/finite_enumerated_sets.py @@ -191,15 +191,15 @@ def _cardinality_from_list(self, *ignored_args, **ignored_kwds): return Integer(len(self.tuple())) def _unrank_from_list(self, r): - """ - The ``r``-th element of ``self`` + r""" + The `r`-th element of ``self``. INPUT: - - ``r`` -- an integer between ``0`` and ``n-1``, - where ``n`` is the cardinality of ``self``. + - ``r`` -- integer between `0` and `n-1`, + where `n` is the cardinality of ``self`` - OUTPUT: the ``r``-th element of ``self`` + OUTPUT: the `r`-th element of ``self`` This implementation of :meth:`unrank` uses the method :meth:`list` (which is cached). Reciprocally, calling diff --git a/src/sage/categories/finite_permutation_groups.py b/src/sage/categories/finite_permutation_groups.py index 476f8b4a200..9422b9c0763 100644 --- a/src/sage/categories/finite_permutation_groups.py +++ b/src/sage/categories/finite_permutation_groups.py @@ -288,7 +288,7 @@ def profile_series(self, variable='z'): def profile(self, n, using_polya=True): r""" - Return the value in ``n`` of the profile of the group ``self``. + Return the value in `n` of the profile of the group ``self``. Optional argument ``using_polya`` allows to change the default method. @@ -296,16 +296,17 @@ def profile(self, n, using_polya=True): - ``n`` -- a nonnegative integer - - ``using_polya`` (optional) -- a boolean: if ``True`` (default), the computation - uses Pólya enumeration (and all values of the profile are cached, so this - should be the method used in case several of them are needed); - if ``False``, uses the GAP interface to compute the orbit. + - ``using_polya`` -- boolean (default: ``True``); if ``True``, the + computation uses Pólya enumeration (and all values of the profile + are cached, so this should be the method used in case several of + them are needed); if ``False``, uses the GAP interface to compute + the orbit. OUTPUT: - - A nonnegative integer that is the number of orbits of ``n``-subsets + - A nonnegative integer that is the number of orbits of `n`-subsets under the action induced by ``self`` on the subsets of its domain - (i.e. the value of the profile of ``self`` in ``n``) + (i.e. the value of the profile of ``self`` in `n`) .. SEEALSO:: diff --git a/src/sage/categories/finite_posets.py b/src/sage/categories/finite_posets.py index f984cdf39d1..d934265a2c6 100644 --- a/src/sage/categories/finite_posets.py +++ b/src/sage/categories/finite_posets.py @@ -1895,10 +1895,10 @@ def order_ideals_lattice(self, as_ideals=True, facade=None): INPUT: - - ``as_ideals`` -- Boolean, if ``True`` (default) returns + - ``as_ideals`` -- boolean (default: ``True``), if ``True`` returns a poset on the set of order ideals, otherwise on the set of antichains - - ``facade`` -- Boolean or ``None`` (default). Whether to + - ``facade`` -- boolean or ``None`` (default); whether to return a facade lattice or not. By default return facade lattice if the poset is a facade poset. diff --git a/src/sage/categories/finitely_generated_semigroups.py b/src/sage/categories/finitely_generated_semigroups.py index 6af0c27494b..322a3630ddc 100644 --- a/src/sage/categories/finitely_generated_semigroups.py +++ b/src/sage/categories/finitely_generated_semigroups.py @@ -161,7 +161,7 @@ def ideal(self, gens, side="twosided"): INPUT: - - ``gens`` -- a list (or iterable) of elements of ``self`` + - ``gens`` -- list (or iterable) of elements of ``self`` - ``side`` -- [default: "twosided"] "left", "right" or "twosided" EXAMPLES:: diff --git a/src/sage/categories/graded_modules_with_basis.py b/src/sage/categories/graded_modules_with_basis.py index 99f09799b9b..a4d66e9c753 100644 --- a/src/sage/categories/graded_modules_with_basis.py +++ b/src/sage/categories/graded_modules_with_basis.py @@ -78,7 +78,7 @@ def submodule(self, gens, check=True, already_echelonized=False, INPUT: - - ``gens`` -- a list or family of elements of ``self`` + - ``gens`` -- list or family of elements of ``self`` - ``check`` -- boolean (default: ``True``); whether to verify that the elements of ``gens`` are in ``self`` - ``already_echelonized`` -- boolean (default: ``False``); whether diff --git a/src/sage/categories/homset.py b/src/sage/categories/homset.py index 05e3ff9ea45..38164e576d3 100644 --- a/src/sage/categories/homset.py +++ b/src/sage/categories/homset.py @@ -94,11 +94,11 @@ def Hom(X, Y, category=None, check=True): - ``Y`` -- an object of a category - - ``category`` -- a category in which the morphisms must be. - (default: the meet of the categories of ``X`` and ``Y``) - Both ``X`` and ``Y`` must belong to that category. + - ``category`` -- a category in which the morphisms must be + (default: the meet of the categories of ``X`` and ``Y``); + both ``X`` and ``Y`` must belong to that category - - ``check`` -- a boolean (default: ``True``): whether to check the + - ``check`` -- boolean (default: ``True``); whether to check the input, and in particular that ``X`` and ``Y`` belong to ``category``. diff --git a/src/sage/categories/lambda_bracket_algebras.py b/src/sage/categories/lambda_bracket_algebras.py index 9c93d417489..970def4aac0 100644 --- a/src/sage/categories/lambda_bracket_algebras.py +++ b/src/sage/categories/lambda_bracket_algebras.py @@ -42,7 +42,7 @@ def __classcall_private__(cls, R, check=True): INPUT: - `R` -- a commutative ring - - ``check`` -- a boolean (default: ``True``); whether to check + - ``check`` -- boolean (default: ``True``); whether to check that `R` is a commutative ring EXAMPLES:: diff --git a/src/sage/categories/lie_algebras.py b/src/sage/categories/lie_algebras.py index 0f8fde4936f..f719f165bdb 100644 --- a/src/sage/categories/lie_algebras.py +++ b/src/sage/categories/lie_algebras.py @@ -645,7 +645,7 @@ def bch(self, X, Y, prec=None): - ``X`` -- an element of ``self`` - ``Y`` -- an element of ``self`` - - ``prec`` -- an integer; the maximum length of Lie brackets to be + - ``prec`` -- integer; the maximum length of Lie brackets to be considered in the formula EXAMPLES: @@ -781,7 +781,7 @@ def _test_jacobi_identity(self, **options): INPUT: - - ``options`` -- any keyword arguments accepted by :meth:`_tester`. + - ``options`` -- any keyword arguments accepted by :meth:`_tester` EXAMPLES: @@ -820,7 +820,7 @@ def _test_antisymmetry(self, **options): INPUT: - - ``options`` -- any keyword arguments accepted by :meth:`_tester`. + - ``options`` -- any keyword arguments accepted by :meth:`_tester` EXAMPLES: @@ -852,7 +852,7 @@ def _test_distributivity(self, **options): INPUT: - - ``options`` -- any keyword arguments accepted by :meth:`_tester`. + - ``options`` -- any keyword arguments accepted by :meth:`_tester` TESTS:: diff --git a/src/sage/categories/map.pyx b/src/sage/categories/map.pyx index b420adb4d76..a1a8c0647ea 100644 --- a/src/sage/categories/map.pyx +++ b/src/sage/categories/map.pyx @@ -401,10 +401,10 @@ cdef class Map(Element): INPUT: - - ``slots`` -- A dictionary of slots to be updated. - The dictionary must have the keys ``'_domain'`` and + - ``slots`` -- a dictionary of slots to be updated; + the dictionary must have the keys ``'_domain'`` and ``'_codomain'``, and may have the keys ``'_repr_type_str'`` - and ``'_is_coercion'``. + and ``'_is_coercion'`` TESTS: diff --git a/src/sage/categories/modules.py b/src/sage/categories/modules.py index 990fcdfb456..bf1a3966fb6 100644 --- a/src/sage/categories/modules.py +++ b/src/sage/categories/modules.py @@ -45,7 +45,7 @@ class Modules(Category_module): INPUT: - ``base_ring`` -- a ring `R` or subcategory of ``Rings()`` - - ``dispatch`` -- a boolean (for internal use; default: ``True``) + - ``dispatch`` -- boolean (for internal use; default: ``True``) When the base ring is a field, the category of vector spaces is returned instead (unless ``dispatch == False``). diff --git a/src/sage/categories/modules_with_basis.py b/src/sage/categories/modules_with_basis.py index d032bf0dca1..1ecf4aedbf9 100644 --- a/src/sage/categories/modules_with_basis.py +++ b/src/sage/categories/modules_with_basis.py @@ -682,7 +682,7 @@ def echelon_form(self, elements, row_reduced=False, order=None): INPUT: - - ``elements`` -- a list or finite iterable of elements of ``self`` + - ``elements`` -- list or finite iterable of elements of ``self`` - ``row_reduced`` -- boolean (default: ``False``); whether to compute the basis for the row reduced echelon form - ``order`` -- (optional) either something that can @@ -736,7 +736,7 @@ def submodule(self, gens, check=True, already_echelonized=False, INPUT: - - ``gens`` -- a list or family of elements of ``self`` + - ``gens`` -- list or family of elements of ``self`` - ``check`` -- boolean (default: ``True``); whether to verify that the elements of ``gens`` are in ``self`` - ``already_echelonized`` -- boolean (default: ``False``); whether @@ -1127,7 +1127,7 @@ def sum_of_monomials(self): INPUT: - - ``indices`` -- a list (or iterable) of indices of basis + - ``indices`` -- list (or iterable) of indices of basis elements EXAMPLES:: @@ -1191,7 +1191,7 @@ def sum_of_terms(self, terms): INPUT: - - ``terms`` -- a list (or iterable) of pairs ``(index, coeff)`` + - ``terms`` -- list (or iterable) of pairs ``(index, coeff)`` OUTPUT: diff --git a/src/sage/categories/monoids.py b/src/sage/categories/monoids.py index 654bb195172..9269c1b1a61 100644 --- a/src/sage/categories/monoids.py +++ b/src/sage/categories/monoids.py @@ -148,7 +148,7 @@ def prod(self, args): INPUT: - - ``args`` -- a list (or iterable) of elements of ``self`` + - ``args`` -- list (or iterable) of elements of ``self`` Returns the product of the elements in ``args``, as an element of ``self``. diff --git a/src/sage/categories/posets.py b/src/sage/categories/posets.py index 0d846648e6f..97ff55a7130 100644 --- a/src/sage/categories/posets.py +++ b/src/sage/categories/posets.py @@ -318,9 +318,9 @@ def directed_subset(self, elements, direction): INPUT: - - elements -- a list of elements. + - elements -- list of elements - - direction -- 'up' or 'down'. + - direction -- 'up' or 'down' EXAMPLES:: @@ -456,7 +456,7 @@ def is_order_ideal(self, o): INPUT: - - ``o`` -- a list (or set, or tuple) containing some elements of ``self`` + - ``o`` -- list (or set, or tuple) containing some elements of ``self`` EXAMPLES:: @@ -483,7 +483,7 @@ def is_order_filter(self, o): INPUT: - - ``o`` -- a list (or set, or tuple) containing some elements of ``self`` + - ``o`` -- list (or set, or tuple) containing some elements of ``self`` EXAMPLES:: @@ -515,9 +515,8 @@ def is_chain_of_poset(self, o, ordered=False): - ``o`` -- an iterable (e. g., list, set, or tuple) containing some elements of ``self`` - - ``ordered`` -- a Boolean (default: ``False``) which - decides whether the notion of a chain includes being - ordered + - ``ordered`` -- a Boolean (default: ``False``); decides + whether the notion of a chain includes being ordered OUTPUT: diff --git a/src/sage/categories/pushout.py b/src/sage/categories/pushout.py index 8e2a3a759ff..a6141243808 100644 --- a/src/sage/categories/pushout.py +++ b/src/sage/categories/pushout.py @@ -351,9 +351,9 @@ def common_base(self, other_functor, self_bases, other_bases): INPUT: - - ``other_functor`` -- a construction functor. + - ``other_functor`` -- a construction functor - - ``self_bases`` -- the arguments passed to this functor. + - ``self_bases`` -- the arguments passed to this functor - ``other_bases`` -- the arguments passed to the functor ``other_functor``. @@ -389,9 +389,9 @@ def _raise_common_base_exception_(self, other_functor, INPUT: - - ``other_functor`` -- a functor. + - ``other_functor`` -- a functor - - ``self_bases`` -- the arguments passed to this functor. + - ``self_bases`` -- the arguments passed to this functor - ``other_bases`` -- the arguments passed to the functor ``other_functor``. @@ -759,9 +759,9 @@ def common_base(self, other_functor, self_bases, other_bases): INPUT: - - ``other_functor`` -- a construction functor. + - ``other_functor`` -- a construction functor - - ``self_bases`` -- the arguments passed to this functor. + - ``self_bases`` -- the arguments passed to this functor - ``other_bases`` -- the arguments passed to the functor ``other_functor``. @@ -3464,7 +3464,7 @@ def merge(self, other): INPUT: - - ``other`` -- Construction Functor. + - ``other`` -- Construction Functor OUTPUT: diff --git a/src/sage/categories/quotient_fields.py b/src/sage/categories/quotient_fields.py index 9d1b94b1a5d..5a85bc130e2 100644 --- a/src/sage/categories/quotient_fields.py +++ b/src/sage/categories/quotient_fields.py @@ -343,8 +343,8 @@ def factor(self, *args, **kwds): INPUT: - - ``*args`` -- Arbitrary arguments suitable over the base ring - - ``**kwds`` -- Arbitrary keyword arguments suitable over the base ring + - ``*args`` -- arbitrary arguments suitable over the base ring + - ``**kwds`` -- arbitrary keyword arguments suitable over the base ring OUTPUT: factorization of ``self`` over the base ring @@ -638,7 +638,7 @@ def _derivative(self, var=None): INPUT: - - ``var`` -- Variable with respect to which the derivative is computed + - ``var`` -- variable with respect to which the derivative is computed OUTPUT: derivative of ``self`` with respect to ``var`` diff --git a/src/sage/categories/rings.py b/src/sage/categories/rings.py index f62b4baa7a3..b846e2ba0ef 100644 --- a/src/sage/categories/rings.py +++ b/src/sage/categories/rings.py @@ -857,7 +857,7 @@ def quotient(self, I, names=None, **kwds): INPUT: - - ``I`` -- A twosided ideal of this ring. + - ``I`` -- a twosided ideal of this ring - ``names`` -- (optional) names of the generators of the quotient (if there are multiple generators, you can specify a single character string and the generators are named in sequence starting with 0). diff --git a/src/sage/categories/semigroups.py b/src/sage/categories/semigroups.py index c28ca4d102c..7e14cc2e8c2 100644 --- a/src/sage/categories/semigroups.py +++ b/src/sage/categories/semigroups.py @@ -68,7 +68,7 @@ def example(self, choice="leftzero", **kwds): INPUT: - - ``choice`` -- str (default: 'leftzero'). Can be either 'leftzero' + - ``choice`` -- string (default: ``'leftzero'``); Can be either 'leftzero' for the left zero semigroup, or 'free' for the free semigroup. - ``**kwds`` -- keyword arguments passed onto the constructor for the chosen semigroup. @@ -185,10 +185,10 @@ def cayley_graph(self, side="right", simple=False, elements=None, - ``simple`` -- boolean (default: ``False``): if ``True``, returns a simple graph (no loops, no labels, no multiple edges) - - ``generators`` -- a list, tuple, or family of elements + - ``generators`` -- list, tuple, or family of elements of ``self`` (default: ``self.semigroup_generators()``) - ``connecting_set`` -- alias for ``generators``; deprecated - - ``elements`` -- a list (or iterable) of elements of ``self`` + - ``elements`` -- list (or iterable) of elements of ``self`` OUTPUT: :class:`DiGraph` @@ -377,7 +377,7 @@ def subsemigroup(self, generators, one=None, category=None): ``self``, or a list, iterable, ... that can be converted into one (see :class:`Family`). - - ``one`` -- a unit for the subsemigroup, or ``None``. + - ``one`` -- a unit for the subsemigroup, or ``None`` - ``category`` -- a category diff --git a/src/sage/categories/semisimple_algebras.py b/src/sage/categories/semisimple_algebras.py index 744af59f07d..90fa3828d09 100644 --- a/src/sage/categories/semisimple_algebras.py +++ b/src/sage/categories/semisimple_algebras.py @@ -92,7 +92,7 @@ def radical_basis(self, **keywords): r""" Return a basis of the Jacobson radical of this algebra. - - ``keywords`` -- for compatibility; ignored. + - ``keywords`` -- for compatibility; ignored OUTPUT: the empty list since this algebra is semisimple diff --git a/src/sage/categories/sets_cat.py b/src/sage/categories/sets_cat.py index 8acf2706d39..f0bca1fb023 100644 --- a/src/sage/categories/sets_cat.py +++ b/src/sage/categories/sets_cat.py @@ -1540,7 +1540,7 @@ def cartesian_product(*parents, **kwargs): INPUT: - - ``parents`` -- a list (or other iterable) of parents. + - ``parents`` -- list (or other iterable) of parents - ``category`` -- (default: ``None``) the category the Cartesian product belongs to. If ``None`` is passed, @@ -2821,7 +2821,8 @@ def inject_shorthands(self, shorthands=None, verbose=True): INPUT: - - ``shorthands`` -- a list (or iterable) of strings (default: ``self._shorthands``) + - ``shorthands`` -- list (or iterable) of strings + (default: ``self._shorthands``) or ``"all"`` (for ``self._shorthands_all``) - ``verbose`` -- boolean (default ``True``); whether to print the defined shorthands diff --git a/src/sage/categories/simplicial_sets.py b/src/sage/categories/simplicial_sets.py index 3c684d351aa..bcf51374dd5 100644 --- a/src/sage/categories/simplicial_sets.py +++ b/src/sage/categories/simplicial_sets.py @@ -822,7 +822,7 @@ def twisted_homology(self, n, reduced=False): INPUT: - - ``n`` -- a positive integer. + - ``n`` -- positive integer - ``reduced`` -- boolean (default: ``False``); if set to True, the presentation matrix will be reduced. diff --git a/src/sage/categories/vector_spaces.py b/src/sage/categories/vector_spaces.py index fe391b615f7..282c227151c 100644 --- a/src/sage/categories/vector_spaces.py +++ b/src/sage/categories/vector_spaces.py @@ -44,7 +44,7 @@ def __classcall_private__(cls, K, check=True): INPUT: - `K` -- a field - - ``check`` -- a boolean (default: ``True``); whether to check that `K` + - ``check`` -- boolean (default: ``True``); whether to check that `K` is a field EXAMPLES:: diff --git a/src/sage/coding/channel.py b/src/sage/coding/channel.py index 20e46baf5a2..597a29dae4e 100644 --- a/src/sage/coding/channel.py +++ b/src/sage/coding/channel.py @@ -788,7 +788,7 @@ def probability_of_exactly_t_errors(self, t): INPUT: - - ``t`` -- an integer + - ``t`` -- integer EXAMPLES:: @@ -808,7 +808,7 @@ def probability_of_at_most_t_errors(self, t): INPUT: - - ``t`` -- an integer + - ``t`` -- integer EXAMPLES:: diff --git a/src/sage/coding/code_bounds.py b/src/sage/coding/code_bounds.py index fd4e36561ef..8db667d3870 100644 --- a/src/sage/coding/code_bounds.py +++ b/src/sage/coding/code_bounds.py @@ -50,7 +50,7 @@ where `0` is a distinguished element of `F`; in particular it is `0` of the field if `F` is a field. The minimum distance of -a linear code is the smallest non-zero weight of a codeword in `C`. The +a linear code is the smallest nonzero weight of a codeword in `C`. The relatively minimum distance is denoted diff --git a/src/sage/coding/code_constructions.py b/src/sage/coding/code_constructions.py index 7f32cdc8ed0..d648d5c2451 100644 --- a/src/sage/coding/code_constructions.py +++ b/src/sage/coding/code_constructions.py @@ -548,7 +548,7 @@ def QuadraticResidueCodeEvenPair(n,F): quadratic residue mod `n`. They are constructed as "even-like" duadic codes associated the - splitting `(Q,N)` mod `n`, where `Q` is the set of non-zero quadratic + splitting `(Q,N)` mod `n`, where `Q` is the set of nonzero quadratic residues and `N` is the non-residues. EXAMPLES:: @@ -598,8 +598,8 @@ def QuadraticResidueCodeEvenPair(n,F): if n <= 2 or not n.is_prime(): raise ValueError("the argument n must be an odd prime") Q = quadratic_residues(n) - Q.remove(0) # non-zero quad residues - N = [x for x in srange(1, n) if x not in Q] # non-zero quad non-residues + Q.remove(0) # nonzero quad residues + N = [x for x in srange(1, n) if x not in Q] # nonzero quad non-residues if q not in Q: raise ValueError("the order of the finite field must be a quadratic residue modulo n") return DuadicCodeEvenPair(F,Q,N) @@ -614,7 +614,7 @@ def QuadraticResidueCodeOddPair(n,F): quadratic residue mod `n`. They are constructed as "odd-like" duadic codes associated the - splitting `(Q,N)` mod `n`, where `Q` is the set of non-zero quadratic + splitting `(Q,N)` mod `n`, where `Q` is the set of nonzero quadratic residues and `N` is the non-residues. EXAMPLES:: @@ -658,8 +658,8 @@ def QuadraticResidueCodeOddPair(n,F): if n <= 2 or not n.is_prime(): raise ValueError("the argument n must be an odd prime") Q = quadratic_residues(n) - Q.remove(0) # non-zero quad residues - N = [x for x in srange(1, n) if x not in Q] # non-zero quad non-residues + Q.remove(0) # nonzero quad residues + N = [x for x in srange(1, n) if x not in Q] # nonzero quad non-residues if q not in Q: raise ValueError("the order of the finite field must be a quadratic residue modulo n") return DuadicCodeOddPair(F,Q,N) diff --git a/src/sage/coding/codecan/autgroup_can_label.pyx b/src/sage/coding/codecan/autgroup_can_label.pyx index 6739a6571e5..e94e6329c6b 100644 --- a/src/sage/coding/codecan/autgroup_can_label.pyx +++ b/src/sage/coding/codecan/autgroup_can_label.pyx @@ -405,7 +405,7 @@ class LinearCodeAutGroupCanLabel: - ``normalization_inverse`` -- the inverse of ``normalization`` - - ``col2pos`` -- a list of disjoint indices in ``range(n)`` + - ``col2pos`` -- list of disjoint indices in ``range(n)`` - ``col2P`` -- an increasing list of integers, with ``len(col2P) == len(col2pos)`` with ``col2P[i] == col2P[j]`` if and @@ -476,7 +476,7 @@ class LinearCodeAutGroupCanLabel: INPUT: - - ``gens`` -- a list of semimonomial transformation group elements of length `m` + - ``gens`` -- list of semimonomial transformation group elements of length `m` - ``normalization`` -- a semimonomial transformation of length `n` diff --git a/src/sage/coding/codecan/codecan.pyx b/src/sage/coding/codecan/codecan.pyx index af8d82e660a..fd2a26f14b1 100644 --- a/src/sage/coding/codecan/codecan.pyx +++ b/src/sage/coding/codecan/codecan.pyx @@ -111,10 +111,10 @@ cdef class InnerGroup: Those stabilizers can be stored as triples: - - ``rank`` -- an integer in `\{0, \ldots, k\}` + - ``rank`` -- integer in `\{0, \ldots, k\}` - ``row_partition`` -- a partition of `\{0, \ldots, k-1\}` with discrete cells for all integers `i` `\geq` ``rank``. - - ``frob_pow`` -- an integer `s` in `\{0, \ldots, r-1\}` if `q = p^r` + - ``frob_pow`` -- integer `s` in `\{0, \ldots, r-1\}` if `q = p^r` The group `G_{\Pi^{(I)}(x)}` contains all elements `(A, \varphi, \alpha) \in G`, where @@ -138,7 +138,7 @@ cdef class InnerGroup: INPUT: - - ``k`` -- an integer, gives the dimension of the matrix component + - ``k`` -- integer; gives the dimension of the matrix component - ``algorithm`` -- either * "semilinear" -- full group @@ -514,7 +514,7 @@ cdef class PartitionRefinementLinearCode(PartitionRefinement_generic): INPUT: - - ``n`` -- an integer + - ``n`` -- integer - ``generator_matrix`` -- a `k \times n` matrix over `\GF{q}` of full row rank, i.e. `k bool: - ``other`` -- another Gabidulin Gao Decoder - OUTPUT: - - - ``True`` or ``False`` + OUTPUT: ``True`` or ``False`` EXAMPLES:: @@ -894,9 +884,7 @@ def _partial_xgcd(self, a, b, d_stop): - ``d_stop`` -- the number of iterations for which the algorithm is to be run - OUTPUT: - - - ``r_c`` -- right linearized remainder of `a` and `b` + OUTPUT: ``r_c`` -- right linearized remainder of `a` and `b` - ``u_c`` -- right linearized quotient of `a` and `b` @@ -995,9 +983,7 @@ def decode_to_code(self, r): - ``r`` -- received codeword - OUTPUT: - - - the decoded codeword corresponding to the received codeword + OUTPUT: the decoded codeword corresponding to the received codeword EXAMPLES:: @@ -1028,9 +1014,7 @@ def decode_to_message(self, r): - ``r`` -- received codeword - OUTPUT: - - - the message corresponding to the received codeword + OUTPUT: the message corresponding to the received codeword EXAMPLES:: diff --git a/src/sage/coding/grs_code.py b/src/sage/coding/grs_code.py index 17f5e06114f..f98e7f708e3 100644 --- a/src/sage/coding/grs_code.py +++ b/src/sage/coding/grs_code.py @@ -81,13 +81,13 @@ class GeneralizedReedSolomonCode(AbstractLinearCode): - ``dimension`` -- the dimension of the resulting code - - ``column_multipliers`` -- (default: ``None``) list of non-zero + - ``column_multipliers`` -- (default: ``None``) list of nonzero elements of `F`; all column multipliers are set to 1 if default value is kept EXAMPLES: - Often, one constructs a Reed-Solomon code by taking all non-zero elements of + Often, one constructs a Reed-Solomon code by taking all nonzero elements of the field as evaluation points, and specifying no column multipliers (see also :func:`ReedSolomonCode` for constructing classical Reed-Solomon codes directly):: @@ -192,7 +192,7 @@ def __init__(self, evaluation_points, dimension, column_multipliers=None): sage: C = codes.GeneralizedReedSolomonCode(F.list()[:n], k, F.list()[:n]) Traceback (most recent call last): ... - ValueError: All column multipliers must be non-zero + ValueError: All column multipliers must be nonzero And all the evaluation points must be different. Note that they should be different after converting into the same field:: @@ -240,7 +240,7 @@ def __init__(self, evaluation_points, dimension, column_multipliers=None): self._dimension = dimension if F.zero() in self._column_multipliers: - raise ValueError("All column multipliers must be non-zero") + raise ValueError("All column multipliers must be nonzero") if len(self._evaluation_points) != len(set(self._evaluation_points)): raise ValueError("All evaluation points must be different") @@ -956,9 +956,7 @@ def encode(self, p): - ``p`` -- a polynomial from the message space of ``self`` of degree less than ``self.code().dimension()`` - OUTPUT: - - - a codeword in associated code of ``self`` + OUTPUT: a codeword in associated code of ``self`` EXAMPLES:: @@ -1269,9 +1267,7 @@ def decode_to_message(self, r): - ``r`` -- a codeword of ``self`` - OUTPUT: - - - a vector of ``self`` message space + OUTPUT: a vector of ``self`` message space EXAMPLES:: @@ -1381,9 +1377,7 @@ def decoding_radius(self): r""" Return maximal number of errors that ``self`` can decode. - OUTPUT: - - - the number of errors as an integer + OUTPUT: the number of errors as an integer EXAMPLES:: @@ -1519,9 +1513,7 @@ def _polynomial_vanishing_at_alphas(self, PolRing): - ``PolRing`` -- polynomial ring of the output - OUTPUT: - - - a polynomial over ``PolRing`` + OUTPUT: a polynomial over ``PolRing`` EXAMPLES:: @@ -1652,9 +1644,7 @@ def decode_to_message(self, r): - ``r`` -- a codeword of ``self`` - OUTPUT: - - - a vector of ``self`` message space + OUTPUT: a vector of ``self`` message space EXAMPLES:: @@ -1766,9 +1756,7 @@ def decoding_radius(self): r""" Return maximal number of errors that ``self`` can decode - OUTPUT: - - - the number of errors as an integer + OUTPUT: the number of errors as an integer EXAMPLES:: @@ -1914,9 +1902,7 @@ def decode_to_message(self, word_and_erasure_vector): In either case, if ``r`` is not a codeword, the output is unspecified. - OUTPUT: - - - a vector of ``self`` message space + OUTPUT: a vector of ``self`` message space EXAMPLES:: @@ -1993,9 +1979,7 @@ def decoding_radius(self, number_erasures): - ``number_erasures`` -- the number of erasures when we try to decode - OUTPUT: - - - the number of errors as an integer + OUTPUT: the number of errors as an integer EXAMPLES:: @@ -2177,9 +2161,7 @@ def _syndrome(self, r): - ``r`` -- a vector of the ambient space of ``self.code()`` - OUTPUT: - - - a list + OUTPUT: a list EXAMPLES:: @@ -2214,9 +2196,7 @@ def _forney_formula(self, error_evaluator, error_locator): - ``error_evaluator``, ``error_locator`` -- two polynomials - OUTPUT: - - - a vector + OUTPUT: a vector EXAMPLES:: @@ -2334,9 +2314,7 @@ def decode_to_message(self, r): - ``r`` -- a codeword of ``self`` - OUTPUT: - - - a vector of ``self`` message space + OUTPUT: a vector of ``self`` message space EXAMPLES:: @@ -2360,9 +2338,7 @@ def decoding_radius(self): r""" Return maximal number of errors that ``self`` can decode - OUTPUT: - - - the number of errors as an integer + OUTPUT: the number of errors as an integer EXAMPLES:: diff --git a/src/sage/coding/guruswami_sudan/gs_decoder.py b/src/sage/coding/guruswami_sudan/gs_decoder.py index ddaa88b0a97..92d0c7ae8f5 100644 --- a/src/sage/coding/guruswami_sudan/gs_decoder.py +++ b/src/sage/coding/guruswami_sudan/gs_decoder.py @@ -152,7 +152,7 @@ class GRSGuruswamiSudanDecoder(Decoder): INPUT: - - ``code`` -- A code associated to this decoder. + - ``code`` -- a code associated to this decoder - ``tau`` -- integer (default: ``None``); the number of errors one wants the Guruswami-Sudan algorithm to correct. @@ -252,7 +252,7 @@ def parameters_given_tau(tau, C=None, n_k=None): INPUT: - - ``tau`` -- an integer, number of errors one wants the Guruswami-Sudan + - ``tau`` -- integer; number of errors one wants the Guruswami-Sudan algorithm to correct - ``C`` -- (default: ``None``) a :class:`GeneralizedReedSolomonCode` - ``n_k`` -- (default: ``None``) a pair of integers, respectively the @@ -428,7 +428,7 @@ def _suitable_parameters_given_tau(tau, C=None, n_k=None): INPUT: - - ``tau`` -- an integer, number of errors one wants the Guruswami-Sudan + - ``tau`` -- integer; number of errors one wants the Guruswami-Sudan algorithm to correct - ``C`` -- (default: ``None``) a :class:`GeneralizedReedSolomonCode` - ``n_k`` -- (default: ``None``) a pair of integers, respectively the @@ -498,10 +498,10 @@ def gs_satisfactory(tau, s, l, C=None, n_k=None): INPUT: - - ``tau`` -- an integer, number of errors one expects Guruswami-Sudan algorithm + - ``tau`` -- integer; number of errors one expects Guruswami-Sudan algorithm to correct - - ``s`` -- an integer, multiplicity parameter of Guruswami-Sudan algorithm - - ``l`` -- an integer, list size parameter + - ``s`` -- integer; multiplicity parameter of Guruswami-Sudan algorithm + - ``l`` -- integer; list size parameter - ``C`` -- (default: ``None``) a :class:`GeneralizedReedSolomonCode` - ``n_k`` -- (default: ``None``) a tuple of integers, respectively the length and the dimension of the :class:`GeneralizedReedSolomonCode` diff --git a/src/sage/coding/guruswami_sudan/interpolation.py b/src/sage/coding/guruswami_sudan/interpolation.py index 0fbbd0115c9..de142887a0c 100644 --- a/src/sage/coding/guruswami_sudan/interpolation.py +++ b/src/sage/coding/guruswami_sudan/interpolation.py @@ -36,7 +36,7 @@ def _flatten_once(lstlst): INPUT: - - ``lstlst`` -- a list of lists. + - ``lstlst`` -- list of lists EXAMPLES:: @@ -98,11 +98,11 @@ def _interpolation_matrix_given_monomials(points, s, monomials): INPUT: - - ``points`` -- a list of pairs of field elements, the interpolation points. + - ``points`` -- list of pairs of field elements, the interpolation points - - ``s`` -- an integer, the multiplicity parameter from Guruswami-Sudan algorithm. + - ``s`` -- integer; the multiplicity parameter from Guruswami-Sudan algorithm - - ``monomials`` -- a list of monomials, each represented by the powers as an integer pair `(i,j)`. + - ``monomials`` -- list of monomials, each represented by the powers as an integer pair `(i,j)` EXAMPLES:: @@ -167,16 +167,16 @@ def _interpolation_matrix_problem(points, tau, parameters, wy): INPUT: - - ``points`` -- a list of interpolation points, as pairs of field elements. + - ``points`` -- list of interpolation points, as pairs of field elements - - ``tau`` -- an integer, the number of errors one wants to decode. + - ``tau`` -- integer; the number of errors one wants to decode - ``parameters`` -- (default: ``None``) a pair of integers, where: - the first integer is the multiplicity parameter of Guruswami-Sudan algorithm and - the second integer is the list size parameter. - - ``wy`` -- an integer specifying the `y`-weighted degree that is to be + - ``wy`` -- integer; specifying the `y`-weighted degree that is to be minimised in the interpolation polynomial. In Guruswami-Sudan, this is `k-1`, where `k` is the dimension of the GRS code. @@ -233,10 +233,10 @@ def gs_interpolation_linalg(points, tau, parameters, wy): INPUT: - - ``points`` -- a list of tuples ``(xi, yi)`` such that we seek ``Q`` with + - ``points`` -- list of tuples ``(xi, yi)`` such that we seek ``Q`` with ``(xi,yi)`` being a root of ``Q`` with multiplicity ``s``. - - ``tau`` -- an integer, the number of errors one wants to decode. + - ``tau`` -- integer; the number of errors one wants to decode - ``parameters`` -- (default: ``None``) a pair of integers, where: @@ -244,7 +244,7 @@ def gs_interpolation_linalg(points, tau, parameters, wy): algorithm and - the second integer is the list size parameter. - - ``wy`` -- an integer, the `y`-weight, where we seek `Q` of low + - ``wy`` -- integer; the `y`-weight, where we seek `Q` of low ``(1, wy)``-weighted degree. EXAMPLES: @@ -308,7 +308,7 @@ def lee_osullivan_module(points, parameters, wy): INPUT: - - ``points`` -- a list of tuples ``(xi, yi)`` such that we seek `Q` with + - ``points`` -- list of tuples ``(xi, yi)`` such that we seek `Q` with ``(xi,yi)`` being a root of `Q` with multiplicity `s`. - ``parameters`` -- (default: ``None``) a pair of integers, where: @@ -317,7 +317,7 @@ def lee_osullivan_module(points, parameters, wy): algorithm and - the second integer is the list size parameter. - - ``wy`` -- an integer, the `y`-weight, where we seek `Q` of low + - ``wy`` -- integer; the `y`-weight, where we seek `Q` of low ``(1,wy)`` weighted degree. EXAMPLES:: @@ -362,10 +362,10 @@ def gs_interpolation_lee_osullivan(points, tau, parameters, wy): INPUT: - - ``points`` -- a list of tuples ``(xi, yi)`` such that we seek ``Q`` with + - ``points`` -- list of tuples ``(xi, yi)`` such that we seek ``Q`` with ``(xi,yi)`` being a root of ``Q`` with multiplicity ``s``. - - ``tau`` -- an integer, the number of errors one wants to decode. + - ``tau`` -- integer; the number of errors one wants to decode - ``parameters`` -- (default: ``None``) a pair of integers, where: @@ -373,7 +373,7 @@ def gs_interpolation_lee_osullivan(points, tau, parameters, wy): algorithm and - the second integer is the list size parameter. - - ``wy`` -- an integer, the `y`-weight, where we seek ``Q`` of low + - ``wy`` -- integer; the `y`-weight, where we seek ``Q`` of low ``(1,wy)`` weighted degree. EXAMPLES:: diff --git a/src/sage/coding/guruswami_sudan/utils.py b/src/sage/coding/guruswami_sudan/utils.py index f29d4eac46f..b592091f79f 100644 --- a/src/sage/coding/guruswami_sudan/utils.py +++ b/src/sage/coding/guruswami_sudan/utils.py @@ -35,7 +35,7 @@ def polynomial_to_list(p, len): - ``p`` -- a polynomial - - ``len`` -- an integer. If ``len`` is smaller than the degree of ``p``, the + - ``len`` -- integer; if ``len`` is smaller than the degree of ``p``, the returned list will be of size degree of ``p``, else it will be of size ``len``. EXAMPLES:: @@ -57,8 +57,8 @@ def johnson_radius(n, d): INPUT: - - ``n`` -- an integer, the length of the code - - ``d`` -- an integer, the minimum distance of the code + - ``n`` -- integer; the length of the code + - ``d`` -- integer; the minimum distance of the code EXAMPLES:: @@ -149,7 +149,7 @@ def _degree_of_vector(v, shifts=None): INPUT: - - ``v`` -- a vector of polynomials. + - ``v`` -- a vector of polynomials - ``shifts`` -- (default: ``None``) a list of integer shifts to consider ``v`` under, i.e. compute `\max(\deg v_i + s_i)`, where `s_1,\ldots, s_n` diff --git a/src/sage/coding/information_set_decoder.py b/src/sage/coding/information_set_decoder.py index 06b5e7f8251..0b5c0f8a2bc 100644 --- a/src/sage/coding/information_set_decoder.py +++ b/src/sage/coding/information_set_decoder.py @@ -80,7 +80,7 @@ class InformationSetAlgorithm(SageObject): - ``code`` -- A linear code for which to decode. - - ``number_errors`` -- an integer, the maximal number of errors to accept as + - ``number_errors`` -- integer; the maximal number of errors to accept as correct decoding. An interval can also be specified by giving a pair of integers, where both end values are taken to be in the interval. @@ -670,7 +670,7 @@ class LinearCodeInformationSetDecoder(Decoder): - ``code`` -- A linear code for which to decode. - - ``number_errors`` -- an integer, the maximal number of errors to accept as + - ``number_errors`` -- integer; the maximal number of errors to accept as correct decoding. An interval can also be specified by giving a pair of integers, where both end values are taken to be in the interval. diff --git a/src/sage/coding/linear_code.py b/src/sage/coding/linear_code.py index f7c1f09f21e..b7605e0b60a 100644 --- a/src/sage/coding/linear_code.py +++ b/src/sage/coding/linear_code.py @@ -18,7 +18,7 @@ parity check matrix for `C`. We commonly endow `F^n` with the Hamming metric, i.e. the weight of a vector is -the number of non-zero elements in it. The central operation of a linear code +the number of nonzero elements in it. The central operation of a linear code is then "decoding": given a linear code `C \subset F^n` and a "received word" `r \in F^n` , retrieve the codeword `c \in C` such that the Hamming distance between `r` and `c` is minimal. @@ -253,9 +253,7 @@ def _dump_code_in_leon_format(C): - ``C`` -- a linear code (over GF(p), p < 11) - OUTPUT: - - - Absolute path to the file written + OUTPUT: absolute path to the file written EXAMPLES:: @@ -636,7 +634,7 @@ def assmus_mattson_designs(self, t, mode=None): # S. Pancratz, 19 Jan 2010: In the doctests below, I removed the example # ``C.binomial_moment(3)``, which was also marked as ``#long``. This way, # we shorten the doctests time while still maintaining a zero and a - # non-zero example. + # nonzero example. def binomial_moment(self, i): r""" Return the i-th binomial moment of the `[n,k,d]_q`-code `C`: @@ -1363,9 +1361,7 @@ def minimum_distance(self, algorithm=None): - ``"Guava"``, to use the optional GAP package Guava - OUTPUT: - - - Integer, minimum distance of this code + OUTPUT: integer; minimum distance of this code EXAMPLES:: @@ -1564,9 +1560,7 @@ def permutation_automorphism_group(self, algorithm="partition"): :meth:`~sage.coding.linear_code.LinearCode.canonical_representative` to access it). - OUTPUT: - - - Permutation automorphism group + OUTPUT: permutation automorphism group EXAMPLES:: @@ -1727,9 +1721,7 @@ def punctured(self, L): - ``L`` -- List of positions to puncture - OUTPUT: - - - an instance of :class:`sage.coding.punctured_code` + OUTPUT: an instance of :class:`sage.coding.punctured_code` EXAMPLES:: @@ -1792,9 +1784,7 @@ def shortened(self, L): - ``L`` -- Subset of `\{1,...,n\}`, where `n` is the length of this code - OUTPUT: - - - Linear code, the shortened code described above + OUTPUT: linear code, the shortened code described above EXAMPLES:: @@ -1822,9 +1812,7 @@ def weight_distribution(self, algorithm=None): ``"binary"``, use an algorithm optimized for binary codes. The default is to use ``"binary"`` for binary codes and ``"gap"`` otherwise. - OUTPUT: - - - A list of non-negative integers: the weight distribution. + OUTPUT: a list of nonnegative integers; the weight distribution .. WARNING:: @@ -1916,9 +1904,7 @@ def support(self): Return the set of indices `j` where `A_j` is nonzero, where `A_j` is the number of codewords in ``self`` of Hamming weight `j`. - OUTPUT: - - - List of integers + OUTPUT: list of integers EXAMPLES:: @@ -1952,9 +1938,7 @@ def weight_enumerator(self, names=None, bivariate=True): set to ``False``, then ``names`` will be interpreted as a single variable name and default to ``"x"``. - OUTPUT: - - - The weight enumerator polynomial over `\ZZ`. + OUTPUT: the weight enumerator polynomial over `\ZZ` EXAMPLES:: @@ -2003,9 +1987,7 @@ def zeta_polynomial(self, name="T"): - ``name`` -- String, variable name (default: ``"T"``) - OUTPUT: - - - Polynomial over `\QQ` + OUTPUT: polynomial over `\QQ` EXAMPLES:: @@ -2344,7 +2326,7 @@ def __init__(self, generator, d=None): sage: C = LinearCode(G) Traceback (most recent call last): ... - ValueError: this linear code contains no non-zero vector + ValueError: this linear code contains no nonzero vector """ base_ring = generator.base_ring() @@ -2362,7 +2344,7 @@ def __init__(self, generator, d=None): from sage.matrix.constructor import matrix generator = matrix(base_ring, basis) if generator.nrows() == 0: - raise ValueError("this linear code contains no non-zero vector") + raise ValueError("this linear code contains no nonzero vector") except AttributeError: # Assume input is an AbstractLinearCode, extract its generator matrix generator = generator.generator_matrix() @@ -2889,9 +2871,7 @@ def decode_to_code(self, r): - ``r`` -- a codeword of ``self`` - OUTPUT: - - - a vector of ``self``'s message space + OUTPUT: a vector of ``self``'s message space EXAMPLES:: @@ -3050,9 +3030,7 @@ def decode_to_code(self, r): - ``r`` -- a codeword of ``self`` - OUTPUT: - - - a vector of ``self``'s message space + OUTPUT: a vector of ``self``'s message space EXAMPLES:: diff --git a/src/sage/coding/linear_code_no_metric.py b/src/sage/coding/linear_code_no_metric.py index a3e639516fa..dcfd03af119 100644 --- a/src/sage/coding/linear_code_no_metric.py +++ b/src/sage/coding/linear_code_no_metric.py @@ -390,9 +390,7 @@ def basis(self): r""" Return a basis of ``self``. - OUTPUT: - - - ``Sequence`` -- an immutable sequence whose universe is ambient space of ``self``. + OUTPUT: ``Sequence`` -- an immutable sequence whose universe is ambient space of ``self`` EXAMPLES:: @@ -463,9 +461,7 @@ def syndrome(self, r): - ``r`` -- a vector of the same length as ``self`` - OUTPUT: - - - a column vector + OUTPUT: a column vector EXAMPLES:: @@ -655,9 +651,7 @@ def information_set(self): is called an information set if the corresponding columns form a square matrix of full rank. - OUTPUT: - - - Information set of a systematic generator matrix of the code. + OUTPUT: information set of a systematic generator matrix of the code EXAMPLES:: @@ -681,9 +675,7 @@ def is_information_set(self, positions): - A list of positions, i.e. integers in the range 0 to `n-1` where `n` is the length of ``self``. - OUTPUT: - - - A boolean indicating whether the positions form an information set. + OUTPUT: a boolean indicating whether the positions form an information set EXAMPLES:: diff --git a/src/sage/coding/linear_rank_metric.py b/src/sage/coding/linear_rank_metric.py index 2c7154c9e42..44310f08f5d 100644 --- a/src/sage/coding/linear_rank_metric.py +++ b/src/sage/coding/linear_rank_metric.py @@ -706,7 +706,7 @@ def __init__(self, generator, sub_field=None, basis=None): from sage.matrix.constructor import matrix generator = matrix(base_field, gen_basis) if generator.nrows() == 0: - raise ValueError("this linear code contains no non-zero vector") + raise ValueError("this linear code contains no nonzero vector") except AttributeError: # Assume input is an AbstractLinearRankMetricCode, extract its generator matrix generator = generator.generator_matrix() @@ -854,9 +854,7 @@ def decode_to_code(self, r): - ``r`` -- a codeword of ``self`` - OUTPUT: - - - a vector of ``self``'s message space + OUTPUT: a vector of ``self``'s message space EXAMPLES:: diff --git a/src/sage/coding/parity_check_code.py b/src/sage/coding/parity_check_code.py index 73e7c9b7816..1b0242f973d 100644 --- a/src/sage/coding/parity_check_code.py +++ b/src/sage/coding/parity_check_code.py @@ -293,9 +293,7 @@ def encode(self, message): - ``message`` -- A ``self.code().dimension()``-vector from the message space of ``self``. - OUTPUT: - - - A codeword in associated code of ``self``. + OUTPUT: a codeword in associated code of ``self`` EXAMPLES:: diff --git a/src/sage/coding/punctured_code.py b/src/sage/coding/punctured_code.py index d3ba80146d0..8d29e98d6eb 100644 --- a/src/sage/coding/punctured_code.py +++ b/src/sage/coding/punctured_code.py @@ -277,9 +277,7 @@ def encode(self, m, original_encode=False, encoder_name=None, **kwargs): to encode ``word``. The default encoder of ``self`` will be used if default value is kept - OUTPUT: - - - an element of ``self`` + OUTPUT: an element of ``self`` EXAMPLES:: diff --git a/src/sage/coding/reed_muller_code.py b/src/sage/coding/reed_muller_code.py index 6e35d530c39..afa7bf1ea53 100644 --- a/src/sage/coding/reed_muller_code.py +++ b/src/sage/coding/reed_muller_code.py @@ -847,9 +847,7 @@ def encode(self, p): - ``p`` -- A polynomial from the message space of ``self`` of degree less than ``self.code().order()``. - OUTPUT: - - - A codeword in associated code of ``self`` + OUTPUT: a codeword in associated code of ``self`` EXAMPLES:: diff --git a/src/sage/coding/self_dual_codes.py b/src/sage/coding/self_dual_codes.py index f797a6b09d3..ddcf6f7eb44 100644 --- a/src/sage/coding/self_dual_codes.py +++ b/src/sage/coding/self_dual_codes.py @@ -526,7 +526,7 @@ def self_dual_binary_codes(n): # "(1,5)(2,6)(3,7)(4,8)(10,14)(11,15)(12,16)(13,17)" ] ) spectrum = [1, 0, 1, 0, 28, 0, 28, 0, 198, 0, 198, 0, 28, 0, 28, 0, 1, 0, 1] self_dual_codes_18_3 = {"order autgp":7225344,"code":LinearCode(genmat),"spectrum":spectrum, - "Type":"I","Comment": "Large aut gp. Unique codeword of smallest non-zero wt.\ + "Type":"I","Comment": "Large aut gp. Unique codeword of smallest nonzero wt.\ Same spectrum as '[18,4]' sd code."} # [18,4]: genmat = _I2(n).augment(block_diagonal_matrix([_matA(n)[8],_matId(n)[8]])) @@ -534,7 +534,7 @@ def self_dual_binary_codes(n): # "(5,6)(14,15)", "(4,5)(13,14)", "(3,4)(12,13)", "(2,3)(11,12)", "(1,2)(10,11)" ] ) spectrum = [1, 0, 1, 0, 28, 0, 28, 0, 198, 0, 198, 0, 28, 0, 28, 0, 1, 0, 1] self_dual_codes_18_4 = {"order autgp":10321920,"code":LinearCode(genmat),"spectrum":spectrum, - "Type":"I","Comment": "Huge aut gp. Unique codeword of smallest non-zero wt.\ + "Type":"I","Comment": "Huge aut gp. Unique codeword of smallest nonzero wt.\ Same spectrum as '[18,3]' sd code."} # [18,5]: C = self_dual_binary_codes(n-2)["%s" % (n-2)]["5"]["code"] @@ -558,7 +558,7 @@ def self_dual_binary_codes(n): "(1,4)(2,6)(3,7)(5,17)(8,14)(10,13)(11,15)(12,16)" ] ) spectrum = [1, 0, 1, 0, 12, 0, 76, 0, 166, 0, 166, 0, 76, 0, 12, 0, 1, 0, 1] self_dual_codes_18_6 = {"order autgp":147456,"code":LinearCode(genmat),"spectrum":spectrum, - "Type":"I","Comment": "'Exceptional'. Unique codeword of smallest non-zero wt."} + "Type":"I","Comment": "'Exceptional'. Unique codeword of smallest nonzero wt."} # [18,7] (equiv to H18 in [P]) genmat = _MS(n)([[1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,1], diff --git a/src/sage/coding/source_coding/huffman.py b/src/sage/coding/source_coding/huffman.py index d11cf5410ed..631c9848fdb 100644 --- a/src/sage/coding/source_coding/huffman.py +++ b/src/sage/coding/source_coding/huffman.py @@ -45,7 +45,7 @@ def frequency_table(string): INPUT: - - ``string`` -- a string of symbols over some alphabet. + - ``string`` -- a string of symbols over some alphabet OUTPUT: @@ -377,7 +377,7 @@ def encode(self, string): INPUT: - - ``string`` -- a string of symbols over an alphabet. + - ``string`` -- a string of symbols over an alphabet OUTPUT: a Huffman encoding of ``string`` @@ -402,7 +402,7 @@ def decode(self, string): INPUT: - - ``string`` -- a string of Huffman encodings. + - ``string`` -- a string of Huffman encodings OUTPUT: the Huffman decoding of ``string`` @@ -519,7 +519,7 @@ def _generate_edges(self, tree, parent="", bit=""): INPUT: - - ``tree`` -- a Huffman binary tree. + - ``tree`` -- a Huffman binary tree - ``parent`` -- (default: empty string) a parent vertex with exactly two children. diff --git a/src/sage/combinat/affine_permutation.py b/src/sage/combinat/affine_permutation.py index dae4d8a4c3a..b21c2513d50 100644 --- a/src/sage/combinat/affine_permutation.py +++ b/src/sage/combinat/affine_permutation.py @@ -906,7 +906,7 @@ def is_fully_commutative(self) -> bool: if m != -1 and c[i] - (i - m) >= c[m]: return False m = i - # now check m (the last non-zero) against first non-zero. + # now check m (the last nonzero) against first nonzero. d = self.n - (m - firstnonzero) return not c[firstnonzero] - d >= c[m] @@ -2167,7 +2167,7 @@ def random_element(self, n=None): Return a random affine permutation of length ``n``. If ``n`` is not specified, then ``n`` is chosen as a random - non-negative integer in `[0, 1000]`. + nonnegative integer in `[0, 1000]`. Starts at the identity, then chooses an upper cover at random. Not very uniform: actually constructs a uniformly random reduced word diff --git a/src/sage/combinat/alternating_sign_matrix.py b/src/sage/combinat/alternating_sign_matrix.py index 944091eb74e..13a939a6873 100644 --- a/src/sage/combinat/alternating_sign_matrix.py +++ b/src/sage/combinat/alternating_sign_matrix.py @@ -84,7 +84,7 @@ class AlternatingSignMatrix(Element, An alternating sign matrix. An alternating sign matrix is a square matrix of `0`'s, `1`'s and `-1`'s - such that the sum of each row and column is `1` and the non-zero + such that the sum of each row and column is `1` and the nonzero entries in each row and column alternate in sign. These were introduced in [MRR1983]_. @@ -1020,7 +1020,7 @@ class AlternatingSignMatrices(UniqueRepresentation, Parent): An alternating sign matrix of size `n` is an `n \times n` matrix of `0`'s, `1`'s and `-1`'s such that the sum of each row and column is `1` and the - non-zero entries in each row and column alternate in sign. + nonzero entries in each row and column alternate in sign. Alternating sign matrices of size `n` are in bijection with :class:`monotone triangles ` with `n` rows. diff --git a/src/sage/env.py b/src/sage/env.py index 12e340cd580..6cf9a5e49c8 100644 --- a/src/sage/env.py +++ b/src/sage/env.py @@ -74,13 +74,13 @@ def var(key: str, *fallbacks: Optional[str], force: bool = False) -> Optional[st INPUT: - - ``key`` -- string. + - ``key`` -- string - - ``fallbacks`` -- tuple containing ``str`` or ``None`` values. + - ``fallbacks`` -- tuple containing ``str`` or ``None`` values - - ``force`` -- boolean (default: ``False``). If + - ``force`` -- boolean (default: ``False``); if ``True``, skip the environment variable and only use the - fallbacks. + fallbacks OUTPUT: the value of the environment variable or its fallbacks