passagemath-fricas 10.5.40__cp39-cp39-macosx_14_0_arm64.whl → 10.5.41__cp39-cp39-macosx_14_0_arm64.whl

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

@@ -33,7 +33,7 @@
 ++ A family \spad{[T1, ..., Ts]} of regular triangular sets
 ++ is a split of Lazard of a given subset \spad{S} of \spad{A}
 ++ iff the union of the \spad{W(Ti)} contains \spad{S} and
-++ is contained in the closure of \spad{S} (w.r.t. Zariski topology).
+++ is contained in the closure of \spad{S} (with respect to Zariski topology).
 ++ A family \spad{[T1, ..., Ts]} of regular triangular sets
 ++ is a split of Lazard of a given triangular set \spad{T}
 ++ if it is a split of Lazard of \spad{W(T)}.
@@ -63,14 +63,14 @@ RegularTriangularSetCategory(R : GcdDomain, E : OrderedAbelianMonoidSup, _
 
      purelyAlgebraic? : (P, %) -> Boolean
          ++ \spad{purelyAlgebraic?(p, ts)} returns \spad{true} iff every
-         ++ variable of \spad{p} is algebraic w.r.t. \spad{ts}.
+         ++ variable of \spad{p} is algebraic with respect to \spad{ts}.
      purelyTranscendental? : (P, %) -> Boolean
          ++ \spad{purelyTranscendental?(p, ts)} returns \spad{true} iff every
-         ++ variable of \spad{p} is not algebraic w.r.t. \spad{ts}
+         ++ variable of \spad{p} is not algebraic with respect to \spad{ts}.
      algebraicCoefficients?  : (P, %) -> Boolean
          ++ \spad{algebraicCoefficients?(p, ts)} returns \spad{true} iff every
          ++ variable of \spad{p} which is not the main one of \spad{p}
-         ++ is algebraic w.r.t. \spad{ts}.
+         ++ is algebraic with respect to \spad{ts}.
      purelyAlgebraic? : % -> Boolean
          ++ \spad{purelyAlgebraic?(ts)} returns true iff for every algebraic
          ++ variable \spad{v} of \spad{ts} we have
@@ -80,7 +80,7 @@ RegularTriangularSetCategory(R : GcdDomain, E : OrderedAbelianMonoidSup, _
      purelyAlgebraicLeadingMonomial? : (P, %) -> Boolean
          ++ \spad{purelyAlgebraicLeadingMonomial?(p, ts)} returns true iff
          ++ the main variable of any non-constant iterarted initial
-         ++ of \spad{p} is algebraic w.r.t. \spad{ts}.
+         ++ of \spad{p} is algebraic with respect to \spad{ts}.
      invertibleElseSplit? : (P, %) -> Union(Boolean, List %)
          ++ \spad{invertibleElseSplit?(p, ts)} returns \spad{true} (resp.
          ++ \spad{false}) if \spad{p} is invertible in the tower
@@ -99,26 +99,27 @@ RegularTriangularSetCategory(R : GcdDomain, E : OrderedAbelianMonoidSup, _
          ++ the radical of saturated of \spad{ts}.
      lastSubResultantElseSplit : (P, P, %) -> Union(P, List %)
          ++ \spad{lastSubResultantElseSplit(p1, p2, ts)} returns either
-         ++ \spad{g} a quasi-monic gcd of \spad{p1} and \spad{p2} w.r.t.
-         ++ the \spad{ts} or a split of Kalkbrener of \spad{ts}.
-         ++ This assumes that \spad{p1} and \spad{p2} have the same maim
+         ++ \spad{g} a quasi-monic gcd of \spad{p1} and \spad{p2} with
+         ++ respect to the \spad{ts} or a split of Kalkbrener of \spad{ts}.
+         ++ This assumes that \spad{p1} and \spad{p2} have the same main
          ++ variable and that this variable is greater that any variable
          ++ occurring in \spad{ts}.
      lastSubResultant : (P, P, %) -> List Record(val : P, tower : %)
          ++ \spad{lastSubResultant(p1, p2, ts)} returns \spad{lpwt} such that
          ++ \spad{lpwt.i.val} is a quasi-monic gcd of \spad{p1} and \spad{p2}
-         ++ w.r.t. \spad{lpwt.i.tower}, for every \spad{i}, and such
+         ++ with respect to \spad{lpwt.i.tower}, for every \spad{i}, and such
          ++ that the list of the \spad{lpwt.i.tower} is a split of Kalkbrener of
-         ++ \spad{ts}. Moreover, if \spad{p1} and \spad{p2} do not
-         ++ have a non-trivial gcd w.r.t. \spad{lpwt.i.tower} then \spad{lpwt.i.val}
-         ++ is the resultant of these polynomials w.r.t. \spad{lpwt.i.tower}.
-         ++ This assumes that \spad{p1} and \spad{p2} have the same maim
+         ++ \spad{ts}. Moreover, if \spad{p1} and \spad{p2} do not have a
+         ++ non-trivial gcd with respect to \spad{lpwt.i.tower} then
+         ++ \spad{lpwt.i.val} is the resultant of these polynomials
+         ++ with respect to \spad{lpwt.i.tower}.
+         ++ This assumes that \spad{p1} and \spad{p2} have the same main
          ++ variable and that this variable is greater that any variable
          ++ occurring in \spad{ts}.
      squareFreePart : (P, %) -> List Record(val : P, tower : %)
          ++ \spad{squareFreePart(p, ts)} returns \spad{lpwt} such that
-         ++ \spad{lpwt.i.val} is a square-free polynomial
-         ++ w.r.t. \spad{lpwt.i.tower}, this polynomial being associated with \spad{p}
+         ++ \spad{lpwt.i.val} is a square-free polynomial with respect to
+         ++ \spad{lpwt.i.tower}, this polynomial being associated with \spad{p}
          ++ modulo \spad{lpwt.i.tower}, for every \spad{i}. Moreover,
          ++ the list of the \spad{lpwt.i.tower} is a split
          ++ of Kalkbrener of \spad{ts}.
@@ -392,22 +393,23 @@ QuasiComponentPackage(R, E, V, P, TS) : Exports == Implementation where
   Exports ==  with
      startTable! : (S, S, S) -> Void
          ++ \spad{startTableGcd!(s1, s2, s3)}
-         ++ is an internal subroutine, exported only for developement.
+         ++ is an internal subroutine, exported only for development.
      stopTable! : () -> Void
          ++ \spad{stopTableGcd!()}
-         ++ is an internal subroutine, exported only for developement.
+         ++ is an internal subroutine, exported only for development.
      supDimElseRittWu? : (TS, TS) -> Boolean
          ++ \spad{supDimElseRittWu(ts, us)} returns true iff \spad{ts}
-         ++ has less elements than \spad{us} otherwise if \spad{ts}
-         ++ has higher rank than \spad{us} w.r.t. Riit and Wu ordering.
+         ++ has less elements than \spad{us} otherwise if \spad{ts} has
+         ++ higher rank than \spad{us} with respect to Riit and Wu ordering.
      algebraicSort : Split -> Split
-         ++ \spad{algebraicSort(lts)} sorts \spad{lts} w.r.t
+         ++ \spad{algebraicSort(lts)} sorts \spad{lts} with respect to
          ++ \spadopFrom{supDimElseRittWu?}{QuasiComponentPackage}.
      moreAlgebraic? : (TS, TS) -> Boolean
          ++ \spad{moreAlgebraic?(ts, us)} returns false iff \spad{ts}
          ++ and \spad{us} are both empty, or \spad{ts}
          ++ has less elements than \spad{us}, or some variable is
-         ++ algebraic w.r.t. \spad{us} and is not w.r.t. \spad{ts}.
+         ++ algebraic with respect to \spad{us} and is not with respect
+         ++ to \spad{ts}.
      subTriSet? : (TS, TS) -> Boolean
          ++ \spad{subTriSet?(ts, us)} returns true iff \spad{ts} is
          ++ a sub-set of \spad{us}.
@@ -417,13 +419,14 @@ QuasiComponentPackage(R, E, V, P, TS) : Exports == Implementation where
      internalSubPolSet? : (LP, LP) -> Boolean
          ++ \spad{internalSubPolSet?(lp1, lp2)} returns true iff \spad{lp1} is
          ++ a sub-set of \spad{lp2} assuming that these lists are sorted
-         ++ increasingly w.r.t. \spadopFrom{infRittWu?}{RecursivePolynomialCategory}.
+         ++ increasingly with respect to
+         ++ \spadopFrom{infRittWu?}{RecursivePolynomialCategory}.
      internalInfRittWu? : (LP, LP) -> Boolean
          ++ \spad{internalInfRittWu?(lp1, lp2)}
-         ++ is an internal subroutine, exported only for developement.
+         ++ is an internal subroutine, exported only for development.
      infRittWu? : (LP, LP) -> Boolean
          ++ \spad{infRittWu?(lp1, lp2)}
-         ++ is an internal subroutine, exported only for developement.
+         ++ is an internal subroutine, exported only for development.
      internalSubQuasiComponent? : (TS,TS) -> Union(Boolean,"failed")
          ++ \spad{internalSubQuasiComponent?(ts, us)} returns a boolean \spad{b} value
          ++ if the fact that the regular zero set of \spad{us} contains that of
@@ -442,16 +445,16 @@ QuasiComponentPackage(R, E, V, P, TS) : Exports == Implementation where
          ++ another \spad{us} in \spad{lts}.
      subCase? : (LpWT, LpWT) -> Boolean
          ++ \spad{subCase?(lpwt1, lpwt2)}
-         ++ is an internal subroutine, exported only for developement.
+         ++ is an internal subroutine, exported only for development.
      removeSuperfluousCases : List LpWT -> List LpWT
          ++ \spad{removeSuperfluousCases(llpwt)}
-         ++ is an internal subroutine, exported only for developement.
+         ++ is an internal subroutine, exported only for development.
      prepareDecompose : (LP, List(TS), B, B) -> List Branch
          ++ \spad{prepareDecompose(lp, lts, b1, b2)}
-         ++ is an internal subroutine, exported only for developement.
+         ++ is an internal subroutine, exported only for development.
      branchIfCan : (LP,TS,LP,B,B,B,B,B) -> Union(Branch,"failed")
          ++ \spad{branchIfCan(leq, ts, lineq, b1, b2, b3, b4, b5)}
-         ++ is an internal subroutine, exported only for developement.
+         ++ is an internal subroutine, exported only for development.
 
   Implementation == add
 
@@ -770,28 +773,28 @@ RegularTriangularSetGcdPackage(R, E, V, P, TS) : Exports == Implementation where
   Exports ==  with
      startTableGcd! : (S, S, S) -> Void
          ++ \spad{startTableGcd!(s1, s2, s3)}
-         ++ is an internal subroutine, exported only for developement.
+         ++ is an internal subroutine, exported only for development.
      stopTableGcd! : () -> Void
          ++ \spad{stopTableGcd!()}
-         ++ is an internal subroutine, exported only for developement.
+         ++ is an internal subroutine, exported only for development.
      startTableInvSet! : (S, S, S) -> Void
          ++ \spad{startTableInvSet!(s1, s2, s3)}
-         ++ is an internal subroutine, exported only for developement.
+         ++ is an internal subroutine, exported only for development.
      stopTableInvSet! : () -> Void
          ++ \spad{stopTableInvSet!()} is an internal subroutine,
-         ++ exported only for developement.
+         ++ exported only for development.
      prepareSubResAlgo : (P, P, TS) -> List LpWT
          ++ \spad{prepareSubResAlgo(p1, p2, ts)}
-         ++ is an internal subroutine, exported only for developement.
+         ++ is an internal subroutine, exported only for development.
      internalLastSubResultant : (P, P, TS, B, B) -> List PWT
          ++ \spad{internalLastSubResultant(p1, p2, ts, inv?, break?)}
-         ++ is an internal subroutine, exported only for developement.
+         ++ is an internal subroutine, exported only for development.
      internalLastSubResultant : (List LpWT, V, B) -> List PWT
          ++ \spad{internalLastSubResultant(lpwt, v, flag)} is an internal
-         ++ subroutine, exported only for developement.
+         ++ subroutine, exported only for development.
      integralLastSubResultant : (P, P, TS) -> List PWT
          ++ \spad{integralLastSubResultant(p1, p2, ts)}
-         ++ is an internal subroutine, exported only for developement.
+         ++ is an internal subroutine, exported only for development.
      toseLastSubResultant : (P, P, TS) -> List PWT
          ++ \spad{toseLastSubResultant(p1, p2, ts)} has the same specifications as
          ++ \spadopFrom{lastSubResultant}{RegularTriangularSetCategory}.
@@ -1092,7 +1095,7 @@ RegularTriangularSetGcdPackage(R, E, V, P, TS) : Exports == Implementation where
 ++ gcd (with coefficients in the tower of simple extensions associated
 ++ with a regular set) are computed. The only requirement is that these
 ++ gcd need to have invertible initials (normalized or not).
-++ WARNING. There is no need for a user to call diectly any operation
+++ WARNING. There is no need for a user to call directly any operation
 ++ of this package since they can be accessed by the domain \spad{TS}.
 ++ Thus, the operations of this package are not documented.\newline
 ++ References:
@@ -1398,7 +1401,7 @@ RegularTriangularSet(R, E, V, P) : Exports == Implementation where
 
      internalAugment : (P, %, B, B, B, B, B) -> List %
        ++ \spad{internalAugment(p, ts, b1, b2, b3, b4, b5)}
-       ++ is an internal subroutine, exported only for developement.
+       ++ is an internal subroutine, exported only for development.
      zeroSetSplit : (LP, B, B) -> Split
        ++ \spad{zeroSetSplit(lp, clos?, info?)} has the same specifications as
        ++ \spadopFrom{zeroSetSplit}{RegularTriangularSetCategory}.
@@ -1407,13 +1410,13 @@ RegularTriangularSet(R, E, V, P) : Exports == Implementation where
        ++ do print messages during the computations.
      zeroSetSplit : (LP, B, B, B, B) -> Split
        ++ \spad{zeroSetSplit(lp, b1, b2.b3, b4)}
-       ++ is an internal subroutine, exported only for developement.
+       ++ is an internal subroutine, exported only for development.
      internalZeroSetSplit : (LP, B, B, B) -> Split
        ++ \spad{internalZeroSetSplit(lp, b1, b2, b3)}
-       ++ is an internal subroutine, exported only for developement.
+       ++ is an internal subroutine, exported only for development.
      pre_process : (LP, B, B) -> Record(val : LP, towers : Split)
        ++ \spad{pre_process(lp, b1, b2)}
-       ++ is an internal subroutine, exported only for developement.
+       ++ is an internal subroutine, exported only for development.
 
   Implementation == add
 

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

@@ -1,5 +1,5 @@
 )abbrev package ROOTUT RootUtilities
-++ Description: This package implments 'complex_roots'.
+++ Description: This package implements 'complex_roots'.
 RootUtilities(R, F) : Exports == Implementation where
   R : Join(GcdDomain, RetractableTo Integer, Comparable,
            LinearlyExplicitOver Integer)
@@ -295,8 +295,8 @@ RootSimplification() : Exports == Implementation where
     -- Below we need to initialize variables with large expressions.
     -- Spad compiler and sbcl have trouble with the expressions
     -- (sbcl runs out of memory compiling resulting code).  Instead
-    -- we pass expresions as strings to interpreter for evaluation.
-    -- Since it is done only when we instatiate this package the
+    -- we pass expressions as strings to interpreter for evaluation.
+    -- Since it is done only when we instantiate this package the
     -- overhead is acceptable.
     --
     -- Helper function to evaluate string as expression.
@@ -967,7 +967,13 @@ RootSimplification() : Exports == Implementation where
         "failed"
 
     my_root(s1 : eI, k : Integer, opr : BasicOperator) : eI ==
-        numer(s1) = 1 => 1/kernel(opr, [1/s1, k::eI])
+        n1 := numer(s1)::eI
+        n1 = 1 => 1/kernel(opr, [1/s1, k::eI])
+        d1 := denom(s1)::eI
+        (nu1 := rsimp1(n1, k)) case eI =>
+            nu1::eI/kernel(opr, [d1, k::eI])
+        (du1 := rsimp1(d1, k)) case eI =>
+            kernel(opr, [n1, k::eI])/du1::eI
         kernel(opr, [s1, k::eI])
 
     eval_rl(rl : List(eI), kf : eI, k : Integer) : eI ==

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

@@ -1,8 +1,8 @@
 )abbrev domain RULE RewriteRule
-++ Rules for the pattern matcher
 ++ Author: Manuel Bronstein
 ++ Date Created: 24 Oct 1988
 ++ Keywords: pattern, matching, rule.
+++ Description: Rules for the pattern matcher.
 RewriteRule(Base, R, F) : Exports == Implementation where
   Base   : SetCategory
   R      : Join(Ring, PatternMatchable Base, Comparable,
@@ -128,13 +128,13 @@ RewriteRule(Base, R, F) : Exports == Implementation where
             lhs(x)::OutputForm, rhs(x)::OutputForm)
 
 )abbrev package APPRULE ApplyRules
