passagemath-fricas 10.5.39__cp311-cp311-macosx_14_0_arm64.whl → 10.5.41__cp311-cp311-macosx_14_0_arm64.whl

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

@@ -379,7 +379,7 @@ FloatSpecialFunctions() : Exports == Implementation where
         finally
             bits(obits)
 
-    -- Riemann Zeta. When Re(s) >= 1/2 we use algoritm 2 from
+    -- Riemann Zeta. When Re(s) >= 1/2 we use algorithm 2 from
     -- P. Borwein, An efficient algorithm for the Riemann Zeta function
     -- conference proceedings
     --
@@ -640,7 +640,7 @@ FloatSpecialFunctions() : Exports == Implementation where
 
 
 )abbrev package FLIOUFUN FloatLiouvilianFunctions
-++ Description: This package implemnts numerical evaluation
+++ Description: This package implements numerical evaluation
 ++  for selected liouvilian functions.
 FloatLiouvilianFunctions() : Exports == Implementation where
 
@@ -740,7 +740,7 @@ FloatLiouvilianFunctions() : Exports == Implementation where
         prec := obits + 20
         oz := order(nz)
         length(prec) > 500 =>
-            error "reqested too high precision"
+            error "requested too high precision"
         if oz < 500 then
            dnz := nz::DoubleFloat
            (sp := prec*(694@I/1000)::DF) > dnz =>
@@ -803,7 +803,7 @@ FloatLiouvilianFunctions() : Exports == Implementation where
         prec := obits + 10
         oz := order(nz)
         length(prec) > 500 =>
-            error "reqested too high precision"
+            error "requested too high precision"
         if oz < 500 then
            dnz := nz::DoubleFloat
            (sp := prec*(694@I/1000)::DF) > dnz =>
@@ -883,7 +883,7 @@ FloatLiouvilianFunctions() : Exports == Implementation where
         prec := obits + 10
         oz := order(nz)
         length(prec) > 500 =>
-            error "reqested too high precision"
+            error "requested too high precision"
         if oz < 500 then
            dnz := nz::DoubleFloat
            (sp := prec*(694@I/1000)::DF) > dnz =>
@@ -956,7 +956,7 @@ FloatLiouvilianFunctions() : Exports == Implementation where
         prec := obits + 20
         oz := order(nz)
         length(prec) > 500 =>
-            error "reqested too high precision"
+            error "requested too high precision"
         if oz < 1000 then
            dnz := sqrt(nz::DF)
            (sp := prec*(694@I/1000)::DF) > dnz =>
@@ -1031,7 +1031,7 @@ FloatLiouvilianFunctions() : Exports == Implementation where
         prec := obits + 20
         oz := order(nz)
         length(prec) > 500 =>
-            error "reqested too high precision"
+            error "requested too high precision"
         if oz < 1000 then
            dnz := sqrt(nz::DF)
            (sp := prec*(694@I/1000)::DF) > dnz =>
@@ -1099,7 +1099,7 @@ FloatLiouvilianFunctions() : Exports == Implementation where
         prec := obits + 20
         oz := order(nz)
         length(prec) > 500 =>
-            error "reqested too high precision"
+            error "requested too high precision"
         if oz < 1000 then
            dnz := sqrt(nz::DF)
            (sp := prec*(694@I/1000)::DF) > dnz =>
@@ -1461,9 +1461,13 @@ DoubleFloatSpecialFunctions2() : with
     Beta : (Complex(DoubleFloat), Complex(DoubleFloat)) -> Complex(DoubleFloat)
     Gamma : DoubleFloat -> DoubleFloat
     Gamma : Complex(DoubleFloat) -> Complex(DoubleFloat)
+    digamma : DoubleFloat -> DoubleFloat
+    digamma : Complex(DoubleFloat) -> Complex(DoubleFloat)
     logGamma : DoubleFloat -> DoubleFloat
     logGamma : Complex(DoubleFloat) -> Complex(DoubleFloat)
     polygamma : (NonNegativeInteger, DoubleFloat) -> DoubleFloat
+    polygamma : (NonNegativeInteger, Complex(DoubleFloat)) ->
+                 Complex(DoubleFloat)
     erf : DoubleFloat -> DoubleFloat
     erfi : DoubleFloat -> DoubleFloat
     fresnelC : DoubleFloat -> DoubleFloat
@@ -1653,15 +1657,6 @@ DoubleFloatSpecialFunctions2() : with
 
     Beta(x : CDF, y : CDF) : CDF == Gamma(x)*Gamma(y)/Gamma(x+y)
 
