passagemath-fricas 10.5.40__cp310-cp310-macosx_14_0_arm64.whl → 10.5.41__cp310-cp310-macosx_14_0_arm64.whl

sage_wheels/lib/fricas/target/aarch64-apple-darwin23.6.0/src/algebra/nregset.spad

@@ -9,12 +9,13 @@
 ++ Description:
 ++ The category of normalized triangular sets. A triangular
 ++ set \spad{ts} is said normalized if for every algebraic
-++ variable \spad{v} of \spad{ts} the polynomial \spad{select(ts, v)}
-++ is normalized w.r.t. every polynomial in \spad{collectUnder(ts, v)}.
-++ A polynomial \spad{p} is said normalized w.r.t. a non-constant
+++ variable \spad{v} of \spad{ts} the polynomial \spad{select(ts, v)} is
+++ normalized with respect to every polynomial in \spad{collectUnder(ts, v)}.
+++ A polynomial \spad{p} is said normalized with respect to a non-constant
 ++ polynomial \spad{q} if \spad{p} is constant or \spad{degree(p, mdeg(q)) = 0}
-++ and \spad{init(p)} is normalized w.r.t. \spad{q}. One of the important
-++ features of normalized triangular sets is that they are regular sets.
+++ and \spad{init(p)} is normalized with respect to \spad{q}. One of the
+++ important features of normalized triangular sets is that they are
+++ regular sets.
 ++ References:
 ++  [1] D. LAZARD "A new method for solving algebraic systems of
 ++      positive dimension" Discr. App. Math. 33:147-160,1991
@@ -25,7 +26,7 @@
 ++      Paris, 1995.
 ++  [4] M. MORENO MAZA "Calculs de pgcd au-dessus des tours
 ++      d'extensions simples et resolution des systemes d'equations