-++ Applications of rules to expressions
 ++ Author: Manuel Bronstein
 ++ Date Created: 20 Mar 1990
 ++ Description:
 ++   This package apply rewrite rules to expressions, calling
 ++   the pattern matcher.
 ++ Keywords: pattern, matching, rule.
+++ Description: Applications of rules to expressions.
 ApplyRules(Base, R, F) : Exports == Implementation where
   Base   : SetCategory
   R      : Join(Ring, PatternMatchable Base, Comparable,
@@ -236,12 +236,12 @@ ApplyRules(Base, R, F) : Exports == Implementation where
       subject
 
 )abbrev domain RULESET Ruleset
-++ Sets of rules for the pattern matcher
 ++ Author: Manuel Bronstein
 ++ Date Created: 20 Mar 1990
 ++ Description:
 ++   A ruleset is a set of pattern matching rules grouped together.
 ++ Keywords: pattern, matching, rule.
+++ Description: Sets of rules for the pattern matcher.
 Ruleset(Base, R, F) : Exports == Implementation where
   Base   : SetCategory
   R      : Join(Ring, PatternMatchable Base, Comparable,

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

@@ -4001,6 +4001,7 @@ object.
 ++ Keywords:
 ++ References:
 ++ http://www.euclideanspace.com/prog/scratchpad/mycode/graph/
+++ Description: This domain implements scenegraph.
 
 Scene(PT) : Exports == Implementation where
  PT : SPointCategory

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

@@ -1,5 +1,6 @@
 )abbrev category TSEREXP TaylorSeriesExpansion
 ++ Author: Waldek Hebisch