-    -- m-steps of backward recurence
-    --     W2(n, x) = x^(-n - 1) + W2(n, x + 1)
-    psi_W2(x : DF, s : DF, n : NonNegativeInteger, m : Integer) : DF ==
-        nn := -1 - n
-        for i in 1..m repeat
-            xm := x + (m - i)::DF
-            s := s + xm^nn
-        s
-
     -- bernoulli(2*k) for k in 1..21
     -- we prepend 0 to get effect of indexing from 1
     ber_coeff := construct([ 0,
@@ -1677,45 +1672,68 @@ DoubleFloatSpecialFunctions2() : with
           48833.2318973593_16667e10,   -1929657.9341940068_149e10,
        84169304.7573682615e10])$DoubleFloatVector
 
-    W_stirling1(t : DF, x2_inv : DF, r_eps : DF, df_n : DF) : DF ==
-        s : DF := 0
-        df_k := 2::DF
-        for k in 2..21 repeat
-            t := t*x2_inv*(df_k + 1 + df_n)*(df_k + df_n)/
-                   ((df_k + 1)*(df_k+2::DF))
-            tk := t*ber_coeff(k)
-            abs(tk) < r_eps => break
-            s := s + tk
-            df_k := df_k + 2::DF
-        s
-
-    W_stirling(xm : DF, n : NonNegativeInteger) : DF ==
-        xm_inv := 1/xm
-        x2_inv := xm_inv*xm_inv
-        df_n := n::DF
-        t0 := 0.5::DF*xm_inv
-        t := (df_n + 1)*0.5::DF*x2_inv
-        r_eps := 1.0e-18::DF*t0
-        if n > 0 then
-            t0 := t0 + 1/df_n
-        t1 := t*ber_coeff(1)
-        s : DF :=
-            t1 < r_eps => 0
-            t1 + W_stirling1(t, xm_inv*xm_inv, r_eps, df_n)
-        t0 + s
-
-    psi_W1(x : DF, n : NonNegativeInteger, m : Integer) : DF ==
-        xm := x + m::DF
-        s := xm^(-n)*W_stirling(xm, n)
-        if n = 0 then
-            s := s - log(xm)
-        psi_W2(x, s, n, m)
+    psi_funs(fF, fabs, psi_W1, psi_W2, W_stirling1, W_stirling) ==>
+
+        -- m-steps of backward recurrence
+        --     W2(n, x) = x^(-n - 1) + W2(n, x + 1)
+        psi_W2(x : fF, s : fF, n : NonNegativeInteger, m : Integer) : fF ==
+            nn := -1 - n
+            for i in 1..m repeat
+                xm := x + (m - i)::DF::fF
+                s := s + xm^nn
+            s
+
+        W_stirling1(t : fF, x2_inv : fF, r_eps : DF, df_n : DF) : fF ==
+            s : fF := 0
+            df_k := 2::DF
+            for k in 2..21 repeat
+                ccn := (df_k + 1 + df_n)*(df_k + df_n)/
+                       ((df_k + 1)*(df_k+2::DF))
+                t := ccn*t*x2_inv
+                tk := ber_coeff(k)*t
+                fabs(tk) < r_eps => break
+                s := s + tk
+                df_k := df_k + 2::DF
+            s
+
+        W_stirling(xm : fF, n : NonNegativeInteger) : fF ==
+            xm_inv := 1/xm
+            x2_inv := xm_inv*xm_inv
+            df_n := n::DF
+            t0 := 0.5::DF*xm_inv
+            t := (df_n + 1)*0.5::DF*x2_inv
+            r_eps := 1.0e-18::DF*fabs(t0)
+            if n > 0 then
+                t0 := t0 + (1/df_n)::fF
+            t1 := ber_coeff(1)*t
+            s : fF :=
+                fabs(t1) < r_eps => 0
+                t1 + W_stirling1(t, x2_inv, r_eps, df_n)
+            t0 + s
+
+        psi_W1(x : fF, n : NonNegativeInteger, m : Integer) : fF ==
+            xm := x + m::DF::fF
+            s := xm^(-n)*W_stirling(xm, n)
+            if n = 0 then
+                s := s - log(xm)
+            psi_W2(x, s, n, m)
+
+    psi_funs(DF, abs, psi_W1_DF, psi_W2_DF, W_stirling1_DF, W_stirling_DF)
+
+    cabs(z : CDF) : DF == sqrt(norm(z))
+
+    psi_funs(CDF, cabs, psi_W1_CDF, psi_W2_CDF, W_stirling1_CDF,
+             W_stirling_CDF)
 
     -- requested accuracy in decimal digits
     df_dig := 15::DF
 
     -- estimate minimal x for which asymptitic expansion gives