-++      algebriques" These, Universite P.etM. Curie, Paris, 1997.
+++      algebriques" These, Universite P. et M. Curie, Paris, 1997.
 
 
 NormalizedTriangularSetCategory(R : GcdDomain, E : OrderedAbelianMonoidSup, _
@@ -41,7 +42,7 @@ NormalizedTriangularSetCategory(R : GcdDomain, E : OrderedAbelianMonoidSup, _
 ++ AMS Classifications:
 ++ Keywords:
 ++ Description:
-++ A package for computing normalized assocites of univariate polynomials
+++ A package for computing normalized associates of univariate polynomials
 ++ with coefficients in a tower of simple extensions of a field.
 ++ References:
 ++  [1] D. LAZARD "A new method for solving algebraic systems of
@@ -51,7 +52,7 @@ NormalizedTriangularSetCategory(R : GcdDomain, E : OrderedAbelianMonoidSup, _
 ++      Paris, 1995.
 ++  [3] M. MORENO MAZA "Calculs de pgcd au-dessus des tours
 ++      d'extensions simples et resolution des systemes d'equations
-++      algebriques" These, Universite P.etM. Curie, Paris, 1997.
+++      algebriques" These, Universite P. et M. Curie, Paris, 1997.
 ++ Version: 1.
 
 NormalizationPackage(R, E, V, P, TS) : Exports == Implementation where
@@ -84,21 +85,23 @@ NormalizationPackage(R, E, V, P, TS) : Exports == Implementation where
   Exports ==  with
 
      recip : (P, TS) -> Record(num : P, den : P)
-       ++ \spad{recip(p, ts)} returns the inverse of \spad{p} w.r.t \spad{ts}
-       ++ assuming that \spad{p} is invertible w.r.t \spad{ts}.
+       ++ \spad{recip(p, ts)} returns the inverse of \spad{p} with respect to
+       ++ \spad{ts} assuming that \spad{p} is invertible with respect to
+       ++ \spad{ts}.
      normalizedAssociate : (P, TS) -> P
        ++ \spad{normalizedAssociate(p, ts)} returns a normalized polynomial
-       ++ \spad{n} w.r.t. \spad{ts} such that \spad{n} and \spad{p} are
-       ++ associates w.r.t \spad{ts} and assuming that \spad{p} is invertible
-       ++ w.r.t \spad{ts}.
+       ++ \spad{n} with respect to \spad{ts} such that \spad{n} and \spad{p}
+       ++ are associates with respect to \spad{ts} and assuming that \spad{p}
+       ++ is invertible with respect to \spad{ts}.
      normalize : (P, TS) -> List PWT
-       ++ \spad{normalize(p, ts)} normalizes \spad{p} w.r.t \spad{ts}.
+       ++ \spad{normalize(p, ts)} normalizes \spad{p} with respect to
+       ++ \spad{ts}.
      outputArgs : (S, S, P, TS) -> Void
        ++ \spad{outputArgs(s1, s2, p, ts)}
-       ++ is an internal subroutine, exported only for developement.
+       ++ is an internal subroutine, exported only for development.
      normInvertible? : (P, TS) -> List BWT
        ++ \spad{normInvertible?(p, ts)}
-       ++ is an internal subroutine, exported only for developement.
+       ++ is an internal subroutine, exported only for development.
 
   Implementation == add
 
@@ -202,7 +205,7 @@ NormalizationPackage(R, E, V, P, TS) : Exports == Implementation where
        zero? p => [[p, ts]$PWT]
        ground? p => [[1, ts]$PWT]
        zero? initiallyReduce(init(p), ts) =>
-         error "in normalize$NORMPK: init(#1) reduces to 0 w.r.t. #2"
+         error "in normalize$NORMPK: init(#1) reduces to 0 with respect to #2"
        --output("Entering  normalize")$OutputPackage
        --outputArgs("p = ", " ts = ",p,ts)
        --output("Calling  normInvertible?")$OutputPackage

sage_wheels/lib/fricas/target/aarch64-apple-darwin23.6.0/src/algebra/numode.spad

@@ -61,7 +61,7 @@
 ++ \centerline{\spad{hnext} = 0.9 * hdid * (\spad{error}/\spad{eps})^(-1/5)}
 ++ Otherwise \spad{hnext = 4.0 * hdid} is returned.
 ++ A more detailed discussion of this and related topics can be
-++ found in the book "Numerical Recipies" by W.Press, B.P. Flannery,
+++ found in the book "Numerical Recipes" by W.Press, B.P. Flannery,
 ++ S.A. Teukolsky, W.T. Vetterling published by Cambridge University Press.
 ++ Argument \spad{step} is a record of 3 floating point
 ++ numbers \spad{(to_try , did , next)},
@@ -121,13 +121,13 @@ NumericalOrdinaryDifferentialEquations() : Exports == Implementation where
      ++ rk4(y, n, x1, h, derivs, t1, t2, t3, t4) is the same as
      ++ \spad{rk4(y, n, x1, h, derivs)} except that you must provide 4 scratch
      ++ arrays t1-t4 of size n.
-     ++ For details, see \con{NumericalOrdinaryDifferentialEquations}.
+     ++ For details, see \spadtype{NumericalOrdinaryDifferentialEquations}.
    rk4a  : (V NF, I, NF, NF, NF, NF, I, (V NF, V NF, NF) -> VOID ) -> VOID
      ++ rk4a(y, n, x1, x2, eps, h, ns, derivs) is a driver function for the
      ++ numerical integration of an ordinary differential equation
      ++ {\em dy/dx = f(y, x)} of n variables, where y is an n-vector
      ++ using a 4-th order Runge-Kutta method.
-     ++ For details, see \con{NumericalOrdinaryDifferentialEquations}.
+     ++ For details, see \spadtype{NumericalOrdinaryDifferentialEquations}.
    rk4qc : (V NF, I, NF, RK4STEP, NF, V NF, (V NF, V NF, NF) -> VOID) -> VOID
      ++ rk4qc(y, n, x1, step, eps, yscal, derivs) is a subfunction for the
      ++ numerical integration of an ordinary differential equation
@@ -135,7 +135,7 @@ NumericalOrdinaryDifferentialEquations() : Exports == Implementation where
      ++ using a 4-th order Runge-Kutta method.
      ++ This function takes a 5-th order Runge-Kutta step with monitoring
      ++ of local truncation to ensure accuracy and adjust stepsize.
-     ++ For details, see \con{NumericalOrdinaryDifferentialEquations}.
+     ++ For details, see \spadtype{NumericalOrdinaryDifferentialEquations}.
    rk4qc : (V NF, I, NF, RK4STEP, NF, V NF, (V NF, V NF, NF) -> VOID
            , V NF, V NF, V NF, V NF, V NF, V NF, V NF) -> VOID
      ++ rk4qc(y, n, x1, step, eps, yscal, derivs, t1, t2, t3, t4, t5, t6, t7) is a subfunction for the
@@ -144,7 +144,7 @@ NumericalOrdinaryDifferentialEquations() : Exports == Implementation where
      ++ using a 4-th order Runge-Kutta method.
      ++ This function takes a 5-th order Runge-Kutta step with monitoring
      ++ of local truncation to ensure accuracy and adjust stepsize.
-     ++ For details, see \con{NumericalOrdinaryDifferentialEquations}.
+     ++ For details, see \spadtype{NumericalOrdinaryDifferentialEquations}.
    rk4f  : (V NF, I, NF, NF, I, (V NF, V NF, NF) -> VOID ) -> VOID
      ++ rk4f(y, n, x1, x2, ns, derivs) uses a 4-th order Runge-Kutta method
      ++ to numerically integrate the ordinary differential equation
@@ -152,7 +152,7 @@ NumericalOrdinaryDifferentialEquations() : Exports == Implementation where
      ++ Starting with y at x1, this function uses \spad{ns} fixed
      ++ steps of a 4-th order Runge-Kutta integrator to advance the
      ++ solution vector to x2 and return the values in y.
-     ++ For details, see \con{NumericalOrdinaryDifferentialEquations}.
+     ++ For details, see \spadtype{NumericalOrdinaryDifferentialEquations}.
 
   Implementation ==>  add
   --some local function definitions here

sage_wheels/lib/fricas/target/aarch64-apple-darwin23.6.0/src/algebra/numquad.spad

@@ -124,7 +124,7 @@ NumericalQuadrature(F : FloatingPointSystem) : Exports == Implementation where
      ++ See \spadtype{NumericalQuadrature} for details.
    romberg      : (F -> F, F, F, F, F, I, I) -> TrapAns
      ++ romberg(fn, a, b, epsrel, epsabs, nmin, nmax) uses the romberg
-     ++ method to numerically integrate function \spadvar{fn} over the closed
+     ++ method to numerically integrate function \spad{fn} over the closed
      ++ interval \spad{a} to \spad{b}, with relative accuracy \spad{epsrel}
      ++ and absolute accuracy \spad{epsabs}, with the refinement levels
      ++ for convergence checking vary from \spad{nmin} to \spad{nmax}.
@@ -147,7 +147,7 @@ NumericalQuadrature(F : FloatingPointSystem) : Exports == Implementation where
      ++ See \spadtype{NumericalQuadrature} for details.
    trapezoidal  : (F -> F, F, F, F, F, I, I) -> TrapAns
      ++ trapezoidal(fn, a, b, epsrel, epsabs, nmin, nmax) uses the
-     ++ trapezoidal method to numerically integrate function \spadvar{fn} over
+     ++ trapezoidal method to numerically integrate function \spad{fn} over
      ++ the closed interval \spad{a} to \spad{b}, with relative accuracy
      ++ \spad{epsrel} and absolute accuracy \spad{epsabs}, with the
      ++ refinement levels for convergence checking vary

sage_wheels/lib/fricas/target/aarch64-apple-darwin23.6.0/src/algebra/numsolve.spad

@@ -38,6 +38,7 @@ ComplexRootPackage(UP, Par) : T == C where
    C == add
 
     import from Factored(UP)
+    import from Factored(SparseUnivariatePolynomial(Complex(Integer)))
 
     complexZeros(p : UP, eps : Par) : List CP ==
       x1 : Symbol() := new()

sage_wheels/lib/fricas/target/aarch64-apple-darwin23.6.0/src/algebra/numtheor.spad

@@ -53,7 +53,7 @@ Finding the gcd of 81 and 57 by the {\bf Euclidean Algorithm}:
 \end{array}
 \]
 
-So the greatest commmon divisor, the GCD(81, 51)=3.
+So the greatest common divisor, the GCD(81, 51)=3.
 
 If the gcd(a, b) = r then there exist integers s and t so that
 \[s(a) + t(b) = r\]
@@ -95,7 +95,7 @@ The extended Euclidean algorithm calculates $s$ efficiently.
 
 We will number the steps of the Euclidean algorithm starting
 with step 0. The quotient obtained at step $i$ will be denoted by $q_i$
-and an auxillary number, $s_i$. For the first two steps, the value
+and an auxiliary number, $s_i$. For the first two steps, the value
 of this number is given : $s_0 = 0$ and $s_1 = 1$. For the remainder of the
 steps, we recursively calculate
 \[s_i = s_{i-2} - s_{i-1} q_{i-2} {\rm\ (mod\ n)}\]

sage_wheels/lib/fricas/target/aarch64-apple-darwin23.6.0/src/algebra/odeef.spad

@@ -596,8 +596,8 @@ ElementaryFunctionLODESolver(R, F, L) : Exports == Implementation where
       ++ found; When found, the solution is returned in the form
       ++ \spad{[h, [b1, ..., bm]]} where \spad{h} is a particular solution and
       ++ and \spad{[b1, ...bm]} are linearly independent solutions of the
-      ++ associated homogenuous equation \spad{op y = 0}.
-      ++ A full basis for the solutions of the homogenuous equation
+      ++ associated homogeneous equation \spad{op y = 0}.
+      ++ A full basis for the solutions of the homogeneous equation
       ++ is not always returned, only the solutions which were found;
       ++ \spad{x} is the dependent variable.
     solve : (L, F, SY, F, List F) -> Union(F, "failed")
@@ -877,14 +877,14 @@ ElementaryFunctionODESolver(R, F) : Exports == Implementation where
       ++ or, if the equations form a fist order linear system, a solution
       ++ of the form \spad{[y_p, [b_1, ..., b_n]]} where \spad{h_p} is a
       ++ particular solution and \spad{[b_1, ...b_m]} are linearly independent
-      ++ solutions of the associated homogenuous system.
+      ++ solutions of the associated homogeneous system.
       ++ error if the equations do not form a first order linear system
     solve : (List F, List OP, SY) -> Union(VEC, "failed")
       ++ solve([eq_1,...,eq_n], [y_1,...,y_n], x) returns either "failed"
       ++ or, if the equations form a fist order linear system, a solution
       ++ of the form \spad{[y_p, [b_1, ..., b_n]]} where \spad{h_p} is a
       ++ particular solution and \spad{[b_1, ...b_m]} are linearly independent
-      ++ solutions of the associated homogenuous system.
+      ++ solutions of the associated homogeneous system.
       ++ error if the equations do not form a first order linear system
     solve : (EQ, OP, SY) -> U
       ++ solve(eq, y, x) returns either a solution of the ordinary differential
@@ -892,8 +892,8 @@ ElementaryFunctionODESolver(R, F) : Exports == Implementation where
       ++ If the equation is linear ordinary, a solution is of the form
       ++ \spad{[h, [b1, ..., bm]]} where \spad{h} is a particular solution
       ++ and \spad{[b1, ...bm]} are linearly independent solutions of the
-      ++ associated homogenuous equation \spad{f(x, y) = 0};
-      ++ A full basis for the solutions of the homogenuous equation
+      ++ associated homogeneous equation \spad{f(x, y) = 0};
+      ++ A full basis for the solutions of the homogeneous equation
       ++ is not always returned, only the solutions which were found;
       ++ If the equation is of the form {dy/dx = f(x, y)}, a solution is of
       ++ the form \spad{h(x, y)} where \spad{h(x, y) = c} is a first integral
@@ -905,8 +905,8 @@ ElementaryFunctionODESolver(R, F) : Exports == Implementation where
       ++ If the equation is linear ordinary, a solution is of the form
       ++ \spad{[h, [b1, ..., bm]]} where \spad{h} is a particular solution and
       ++ and \spad{[b1, ...bm]} are linearly independent solutions of the
-      ++ associated homogenuous equation \spad{f(x, y) = 0};
-      ++ A full basis for the solutions of the homogenuous equation
+      ++ associated homogeneous equation \spad{f(x, y) = 0};
+      ++ A full basis for the solutions of the homogeneous equation
       ++ is not always returned, only the solutions which were found;
       ++ If the equation is of the form {dy/dx = f(x, y)}, a solution is of
       ++ the form \spad{h(x, y)} where \spad{h(x, y) = c} is a first integral

sage_wheels/lib/fricas/target/aarch64-apple-darwin23.6.0/src/algebra/op.spad

@@ -435,10 +435,18 @@ CommonOperators() : Exports == Implementation where
 
     -- orthogonal polynomials
     opCharlierC := operator('charlierC, 3)$OP
+    op_hahn_p := operator('hahn_p, 5)$OP
+    op_hahnQ := operator('hahnQ, 5)$OP
+    op_hahnR := operator('hahnR, 5)$OP
+    op_hahnS := operator('hahnS, 5)$OP
     opHermiteH := operator('hermiteH, 2)$OP
     opJacobiP := operator('jacobiP, 4)$OP
+    op_krawtchoukK := operator('krawtchoukK, 4)$OP
     opLaguerreL := operator('laguerreL, 3)$OP
     opMeixnerM := operator('meixnerM, 4)$OP
+    op_meixnerP := operator('meixnerP, 4)$OP
+    op_racahR := operator('racahR, 6)$OP
+    op_wilsonW := operator('wilsonW, 6)$OP
 
     op_log_gamma := operator('%logGamma, 1)$OP
     op_eis := operator('%eis, 1)$OP
@@ -524,10 +532,14 @@ CommonOperators() : Exports == Implementation where
     opLerchPhi, _
     opRiemannZeta, _
     opCharlierC, _
+    op_hahn_p, op_hahnQ, op_hahnR, op_hahnS, _
     opHermiteH, _
     opJacobiP, _
+    op_krawtchoukK, _
     opLaguerreL, _
-    opMeixnerM, _
+    opMeixnerM, op_meixnerP, _
+    op_racahR, _
+    op_wilsonW, _
     opWeierstrassPInverse _
     ]
 

sage_wheels/lib/fricas/target/aarch64-apple-darwin23.6.0/src/algebra/outform.spad

@@ -469,6 +469,8 @@ OutputForm() : Join(SetCategory, ConvertibleTo InputForm) with
         outputForm s ==
           sform concat(quote()$Character, concat(s, quote()$Character))
 
+        import from Character
+
         convert(a: %): InputForm ==
             b: SExpression := a pretend SExpression
             if atom?(b)$SExpression then
@@ -499,7 +501,7 @@ OutputForm() : Join(SetCategory, ConvertibleTo InputForm) with
 
         hspace(n) ==
           n = 0 => empty()
-          sform(fillerSpaces(n, " ")$Lisp)
+          sform(filler_spaces(n)$Lisp)
 
         rspace(n, m) ==
           n = 0 or m = 0 => empty()

sage_wheels/lib/fricas/target/aarch64-apple-darwin23.6.0/src/algebra/pade.spad

@@ -1,12 +1,12 @@
 )abbrev package PADEPAC PadeApproximantPackage
-++ This package computes reliable Pad&ea. approximants using
-++ a generalized Viskovatov continued fraction algorithm.
 ++ Authors: Trager, Burge, Hassner & Watt.
 ++ Date Created: April 1987
 ++ Keywords: Pade, series
 ++ Examples:
 ++ References:
 ++   "Pade Approximants, Part I: Basic Theory", Baker & Graves-Morris.
+++ Description: This package computes reliable Pade approximants using
+++ a generalized Viskovatov continued fraction algorithm.
 
 PadeApproximantPackage(R : Field, x : Symbol, pt : R) : Exports == Implementation where
    PS ==> UnivariateTaylorSeries(R, x, pt)
@@ -46,14 +46,14 @@ PadeApproximantPackage(R : Field, x : Symbol, pt : R) : Exports == Implementatio
      pade(n, m, u) == pade(n, m, u, 1)
 
 )abbrev package PADE PadeApproximants
-++ This package computes reliable Pad&ea. approximants using
-++ a generalized Viskovatov continued fraction algorithm.
 ++ Authors: Burge, Hassner & Watt.
 ++ Date Created: April 1987
 ++ Keywords: Pade, series
 ++ Examples:
 ++ References:
 ++   "Pade Approximants, Part I: Basic Theory", Baker & Graves-Morris.
+++ Description: This package computes reliable Pade approximants using
+++ a generalized Viskovatov continued fraction algorithm.
 PadeApproximants(R, PS, UP) : Exports == Implementation where
   R :  Field -- IntegralDomain
   PS : UnivariateTaylorSeriesCategory R

sage_wheels/lib/fricas/target/aarch64-apple-darwin23.6.0/src/algebra/padic.spad

@@ -8,7 +8,7 @@
 ++ Keywords: p-adic, completion
 ++ Examples:
 ++ References:
-++ Description: This is the catefory of stream-based representations of
+++ Description: This is the category of stream-based representations of
 ++   the p-adic integers.
 PAdicIntegerCategory(p) : Category == Definition where
   p   :   Integer
@@ -51,7 +51,6 @@ PAdicIntegerCategory(p) : Category == Definition where
 ++ Related Domains:
 ++ Also See:
 ++ AMS Classifications:
-++ Keywords:
 ++ Keywords: p-adic, completion
 ++ Examples:
 ++ References:
@@ -300,7 +299,6 @@ InnerPAdicInteger(p, unBalanced?) : Exports == Implementation where
 ++ Related Domains:
 ++ Also See:
 ++ AMS Classifications:
-++ Keywords:
 ++ Keywords: p-adic, completion
 ++ Examples:
 ++ References:
@@ -316,7 +314,7 @@ PAdicInteger(p : Integer) == InnerPAdicInteger(p, true$Boolean)
 ++ Related Domains:
 ++ Also See:
 ++ AMS Classifications:
-++ Keywords: p-adic, complementation
+++ Keywords: p-adic, completion
 ++ Examples:
 ++ References:
 ++ Description:
@@ -331,7 +329,6 @@ BalancedPAdicInteger(p : Integer) == InnerPAdicInteger(p, false$Boolean)
 ++ Related Domains:
 ++ Also See:
 ++ AMS Classifications:
-++ Keywords:
 ++ Keywords: p-adic, completion
 ++ Examples:
 ++ References:
@@ -543,7 +540,6 @@ PAdicRationalConstructor(p, PADIC) : Exports == Implementation where
 )abbrev domain PADICRAT PAdicRational
 ++ Author: Clifton J. Williamson
 ++ Date Created: 15 May 1990
-++ Keywords: p-adic, complementation
 ++ Basic Operations:
 ++ Related Domains:
 ++ Also See:
@@ -559,7 +555,6 @@ PAdicRational(p : Integer) == PAdicRationalConstructor(p, PAdicInteger p)
 )abbrev domain BPADICRT BalancedPAdicRational
 ++ Author: Clifton J. Williamson
 ++ Date Created: 15 May 1990
-++ Keywords: p-adic, complementation
 ++ Basic Operations:
 ++ Related Domains:
 ++ Also See:

sage_wheels/lib/fricas/target/aarch64-apple-darwin23.6.0/src/algebra/padiclib.spad

@@ -95,7 +95,7 @@ IntegralBasisPolynomialTools(K, R, UP, L) : Exports == Implementation where
 ++ Keywords: function field, finite field, integral basis
 ++ Examples:
 ++ References:
-++ Description:
+++ Description: Modular helpers for computing integral bases.
 
 ChineseRemainderToolsForIntegralBases(K, R, UP) : Exports == Implementation where
   K  : FiniteFieldCategory

sage_wheels/lib/fricas/target/aarch64-apple-darwin23.6.0/src/algebra/patmatch1.spad

@@ -881,7 +881,7 @@ PatternMatchFunctionSpace(S, R, F) : Exports== Implementation where
 ++ Author: Manuel Bronstein
 ++ Date Created: 3 Dec 1989
 ++ Description:
-++   This package provides the top-level pattern macthing functions.
+++   This package provides the top-level pattern matching functions.
 ++ Keywords: pattern, matching.
 PatternMatch(Base, Subject, Pat) : Exports == Implementation where
   Base   : SetCategory

sage_wheels/lib/fricas/target/aarch64-apple-darwin23.6.0/src/algebra/perm.spad

@@ -21,7 +21,7 @@ PermutationCategory(S : SetCategory) : Category  ==  Group with
       ++ to a permutation, each cycle being a list with not
       ++ repetitions, is coerced to the permutation, which maps
       ++ {\em ls.i} to {\em ls.i+1}, indices modulo the length of the list,
-      ++ then these permutations are mutiplied.
+      ++ then these permutations are multiplied.
       ++ Error: if repetitions occur in one cycle.
     eval  :  (%, S)          ->  S
       ++ eval(p, el) returns the image of {\em el} under the
@@ -56,7 +56,7 @@ PermutationCategory(S : SetCategory) : Category  ==  Group with
 ++   A permutation is considered as a map from S into S. In particular
 ++   multiplication is defined as composition of maps:
 ++   {\em pi1 * pi2 = pi1 o pi2}.
-++   The internal representation of permuatations are two lists
+++   The internal representation of permutations are two lists
 ++   of equal length representing preimages and images.
 
 Permutation(S : SetCategory) : public == private where
@@ -90,7 +90,7 @@ Permutation(S : SetCategory) : public == private where
       ++ permutation, each cycle being a list with no
       ++ repetitions, is coerced to the permutation, which maps
       ++ {\em ls.i} to {\em ls.i+1}, indices modulo the length of the list,
-      ++ then these permutations are mutiplied.
+      ++ then these permutations are multiplied.
       ++ Error: if repetitions occur in one cycle.
     coerce            :  List S           ->  %
       ++ coerce(ls) coerces a cycle {\em ls}, i.e. a list with not
@@ -310,7 +310,7 @@ removes fixed points from its result.
       out : Set S := set(list(el))
       el2 := eval(p, el)
       while el2 ~= el repeat
-        -- be carefull: insert adds one element
+        -- be careful: insert adds one element
         -- as side effect to out
         insert!(el2, out)
         el2 := eval(p, el2)

sage_wheels/lib/fricas/target/aarch64-apple-darwin23.6.0/src/algebra/permgrps.spad

@@ -121,7 +121,7 @@ PermutationGroup(S : SetCategory) : public == private where
       ++ 0 and 1: {\em initializeGroupForWordProblem(gp, 0, 1)}.
       ++ Notes: (1) be careful: invoking this routine will destroy the
       ++ possibly information about your group (but will recompute it again)
-      ++ (2) users need not call this function normally for the soultion of
+      ++ (2) users need not call this function normally for the solution of
       ++ the word problem.
     initializeGroupForWordProblem : (%, I, I) -> Void
       ++ initializeGroupForWordProblem(gp, m, n) initializes the group
@@ -130,7 +130,7 @@ PermutationGroup(S : SetCategory) : public == private where
       ++ routine takes longer than the standard routine for longer words.
       ++ (2) be careful: invoking this routine will destroy the possibly stored
       ++ information about your group (but will recompute it again).
-      ++ (3) users need not call this function normally for the soultion of
+      ++ (3) users need not call this function normally for the solution of
       ++ the word problem.
     relationsInStrongGenerators : % -> L(L(I))
       ++ relationsInStrongGenerators(gp) computes relations between

sage_wheels/lib/fricas/target/aarch64-apple-darwin23.6.0/src/algebra/pfo.spad

@@ -1,7 +1,8 @@
 )abbrev package FORDER FindOrderFinite
-++ Finds the order of a divisor over a finite field
 ++ Author: Manuel Bronstein
 ++ Date Created: 1988
+++ Description: This package finds the order of a divisor over a finite
+++  field.
 FindOrderFinite(F, UP, UPUP, R) : Exports == Implementation where
   F   : Join(Finite, Field)
   UP  : UnivariatePolynomialCategory F
@@ -19,9 +20,10 @@ FindOrderFinite(F, UP, UPUP, R) : Exports == Implementation where
         dd := reduce(d + dd)
 
 )abbrev package RDIV ReducedDivisor
-++ Finds the order of a divisor over a finite field
 ++ Author: Manuel Bronstein
 ++ Date Created: 1988
+++ Description: This package finds the order of a divisor over a field
+++  using reduction to finite field.
 ReducedDivisor(F1, UP, UPUP, R, F2) : Exports == Implementation where
   F1    : Field
   UP    : UnivariatePolynomialCategory F1
@@ -65,9 +67,9 @@ ReducedDivisor(F1, UP, UPUP, R, F2) : Exports == Implementation where
                                  )$FindOrderFinite(F2, UP2, UPUP2, curve)
 
 )abbrev package PFOTOOLS PointsOfFiniteOrderTools
-++ Utilities for PFOQ and PFO
 ++ Author: Manuel Bronstein
 ++ Date Created: 25 Aug 1988
+++ Description: Utilities for PFOQ and PFO.
 PointsOfFiniteOrderTools(UP, UPUP) : Exports == Implementation where
   UP   : UnivariatePolynomialCategory Fraction Integer
   UPUP : UnivariatePolynomialCategory Fraction UP
@@ -117,14 +119,13 @@ PointsOfFiniteOrderTools(UP, UPUP) : Exports == Implementation where
       retract(discriminant((d exquo gcd(d, differentiate d))::UP))@Z
 
 )abbrev package PFOQ PointsOfFiniteOrderRational
-++ Finds the order of a divisor on a rational curve
 ++ Author: Manuel Bronstein
 ++ Date Created: 25 Aug 1988
 ++ Description:
 ++ This package provides function for testing whether a divisor on a
 ++ curve is a torsion divisor.
 ++ Keywords: divisor, algebraic, curve.
-++ Examples: )r PFOQ INPUT
+++ Description: Finds the order of a divisor on a rational curve.
 -- Currently unused.
 PointsOfFiniteOrderRational(UP, UPUP, R) : Exports == Implementation where
   UP   : UnivariatePolynomialCategory Fraction Integer
@@ -193,7 +194,6 @@ PointsOfFiniteOrderRational(UP, UPUP, R) : Exports == Implementation where
       [n, g@R]
 
 )abbrev package FSRED FunctionSpaceReduce
-++ Reduction from a function space to the rational numbers
 ++ Author: Manuel Bronstein
 ++ Date Created: 1988
 ++ Description:
@@ -201,6 +201,7 @@ PointsOfFiniteOrderRational(UP, UPUP, R) : Exports == Implementation where
 ++ in a function space by random integers. The correspondence between
 ++ the kernels and the integers is fixed between calls to newReduc().
 ++ Keywords: function, space, redcution.
+++ Description: Reduction from a function space to the rational numbers.
 FunctionSpaceReduce(R, F) : Exports == Implementation where
   R : Join(Comparable, IntegralDomain, RetractableTo Integer)
   F : FunctionSpace R
@@ -256,14 +257,13 @@ FunctionSpaceReduce(R, F) : Exports == Implementation where
       u@Z::F
 
 )abbrev package PFO PointsOfFiniteOrder
-++ Finds the order of a divisor on a curve
 ++ Author: Manuel Bronstein
 ++ Date Created: 1988
 ++ Description:
 ++ This package provides function for testing whether a divisor on a
 ++ curve is a torsion divisor.
 ++ Keywords: divisor, algebraic, curve.
-++ Examples: )r PFO INPUT
+++ Description: Finds the order of a divisor on a curve.
 PointsOfFiniteOrder(R0, F, UP, UPUP, R) : Exports == Implementation where
   R0   : Join(Comparable, IntegralDomain, RetractableTo Integer)
   F    : FunctionSpace R0

sage_wheels/lib/fricas/target/aarch64-apple-darwin23.6.0/src/algebra/polset.spad

@@ -68,24 +68,27 @@ PolynomialSetCategory(R : Ring, E : OrderedAbelianMonoidSup, _
            ++ \spad{roughUnitIdeal?(ps)} returns true iff \spad{ps} contains some
            ++ non null element lying in the base ring \spad{R}.
        headRemainder : (P, %) -> Record(num : P, den : R)
-           ++ \spad{headRemainder(a, ps)} returns \spad{[b, r]} such that the leading
-           ++ monomial of \spad{b} is reduced in the sense of Groebner bases w.r.t.
-           ++ \spad{ps} and \spad{r*a - b} lies in the ideal generated by \spad{ps}.
+           ++ \spad{headRemainder(a, ps)} returns \spad{[b, r]} such that
+           ++ the leading monomial of \spad{b} is reduced in the sense of
+           ++ Groebner bases with respect to \spad{ps} and \spad{r*a - b}
+           ++ lies in the ideal generated by \spad{ps}.
        remainder : (P, %) -> Record(rnum : R, polnum : P, den : R)
-           ++ \spad{remainder(a, ps)} returns \spad{[c, b, r]} such that \spad{b} is fully
-           ++ reduced in the sense of Groebner bases w.r.t. \spad{ps},
-           ++ \spad{r*a - c*b} lies in the ideal generated by \spad{ps}.
+           ++ \spad{remainder(a, ps)} returns \spad{[c, b, r]} such that
+           ++ \spad{b} is fully reduced in the sense of Groebner bases
+           ++ with respect to \spad{ps} and \spad{r*a - c*b}
+           ++ lies in the ideal generated by \spad{ps}.
            ++ Furthermore, if \spad{R} is a gcd-domain, \spad{b} is primitive.
        rewriteIdealWithHeadRemainder : (List(P), %) -> List(P)
            ++ \spad{rewriteIdealWithHeadRemainder(lp, cs)} returns \spad{lr} such that
            ++ the leading monomial of every polynomial in \spad{lr} is reduced
-           ++ in the sense of Groebner bases w.r.t. \spad{cs} and \spad{(lp, cs)}
+           ++ in the sense of Groebner bases with respect to \spad{cs} and
+           ++ \spad{(lp, cs)}
            ++ and \spad{(lr, cs)} generate the same ideal in \spad{(R)^(-1) P}.
        rewriteIdealWithRemainder : (List(P), %) -> List(P)
-           ++ \spad{rewriteIdealWithRemainder(lp, cs)} returns \spad{lr} such that
-           ++ every polynomial in \spad{lr} is fully reduced in the sense
-           ++ of Groebner bases w.r.t. \spad{cs} and \spad{(lp, cs)} and
-           ++ \spad{(lr, cs)} generate the same ideal in \spad{(R)^(-1) P}.
+           ++ \spad{rewriteIdealWithRemainder(lp, cs)} returns \spad{lr} such
+           ++ that every polynomial in \spad{lr} is fully reduced in the sense
+           ++ of Groebner bases with respect to \spad{cs} and \spad{(lp, cs)}
+           ++ and \spad{(lr, cs)} generate the same ideal in \spad{(R)^(-1) P}.
        triangular? : % -> Boolean
            ++ \spad{triangular?(ps)} returns true iff \spad{ps} is a triangular set,
            ++ i.e. two distinct polynomials have distinct main variables

sage_wheels/lib/fricas/target/aarch64-apple-darwin23.6.0/src/algebra/poltopol.spad

@@ -1,7 +1,7 @@
 )abbrev package MPC2 MPolyCatFunctions2
-++ Utilities for MPolyCat
 ++ Author: Manuel Bronstein
 ++ Date Created: 1987
+++ Description: Utilities for MPolyCat.
 MPolyCatFunctions2(VarSet, E1, E2, R, S, PR, PS) : public == private where
 
   VarSet : OrderedSet

sage_wheels/lib/fricas/target/aarch64-apple-darwin23.6.0/src/algebra/polycat.spad

@@ -9,7 +9,7 @@
 ++ Description:
 ++ Abelian monoid ring elements (not necessarily of finite support)
 ++ of this ring are of the form formal SUM (r_i * e_i)
-++ where the r_i are coefficents and the e_i, elements of the
+++ where the r_i are coefficients and the e_i, elements of the
 ++ ordered abelian monoid, are thought of as exponents or monomials.
 ++ The monomials commute with each other, but in general do not
 ++ commute with the coefficients (which themselves may or may not

sage_wheels/lib/fricas/target/aarch64-apple-darwin23.6.0/src/algebra/ratfact.spad

@@ -1,10 +1,11 @@
 )abbrev package RATFACT RationalFactorize
 ++ Author: P. Gianni
-++ Factorization of extended polynomials with rational coefficients.
-++ This package implements factorization of extended polynomials
-++ whose coefficients are rational numbers. It does this by taking the
-++ lcm of the coefficients of the polynomial and creating a polynomial
-++ with integer coefficients. The algorithm in \spadtype{GaloisGroupFactorizer} is then
+++ Description: Factorization of extended polynomials with rational
+++ coefficients.  This package implements factorization of extended
+++ polynomials whose coefficients are rational numbers. It does this by
+++ taking the lcm of the coefficients of the polynomial and creating a
+++ polynomial with integer coefficients. The algorithm in
+++ \spadtype{GaloisGroupFactorizer} is then
 ++ used to factor the integer polynomial. The result is normalized
 ++ with respect to the original lcm of the denominators.
 ++ Keywords: factorization, hensel, rational number

sage_wheels/lib/fricas/target/aarch64-apple-darwin23.6.0/src/algebra/rdeefx.spad

@@ -2196,6 +2196,9 @@ ElementaryRischDEX(R, F) : Exports == Implementation where
             do_risch_DE(f, g, x, lk)$ElementaryRischDEX2(R, F)
         k := top_kernel(f, g, x)
         lk := [kk for kk in lk | kk ~= k]
+        c0 := g*f/fp
+        D(c0, x) = 0 =>
+            [0, g, c0*Ei(f), true]
         has?(operator k, ALGOP)$BasicOperator =>
             ei_int_alg(f, g, x, k, lk)
         fpu := univariate(fp, k)

sage_wheels/lib/fricas/target/aarch64-apple-darwin23.6.0/src/algebra/rec.spad

@@ -148,7 +148,7 @@ moment, similar to the indexing variable in sum and product.
 
 \subsubsection{Extracting some information from the recurrence}
 
-We need to find out wether we can determine the next term of the sequence, and
+We need to find out whether we can determine the next term of the sequence, and
 how many initial values are necessary.
 
 )endif