+++ Description: Category for operations needed by Taylor expansions.
 TaylorSeriesExpansion(Coef : Algebra(Fraction(Integer)),
         Expon : OrderedAbelianMonoid, Var : OrderedSet,
         PS : PowerSeriesCategory(Coef, Expon, Var),

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

@@ -65,7 +65,7 @@ SExpressionCategory(Str, Sym, Int, Flt) : Category == Decl where
         elt :       (%, Integer)      -> %
           ++ elt((a1, ..., an), i) returns \spad{ai}.
         elt :       (%, List Integer) -> %
-          ++ elt(s, [i1, ..., im]) recursively selects subexpession,
+          ++ elt(s, [i1, ..., im]) recursively selects subexpression,
           ++ that is elt(s, []) is just s and elt(s, [i1, ..., im]) is
           ++ the same as elt(elt(s, i1), [i2, ..., im]).
 

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

@@ -160,13 +160,12 @@ FloatingPointSystem() : Category == Join(RealNumberSystem(), Approximate,
    digits() == max(1, 4004 * (bits()-1) quo 13301)::PositiveInteger
 
    toString x == convert(x)@String
+
    toString(x : %, n : NonNegativeInteger) : String ==
-       x1 := round x
-       x0 := abs(x-x1)
-       tenn := float(1, n::Integer, 10)
-       x2 := round(tenn*x0)
-       res:List String := [convert(retract(x1))@String,".",convert(retract(x2))@String]
-       concat res
+       fixed_mr([mantissa(x), exponent(x)], n,
+                [false, false, "fixed", 0, underscore()$Character]
+               )$FloatingPointConvertion
+
 
 )if false
 \section{domain DFLOAT DoubleFloat}
@@ -494,6 +493,8 @@ DoubleFloat() : Join(FloatingPointSystem, DifferentialRing, OpenMath,
    airyBiPrime(x)   == airyBiPrime(sfx)$SFSFUN2 pretend %
    digamma(x) == polygamma(0, sfx)$SFSFUN2 pretend %
 
+   import from DoubleFloat
+
    polygamma(x, y)   ==
        if (n := retractIfCan(sfx)@Union(Integer, "failed")) case Integer _
           and n >= 0 then

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

@@ -154,7 +154,7 @@ IntegerNumberSystem() : Category ==
 
 
 -- Lisp dependencies
--- EQ, ABSVAL, TIMES, INTEGER-LENGTH, HASHEQ, REMAINDER
+-- EQ, ABSVAL, TIMES, INTEGER-LENGTH, REMAINDER
 -- QSLESSP, QSGREATERP, QSADD1, QSSUB1, QSMINUS, QSPLUS, QSDIFFERENCE
 -- QSTIMES, QSREMAINDER, QSODDP, QSZEROP, QSMAX, QSMIN, QSNOT, QSAND
 -- QSOR, QSXOR, QSLEFTSHIFT, QSADDMOD, QSDIFMOD, QSMULTMOD

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

@@ -235,7 +235,7 @@ NGroebnerPackage(Dom, Expon, Dpol) : T == C where
          (en := subtractIfCan(e2, e1)) case Expon
 
    --- concat F and h and erase polys in F with lexp
-   --- beeing multiple of lexp h
+   --- being multiple of lexp h
    --- Can do this because such poly can be recoverd
    --- from critical pair
 

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

@@ -13,7 +13,7 @@ UnitGaussianElimination : with
       ++ Note:  m is modified in place
     pre_smith : Matrix(Integer) -> Matrix(Integer)
       ++ pre_smith(m) first performs pre_gauss(m) and then
-      ++ drops all rows and colums of m contaning pivots.
+      ++ drops all rows and columns of m containing pivots.
     pre_lr : (Matrix(Integer), Vector(Integer), Vector(Integer)
              ) -> Matrix(Integer)
       ++ pre_lr(m, pi, pj) is like pre_gauss, but records positions

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

@@ -140,7 +140,7 @@ ThreeSpaceCategory(R : Ring) : Exports == Implementation where
       ++ The closed curve is added to the \spadtype{ThreeSpace}, s.
     closedCurve         : L POINT -> %
       ++ closedCurve(lp) sets a list of points defined by the first element
-      ++ of lp through the last element of lp and back to the first elelment
+      ++ of lp through the last element of lp and back to the first element
       ++ again and returns a \spadtype{ThreeSpace} whose component is the
       ++ closed curve defined by lp.
     closedCurve         : % -> L POINT
@@ -155,7 +155,7 @@ ThreeSpaceCategory(R : Ring) : Exports == Implementation where
       ++ is also the last element, or false otherwise.
     polygon      : (%, L POINT) -> %
       ++ polygon(s, [p0, p1, ..., pn]) adds a polygon component defined by a list of
-      ++ points, p0 throught pn, to the \spadtype{ThreeSpace} s.
+      ++ points, p0 through pn, to the \spadtype{ThreeSpace} s.
     polygon      : (%, L L R) -> %
       ++ polygon(s, [[r0], [r1], ..., [rn]]) adds a polygon component defined
       ++ by a list of points \spad{r0} through \spad{rn}, which are lists of
@@ -393,7 +393,7 @@ ThreeSpace(R : Ring) : Exports == Implementation where
       --     xxx(s)   : extract xxx from threespace, s
       --     xxx(p)   : create a new three space with xxx, p
       --     xxx(s, p) : add xxx, p, to a three space, s
-      --     xxx(s, q) : add an xxx, convertable from q, to a three space, s
+      --     xxx(s, q) : add an xxx, convertible from q, to a three space, s
       --     xxx(s, i) : add an xxx, the data for xxx being indexed by reference  ^* complete this
     point?(space : %) ==
       #(c := children space.subspaceField) > 1$NNI =>

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

@@ -19,14 +19,6 @@ DoubleFloatSpecialFunctions() : Exports == Impl where
 
     Exports ==> with
 
-        digamma : C -> C
-            ++ digamma(x) is the function, \spad{psi(x)}, defined by
-            ++   \spad{psi(x) = Gamma'(x)/Gamma(x)}.
-
-        polygamma : (NNI, C) -> C
-            ++ polygamma(n, x) is the n-th derivative of \spad{digamma(x)}.
-
-
         besselJ : (R, R) -> R
             ++ besselJ(v, x) is the Bessel function of the first kind,
             ++ \spad{J(v, x)}.
@@ -89,8 +81,6 @@ DoubleFloatSpecialFunctions() : Exports == Impl where
 
         -- These are hooks to Bruce's boot code.
 
-        polygamma(k, z) == c_psi(k, z)$Lisp
-
         besselJ(v, z)   == c_besselj(v, z)$Lisp
         besselJ(n, x)   == r_besselj(n, x)$Lisp
 
@@ -99,7 +89,6 @@ DoubleFloatSpecialFunctions() : Exports == Impl where
 
 
         -- All others are defined in terms of these.
-        digamma z == polygamma(0, z)
 
         fuzz := (10::R)^(-7)