-    -- good accuracy
+    -- good accuracy.  See formula (2.3):
+    -- D. E. Amos, Algorithm 610, A portable FORTRAN subroutine
+    -- for derivatives of the Psi function,
+    -- ACM Transactions on Mathematical Software, Vol. 9,
+    -- No. 4, December 1983, Pages 494-502.
     min_asymp(n : NonNegativeInteger) : DF ==
         slope := 0.21::DF + df_dig*(0.0006038::DF*df_dig + 0.008677::DF)
         xm := 3.50::DF + df_dig*0.40::DF + n*slope
@@ -1760,11 +1778,45 @@ DoubleFloatSpecialFunctions2() : with
         m : Integer :=
             x_min < x => 0
             retract(ceiling(x_min - x))@Integer
-        res1 := Gamma(n::DF + 1)*psi_W1(x, n, m)
+        res1 := Gamma(n::DF + 1)*psi_W1_DF(x, n, m)
+        if even?(n) then
+            res1 := -res1
+        res1
+
+    digamma(x : DF) : DF == polygamma(0, x)
+
+    polygamma(n : NonNegativeInteger, x : CDF) : CDF ==
+        (ix := imag(x)) = 0 => complex(polygamma(n, real(x)), 0)
+        (rx := real(x)) < -1 =>
+            2 < n =>
+                error "polygamma not implemented for x with real(x) < -1"
+            rx_int := round(rx)
+            x1 := x - complex(rx_int, 0)
+            x1 = 0 =>
+                error "pole of polygamma"
+            res1 := polygamma(n, 1 - x)
+            if odd?(n) then
+               res1 := -res1
+            cot_d :=
+                cv := cot(c_pi*x1)
+                n = 0 => c_pi*cv
+                cv1 := c_pi*(1 + cv*cv)
+                n = 1 => -c_pi*cv1
+                n = 2 => 2*c_pi*c_pi*cv*cv1
+                error "unimplemented"
+            res1 - cot_d
+        x_min := min_asymp(n)
+        m : Integer :=
+            ax := cabs(x)
+            x_min < ax => 0
+            nrx := sqrt(x_min*x_min + 0.5 - ix*ix)
+            retract(ceiling(nrx - rx))@Integer
+        res1 := Gamma(n::DF + 1)*psi_W1_CDF(x, n, m)
         if even?(n) then
             res1 := -res1
         res1
 
+    digamma(x : CDF) : CDF == polygamma(0, x)
 
     import FloatLiouvilianFunctions
 

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

@@ -10,10 +10,10 @@
 ++ The category of square-free regular triangular sets.
 ++ A regular triangular set \spad{ts} is square-free if
 ++ the gcd of any polynomial \spad{p} in \spad{ts} and
-++ \spad{differentiate(p, mvar(p))} w.r.t.
+++ \spad{differentiate(p, mvar(p))} with respect to
 ++ \spadopFrom{collectUnder}{TriangularSetCategory}(ts, \spadopFrom{mvar}{RecursivePolynomialCategory}(p))
-++ has degree zero w.r.t. \spad{mvar(p)}. Thus any square-free regular
-++ set defines a tower of square-free simple extensions.\newline
+++ has degree zero with respect to \spad{mvar(p)}.  Thus any square-free
+++ regular set defines a tower of square-free simple extensions.\newline
 ++ References:
 ++  [1] D. LAZARD "A new method for solving algebraic systems of
 ++      positive dimension" Discr. App. Math. 33:147-160,1991
@@ -81,22 +81,22 @@ SquareFreeQuasiComponentPackage(R, E, V, P, TS) : Exports == Implementation wher
   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. Ritt and Wu ordering.
+         ++ \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} with respect to Ritt and Wu ordering.
      algebraicSort : Split -> Split
-         ++ \spad{algebraicSort(lts)} sorts \spad{lts} w.r.t
-         ++ \spadopFrom{supDimElseRittWu}{QuasiComponentPackage}.
+         ++ \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}.
+         ++ and \spad{us} are both empty, or \spad{ts} has less elements
+         ++ than \spad{us}, or some variable is 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}.
@@ -106,13 +106,14 @@ SquareFreeQuasiComponentPackage(R, E, V, P, TS) : Exports == Implementation wher
      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 the regular zero set of \spad{us} contains that of
@@ -121,7 +122,7 @@ SquareFreeQuasiComponentPackage(R, E, V, P, TS) : Exports == Implementation wher
      subQuasiComponent? : (TS, TS) -> Boolean
          ++ \spad{subQuasiComponent?(ts, us)} returns true iff
          ++ \spadopFrom{internalSubQuasiComponent?(ts, us)}{QuasiComponentPackage}
-         ++ returs true.
+         ++ returns true.
      subQuasiComponent? : (TS, Split) -> Boolean
          ++ \spad{subQuasiComponent?(ts, lus)} returns true iff
          ++ \spad{subQuasiComponent?(ts, us)} holds for one \spad{us} in \spad{lus}.
@@ -131,16 +132,16 @@ SquareFreeQuasiComponentPackage(R, E, V, P, TS) : Exports == Implementation wher
          ++ 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
 
@@ -883,7 +884,7 @@ SquareFreeRegularTriangularSetGcdPackage(R, E, V, P, TS) : Exports == Implementa
 ++ gcds (with coefficients in the tower of simple extensions associated
 ++ with a regular set) are computed. The only requirement is that these
 ++ gcds 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 \spadtype{TS}.
 ++ Thus, the operations of this package are not documented.\newline
 ++ References:
@@ -1176,7 +1177,7 @@ SquareFreeRegularTriangularSet(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}
@@ -1186,13 +1187,13 @@ SquareFreeRegularTriangularSet(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/stream.spad

@@ -1181,7 +1181,7 @@ StreamFunctions1(S : Type) : Exports == Implementation where
 
   Exports ==> with
     concat : ST ST S -> ST S
-      ++ concat(u) returns the left-to-right concatentation of the streams in u.
+      ++ concat(u) returns the left-to-right concatenation of the streams in u.
       ++ Note: \spad{concat(u) = reduce(concat, u)}.
 
   Implementation ==> add

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

@@ -263,8 +263,8 @@ IndexedString(mn : Integer) : Export == Implementation where
     c :  Character
     cc : CharacterClass
 
-    new(n, c)              == make_full_CVEC2(n, c)$Lisp
-    empty()                == make_full_CVEC(0$Lisp)$Lisp
+    new(n, c)              == make_string_code(n, c)$Lisp
+    empty()                == filler_spaces(0$Lisp)$Lisp
     empty?(s)              == Qsize(s) = 0
     #s                     == Qsize(s)
     s = t                  == Qequal(s, t)
@@ -374,6 +374,16 @@ IndexedString(mn : Integer) : Export == Implementation where
         RPLACSTR(y, s, m, x, 0, m)$Lisp
         y
 
+    join(sep: %, l: List %): % ==
+        empty? l => empty()
+        lensep := #sep
+        t := new(+/[#s for s in l] + #rest(l)*lensep, space$C)
+        t := copyInto!(t, first l, 1); i := 1 + #first(l)
+        for s in rest l repeat
+            t := copyInto!(t, sep, i); i := i + lensep
+            t := copyInto!(t, s,   i); i := i + #s
+        t
+
     qelt(s : %, i : I) == Qelt(s, i - mn)
 
     elt(s : %, i : I) ==

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

@@ -12,7 +12,8 @@
 ++ References:
 ++ Description:
 ++   StreamTaylorSeriesOperations implements Taylor series arithmetic,
-++   where a Taylor series is represented by a stream of its coefficients.
+++   where a Taylor series is represented by a stream of its coefficients,
+++   see corresponding operations in the category Ring.
 StreamTaylorSeriesOperations(A) : Exports == Implementation where
   A :        Ring
   RN     ==> Fraction Integer
@@ -194,51 +195,122 @@ StreamTaylorSeriesOperations(A) : Exports == Implementation where
       zero? s => zro()
       map(z +-> z*s, x)
 
-    iDiv : (ST A, ST A, A) -> ST A
-    iDiv(x, rst_y, ry0) == delay
-      empty? x => empty()
-      c0 := frst x * ry0
-      concat(c0, iDiv(rst x - c0*rst_y, rst_y, ry0))
-
-    i_div1 : (ST A, ST A, A, A) -> ST A
-    i_div1(rst_x, rst_y, ry0, c0) == delay
-        empty?(rst_y) => map(z +-> z*ry0, rst_x)
-        iDiv(rst_x - c0*rst_y, rst_y, ry0)
-
-    x exquo y ==
-      y0 : A
-      for n in 1.. repeat
-        n > 1000 => return "failed"
-        empty? y => return "failed"
-        empty? x => return empty()
-        (y0 := frst y) = 0 =>
-          frst x = 0 => (x := rst x; y := rst y)
-          return "failed"
-        -- first entry in y is non-zero
-        break
-      (ry0u := recip y0) case "failed" => "failed"
-      ry0 := ry0u@A
-      x0 := frst x
-      c0 := x0*ry0
-      concat(c0, i_div1(rst x, rst y, ry0, c0))
-
-    (x : ST A) / (y : ST A) == delay
-      empty? y => error "/: division by zero"
-      empty? x => empty()
-      (ry0u := recip frst y) case "failed" =>
-        error "/: second argument is not invertible"
-      ry0 := ry0u@A
-      x0 := frst x
-      c0 := x0*ry0
-      concat(c0, i_div1(rst x, rst y, ry0, c0))
-
-    recip x ==
-      empty? x => "failed"
-      rh1 := recip frst x
-      rh1 case "failed" => "failed"
-      rh := rh1@A
+-------------------------------------------------------------------
+
+    -- We use
+    -- https://en.wikipedia.org/wiki/Formal_power_series#Multiplicative_inverse.
+    -- For the actual computation formula (non-commutative case) see
+    -- explanation for / below with f=1.
+    -- recip computes the zeroth coefficient and computes arguments
+    -- for restRecip to compute the remaining coefficients.
+    -- restRecip avoids zero multiplication if the tail of the yet computed
+    -- partial stream ends in zeros.
+    -- Assume that x = (a0,a1,a2,...)
+    -- Arguments for restRecip:
+    -- a = (a1, a2, a3,...)
+    -- u = - 1/a0
+    -- n = in this invocation we compute (cn, c(n+1), ...)
+    -- k = the resulting coefficients ck, c(k+1), ..., c(n-1) are equal to 0
+    -- ra = (ak,a(k+1),a(k+2),...) substream of x starting at k
+    -- revc = [c(k-1),c(k-2),...,c(0)] the first k coefficients of the result
+    --        in reverse order, c(k-1)~=0.
+
+    -- local
+    revSum(ra : ST A, rvc : List A) : A ==
+        cc : A := 0
+        for c in rvc while not empty? ra repeat
+            cc := cc + c * frst(ra)
+            ra := rst ra
+        cc
+
+    -- local
+    restRecip(a : ST A, u : A, n : I, k : I, ra : ST A, revc : List A): ST A ==
       delay
-        concat(rh, iDiv(- rh * rst x, rst x, rh))
+        --assert(k=#revc)
+        --assert(for i in k .. n-1 while not empty? a repeat a := rst a; a=ra)
+        --assert(#revc>0)
+        empty? ra => empty()
+        rvc : List A := revc -- create a local variable inside 'delay'
+        cn : A := u * revSum(ra, rvc) -- u = -1/a(0)
+        zero? cn => concat(cn, restRecip(a, u, n+1, k, rst ra, rvc))
+        for i in k..n-1 repeat rvc := cons(0, rvc) -- fill rvc with zeros
+        concat(cn, restRecip(a, u, n+1, n+1, a, cons(cn, rvc)))
+
+    recip(x : ST A) : UN ==
+        empty? x => "failed"
+        ua : Union(A, "failed") := recip frst x
+        ua case "failed" => "failed"
+        c0 : A := ua @ A
+        concat(c0, restRecip(rst x, -c0, 1, 1, rst x, [c0])) :: UN
+
+-------------------------------------------------------------------
+
+    -- We use
+    -- https://en.wikipedia.org/wiki/Formal_power_series#Division.
+    -- In fact, the Wikipedia formula is for the commutative case.
+    -- We allow / also for the non-commutative case to mean "right-division",
+    -- i.e. if h=f/g then h*g=f. Thus,
+    -- $f=\sum_{n=0}^\infty b_n x^n$,
+    -- $g=\sum_{n=0}^\infty a_n x^n$,
+    -- $h=\sum_{n=0}^\infty c_n x^n$ as in the Wikipedia article, we get:
+    -- $\sum_{n=0}^\infty c_n x^n \sum_{n=0}^\infty a_n x^n
+    -- = \sum_{n-0}^\infty b_n x^n$ and by equating coefficients we get
+    -- for any $n\ge0$ that $b_n = \sum_{i=0}^n c_{n-i} a_i$.
+    -- Therefore $c_0 = b_0 / a_0 = b_0 a_0^{-1}$ and
+    -- $c_n = (b_n - \sum_{i=1}^n c_{n-i} a_i) / a_0$.
+
+    -- / computes the zeroth coefficient and computes arguments
+    -- for restDiv to compute the remaining coefficients.
+    -- restDiv avoids zero multiplication if the tail of the yet computed
+    -- partial stream ends in zeros.
+    -- Assume that x = (b0,b1,b2,...), y = (a0,a1,a2,...).
+    -- Arguments for restDiv:
+    -- a = (a1, a2, a3,...)
+    -- u = - 1/a0
+    -- n = in this invocation we compute (cn, c(n+1), ...)
+    -- k = the resulting coefficients ck, c(k+1), ..., c(n-1) are equal to 0
+    -- ra = (ak,a(k+1),a(k+2),...) substream of x starting at k
+    -- b = (bn, b(n+1), b(n+2),...)
+    -- revc = [c(k-1),c(k-2),...,c(0)] the first k coefficients of the result
+    --        in reverse order, c(k-1)~=0.
+
+    -- local
+    restDiv(a : ST A, u : A, n : I, k : I, ra : ST A, b : ST A,_
+            revc : List A) : ST A == delay
+        --assert(k=#revc)
+        --assert(for i in k .. n-1 while not empty? a repeat a := rst a; a=ra)
+        --assert(#revc>0)
+        empty? b => restRecip(a, u, n, k, ra, revc)
+        rvc : List A := revc -- create a local variable inside 'delay'
+        cn : A := (revSum(ra, rvc) - frst b) * u -- u = -1/a(0)
+        zero? cn => concat(cn, restDiv(a, u, n+1, k, rst ra, rst b, rvc))
+        for i in k..n-1 repeat rvc := cons(0, rvc) -- fill rvc with zeros
+        concat(cn, restDiv(a, u, n+1, n+1, a, rst b, cons(cn, rvc)))
+
+    ((x : ST A) exquo (y : ST A)) : UN ==
+        for n in 1..1000 repeat
+            empty? y => return "failed"
+            empty? x => return empty()
+            not zero? frst y => break
+            not zero? frst x => return "failed"
+            x := rst x
+            y := rst y
+        ua : Union(A, "failed") := recip frst y
+        ua case "failed" => "failed"
+        u : A := ua @ A
+        c0 := frst(x) * u
+        concat(c0, restDiv(rst y, -u, 1, 1, rst y, rst x, [c0]))
+
+    ((x : ST A) / (y : ST A)) : ST A == delay
+        empty? y => error "/: division by zero"
+        empty? x => empty()
+        ua : Union(A, "failed") := recip frst y
+        ua case "failed" => error "/: second argument is not invertible"
+        u : A := ua @ A
+        c0 := frst(x) * u
+        concat(c0, restDiv(rst y, -u, 1, 1, rst y, rst x, [c0]))
+
+-------------------------------------------------------------------
 
 --% coefficients
 

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

@@ -16,7 +16,7 @@ MoreSystemCommands : public == private where
   public == with
 
     systemCommand : String -> Void
-      ++ systemCommand(cmd) takes the string \spadvar{cmd} and passes
+      ++ systemCommand(cmd) takes the string \spad{cmd} and passes
       ++ it to the runtime environment for execution as a system
       ++ command. Although various things may be printed, no usable
       ++ value is returned.

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

@@ -46,7 +46,7 @@ TexFormat() : public == private where
       ++ numbers.
     display :  (%, I) -> Void
       ++ display(t, width) outputs the TeX formatted code t so that each
-      ++ line has length less than or equal to \spadvar{width}.
+      ++ line has length less than or equal to \spad{width}.
     display :  % -> Void
       ++ display(t) outputs the TeX formatted code t so that each
       ++ line has length less than or equal to the value set by

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

@@ -219,6 +219,9 @@ BinaryTree(S : SetCategory) : Exports == Implementation where
        empty? t => error "binaryTree:no value to set"
        setvalue!(first(t::Rep), nd)
        nd
+
+     import from Tree(S)
+
      setleft!(t1, t2) ==
        empty? t1 => error "binaryTree:no left to set"
        setchildren!(first(t1::Rep), t2::Rep)