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/fops.spad

@@ -0,0 +1,351 @@
+)abbrev package FILSER FileSerialization
+++ Description: This package converts Spad data to form which can
+++ be written to files and back.
+FileSerialization : Exports == Implementation where
+  Exports ==> with
+    serialize : None -> None
+      ++ serialize(d) returns copy of d transformed for writing
+      ++ to files.
+    deserialize : None -> None
+      ++ deserialize(d) reconstructs o from \spad{d := serialize(o)}.
+  Implementation ==> add
+
+    SEX ==> SExpression
+    Hget ==> HGET$Lisp
+    Qcar ==> QCAR$Lisp
+    Qcdr ==> QCDR$Lisp
+    null? ==> NULL$Lisp
+    pair? ==> PAIRP$Lisp
+    vec? ==> VECP$Lisp
+    nil ==> NIL$Lisp
+    kernel? ==> SPAD_KERNEL_-P$Lisp
+    kernel_arg ==> SPAD_KERNEL_-ARG$Lisp
+    kernel_nest ==> SPAD_KERNEL_-NEST$Lisp
+    kernel_op ==> SPAD_KERNEL_-OP$Lisp
+    array_size ==> ARRAY_-TOTAL_-SIZE$Lisp
+    row_major_aref ==> ROW_-MAJOR_-AREF$Lisp
+
+    HT ==> HashTable(None, None, "EQ")
+
+    to_n(x) ==> x pretend None
+    l_to_s(l : List(SEX)) : SEX == l pretend SEX
+
+    spadClosure?(d : None) : None ==
+        fun : None := Qcar(d)
+        not(FUNCTIONP(fun)$Lisp) => nil
+        null?(name : None := BPINAME(fun)$Lisp) => nil
+        not(vec?(Qcdr(d))) => nil
+        name
+
+    tT ==> Record(tag : Symbol, type : SEX)
+    type_tags := [
+       ['U8,       l_to_s([convert('UNSIGNED_-BYTE), convert(8)])]$tT,
+         ['U16,    l_to_s([convert('UNSIGNED_-BYTE), convert(16)])]$tT,
+           ['U32,  l_to_s([convert('UNSIGNED_-BYTE), convert(32)])]$tT,
+        ['I8,      l_to_s([convert('SIGNED_-BYTE), convert(8)])]$tT,
+          ['I16,   l_to_s([convert('SIGNED_-BYTE), convert(16)])]$tT,
+            ['I32, l_to_s([convert('SIGNED_-BYTE), convert(32)])]$tT,
+              ['FIX, convert('FIXNUM)],
+                ['DF,  convert('DOUBLE_-FLOAT)]]$List(tT)
+
+    get_type_tag(lt : SEX) : SEX ==
+        res : SEX := nil
+        for tp in type_tags while null?(res) repeat
+            ct := tp.type
+            if SUBTYPEP(lt, ct)$Lisp and SUBTYPEP(ct, lt)$Lisp then
+                res := convert(tp.tag)
+        res
+
+    get_lisp_type(tt : Symbol) : SEX ==
+        res := (false$Boolean) pretend SEX
+        for tp in type_tags while null?(res) repeat
+            if tt = tp.tag then
+               res := tp.type
+        res
+
+    do_serialize(d : None, seen : HT) : None ==
+            nd : None
+            null?(d) => nil
+            -- Needed to preserve EQ between data parts
+            not(null?(e : None := Hget(seen, d))) => e
+
+            pair?(d) =>
+                qcar : None := Qcar(d)
+                qcdr : None := Qcdr(d)
+                EQUAL(qcar, function(newGoGet$Lisp)$Lisp)$Lisp =>
+                    do_serialize(replaceGoGetSlot(qcdr)$Lisp, seen)
+                not(null?((name := spadClosure?(d)))) =>
+                   d1 := do_serialize(qcdr, seen)
+                   nd := to_n([to_n('WRITIFIED!!), to_n('SPADCLOSURE),
+                                d1, name]$List(None))
+                   setelt!(seen, d, nd)
+                   nd
+                nd := CONS(qcar, qcdr)$Lisp
+                setelt!(seen, d, nd)
+                qcar := do_serialize(qcar, seen)
+                qcdr := do_serialize(qcdr, seen)
+                QRPLACA(nd, qcar)$Lisp
+                QRPLACD(nd, qcdr)$Lisp
+                nd
+            vec?(d) =>
+                isDomainOrPackage(d)$Lisp =>
+                    d1 : None := mkEvalable(devaluate(d)$Lisp)$Lisp
+                    nd := to_n([to_n('WRITIFIED!!), to_n('DEVALUATED),
+                                do_serialize(d1, seen)]$List(None))
+                    setelt!(seen, d, nd)
+                    nd
+                oa := d pretend PrimitiveArray(None)
+                empty?(oa) =>
+                    qsetelt!(seen, d, d)
+                    d
+                n := #oa
+                noa := new(n, qelt(oa, 0))$PrimitiveArray(None)
+                nd := to_n(noa)
+                setelt!(seen, d, nd)
+                for i in 0..(n - 1) repeat
+                    qsetelt!(noa, i, do_serialize(qelt(oa, i), seen))
+                nd
+            GENERAL_ARRAY?(d)$Lisp =>
+                nd := MAKE_-ARRAY(ARRAY_-DIMENSIONS(d)$Lisp)$Lisp
+                setelt!(seen, d, nd)
+                n : Integer := array_size(d)
+                for i in 0..(n - 1) repeat
+                    SETF(row_major_aref(nd, i),
+                         do_serialize(row_major_aref(d, i), seen))$Lisp
+                nd
+            is_BVEC(d)$Lisp => d
+            STRINGP(d)$Lisp =>
+                EQ(d, _$NullStream$Lisp)$Lisp =>
+                    to_n([to_n('WRITIFIED!!), to_n('NULLSTREAM)]$List(None))
+                EQ(d, _$NonNullStream$Lisp)$Lisp =>
+                    to_n([to_n('WRITIFIED!!), to_n('NONNULLSTREAM)
+                         ]$List(None))
+                d
+            ARRAYP(d)$Lisp =>
+                tt := get_type_tag(ARRAY_-ELEMENT_-TYPE(d)$Lisp)
+                not(null?(tt)) =>
+                    dims : None := ARRAY_-DIMENSIONS(d)$Lisp
+                    n : NonNegativeInteger := array_size(d)
+                    nv := new(n, nil)$PrimitiveArray(None)
+                    nd := to_n([to_n('WRITIFIED!!), to_n('TYARR), to_n(tt),
+                                 dims, to_n(nv)]$List(None))
+                    setelt!(seen, d, nd)
+                    for i in 0..(n - 1) repeat
+                        setelt!(nv, i,
+                                do_serialize(row_major_aref(d, i), seen))
+                    nd
+                error "serialize: failed uknown ARRAY"
+            kernel?(d) =>
+                nd := makeSpadKernel(nil, nil, kernel_nest(d))$Lisp
+                setelt!(seen, d, nd)
+                SETF(kernel_op(nd), do_serialize(kernel_op(d), seen))$Lisp
+                SETF(kernel_arg(nd), do_serialize(kernel_arg(d), seen))$Lisp
+                nd
+            EQ(d, 'WRITIFIED!!)$Lisp =>
+                to_n([to_n('WRITIFIED!!), to_n('SELF)]$List(None))
+            COMPILED_-FUNCTION_-P(d)$Lisp =>
+                error "serialize: failed COMPILED-FUNCTION"
+            HASHTABLEP(d)$Lisp =>
+                nd := to_n([to_n('WRITIFIED!!)]$List(None))
+                setelt!(seen, d,  nd)
+                keys : List(None) := HKEYS(d)$Lisp
+                QRPLACD(nd,
+                        to_n([to_n('HASHTABLE), HASHTABLE_CLASS(d)$Lisp,
+                              do_serialize(to_n(keys), seen),
+                              to_n([do_serialize(Hget(d, k), seen)
+                                    for k in keys]$List(None))
+                             ]$List(None)))$Lisp
+                nd
+            FLOATP(d)$Lisp =>
+                EQUAL(d, READ_-FROM_-STRING(STRINGIMAGE(d)$Lisp)$Lisp
+                     )$Lisp => d
+                error "serialize: failed FLOAT"
+            d
+
+    serialize(d : None) : None ==
+        not(scan_for_unwritable(d)$Lisp) => d
+        seen := empty()$HT
+        do_serialize(d, seen)
+
+    do_deserialize(d : None, seen : HT) : None ==
+            nd : None
+            null?(d) => nil
+            -- Needed to preserve EQ between data parts
+            not(null?(e : None := Hget(seen, d))) => e
+
+            pair?(d) and EQ(first(d pretend List(SEX)), 'WRITIFIED!!)$Lisp =>
+                dl := d pretend List(SEX)
+                type := symbol(dl(2))
+                type = 'SELF => to_n('WRITIFIED!!)
+                type = 'TYARR =>
+                    lt := get_lisp_type(symbol(dl(3)))
+                    nd := MAKE_TYPED_ARRAY(dl(4), lt)$Lisp
+                    setelt!(seen, d, nd)
+                    ov := dl(5) pretend PrimitiveArray(None)
+                    n : Integer := array_size(nd)
+                    for i in 0..(n - 1) repeat
+                        SETF(row_major_aref(nd, i),
+                             do_deserialize(qelt(ov, i), seen))$Lisp
+                    nd
+                type = 'HASHTABLE =>
+                    nd := MAKE_HASHTABLE(dl(3))$Lisp
+                    setelt!(seen, d, nd)
+                    for k in destruct(dl(4)) for e in destruct(dl(5)) repeat
+                        HPUT(nd, do_deserialize(k pretend None, seen),
+                                  do_deserialize(e pretend None, seen))$Lisp
+                    nd
+                type = 'DEVALUATED =>
+                    nd := EVAL(do_deserialize(dl(3) pretend None, seen))$Lisp
+                    setelt!(seen, d, nd)
+                    nd
+                type = 'SPADCLOSURE =>
+                    vec := do_deserialize(dl(3) pretend None, seen)
+                    name := symbol(dl(4))
+                    not(FBOUNDP(name)$Lisp) =>
+                       error ["undefined function: ", string(name)]
+                    nd := CONS(SYMBOL_-FUNCTION(name)$Lisp, vec)$Lisp
+                    setelt!(seen, d, nd)
+                    nd
+                type = 'NULLSTREAM => _$NullStream$Lisp
+                type = 'NONNULLSTREAM => _$NonNullStream$Lisp
+                error "Unknown type to deserialize."
+            pair?(d) =>
+                qcar : None := Qcar(d)
+                qcdr : None := Qcdr(d)
+                nd  := CONS(qcar, qcdr)$Lisp
+                setelt!(seen, d, nd)
+                QRPLACA(nd, do_deserialize(qcar, seen))$Lisp
+                QRPLACD(nd, do_deserialize(qcdr, seen))$Lisp
+                nd
+            vec?(d) =>
+                oa := d pretend PrimitiveArray(None)
+                empty?(oa) =>
+                    qsetelt!(seen, d, d)
+                    d
+                n := #oa
+                noa := new(n, qelt(oa, 0))$PrimitiveArray(None)
+                nd := to_n(noa)
+                setelt!(seen, d, nd)
+                for i in 0..(n - 1) repeat
+                    qsetelt!(noa, i, do_deserialize(qelt(oa, i), seen))
+                nd
+            GENERAL_ARRAY?(d)$Lisp =>
+                nd := MAKE_-ARRAY(ARRAY_-DIMENSIONS(d)$Lisp)$Lisp
+                setelt!(seen, d, nd)
+                n : Integer := array_size(d)
+                for i in 0..(n - 1) repeat
+                    SETF(row_major_aref(nd, i),
+                         do_deserialize(row_major_aref(d, i), seen))$Lisp
+                nd
+            kernel?(d) =>
+                nd := makeSpadKernel(nil, nil, kernel_nest(d))$Lisp
+                setelt!(seen, d, nd)
+                SETF(kernel_op(nd), do_deserialize(kernel_op(d), seen))$Lisp
+                SETF(kernel_arg(nd),
+                     do_deserialize(kernel_arg(d), seen))$Lisp
+                nd
+            d
+
+    deserialize(d : None) : None ==
+        not(scan_for_writified(d)$Lisp) => d
+        seen := empty()$HT
+        do_deserialize(d, seen)
+
+
+)abbrev domain BASFILE BasicFile
+++ Description: This is domain for storing and reading Spad values in
+++ files.
+BasicFile : Exports == Implementation where
+  IOMode ==> String
+  Exports ==> with
+    open : (FileName, IOMode) -> %
+      ++ open opens the file.
+    close! : % -> Void
+      ++ clos! closes the file.
+    read : % -> None
+      ++ read sequentially reads one item from the file.
+    readIfCan : % -> Union(None, "failed")
+      ++ readIfCan read one item from the file. otherwise returns
+      ++ \spad{"failed"}
+    write! : (%, None) -> Void
+      ++ write writes one item to the file.
+    flush : % -> Void
+      ++ flush passes all buffered data to the operating system.
+  Implementation ==> add
+
+    import FileSerialization
+
+    nil ==> NIL$Lisp
+
+    open(fn : FileName, mode : IOMode) : % ==
+        mode = "input"  =>
+            not(readable?(fn)) => error ["File is not readable", fn]
+            MAKE_INSTREAM(fn::String)$Lisp
+        mode = "output" =>
+            not(writable?(fn)) => error ["File is not writable", fn]
+            MAKE_OUTSTREAM(fn::String)$Lisp
+        error ["IO mode must be input or output", mode]
+
+    close!(f : %) : Void == SHUT(f)$Lisp
+
+    readIfCan(f : %) : Union(None, "failed") ==
+        res1 : None := READ(f, nil, _$eof_marker$Lisp)$Lisp
+        eof_marker?(res1)$Lisp => "failed"
+        deserialize(res1) pretend None
+
+    read(f : %) : None ==
+        res1 : None := READ(f, nil, _$eof_marker$Lisp)$Lisp
+        eof_marker?(res1)$Lisp => error "End of file"
+        deserialize(res1) pretend None
+
+    write!(f : %, d : None) : Void ==
+        res1 : Union(None, "failed") := trappedSpadEval(serialize(d))$Lisp
+        res1 case "failed" => error "The value cannot be saved to a file."
+        write_to_stream(res1::None, f)$Lisp
+
+    flush(f : %) : Void ==
+        FORCE_-OUTPUT(f)$Lisp
+
+)abbrev domain BKAFILE BasicKeyedAccessFile
+BasicKeyedAccessFile : Exports == Implementation where
+  IOMode ==> String
+  Exports ==> with
+    open : (FileName, IOMode) -> %
+      ++ open opens the keyed access file.
+    close! : % -> Void
+      ++ close! closes the keyed access file.
+    read : (%, String) -> None
+      ++ read(f, key) reads item with the key \spad{key} from \spad{f}.
+    write! : (%, String, None) -> Void
+      ++ write! writes one item to the keyed access file.
+    remove! : (%, String) -> Void
+      ++ remove!(f, key) removes item with the key \spad{key} from \spad{f}.
+    keys : % -> List(String)
+      ++ keys(f) gives the list of keys of \spad{f}.
+
+  Implementation ==> add
+
+    import FileSerialization
+
+    open(fn : FileName, mode : IOMode) : % ==
+        mode = "input" or mode = "output" =>
+            kaf_open(fn::String, mode = "output")$Lisp
+        error ["IO mode must be input or output", mode]
+
+    close!(f : %) : Void ==
+        kaf_close(f)$Lisp
+
+    read(f : %, key : String) : None ==
+        deserialize(kaf_read(f, key, _$error_mark$Lisp)$Lisp)
+
+    write!(f : %, key : String, val : None) : Void ==
+        res1 : Union(None, "failed") := trappedSpadEval(serialize(val))$Lisp
+        res1 case "failed" =>
+            error "can not save value to file"
+        kaf_write(f, key, res1::None)$Lisp
+
+    remove!(f : %, key : String) : Void ==
+        kaf_remove(f, key)$Lisp
+
+    keys(f : %) : List(String) == rkeys2(f)$Lisp
+

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

@@ -201,7 +201,7 @@ FortranMatrixFunctionCategory() : Category == FortranProgramCategory with
 ++ Date Created: 11 March 1994
 ++ Related Constructors: FortranProgramCategory.
 ++ Description:
-++ \spadtype{FortranVectorFunctionCategory} is the catagory of arguments
+++ \spadtype{FortranVectorFunctionCategory} is the category of arguments
 ++ to NAG Library routines which return the values of vectors of functions.
 FortranVectorFunctionCategory() : Category == FortranProgramCategory with
     coerce : List FortranCode -> %

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

@@ -1226,31 +1226,24 @@ SimpleFortranProgram(R, FS) : Exports == Implementation where
     fortran(fname, ftype, res) ==
       construct(fname, ftype, res)$Rep
 
-    nameOf(u : %) : Symbol == u . name
-
-    typeOf(u:%):Union(FST,"void") == u . type
-
-    bodyOf(u : %) : FS == u . body
-
-    argumentsOf(u : %) : List Symbol == variables(bodyOf u)$FS
+    argumentsOf(u : %) : List Symbol == variables(u.body)$FS
 
     coerce(u : %) : OutputForm ==
-      coerce(nameOf u)$Symbol
+      coerce(u.name)$Symbol
 
     outputAsFortran(u : %) : Void ==
       ftype := u.type
       ftype_s : String := checkType(ftype::String)
-      fname := nameOf(u)
+      fname := u.name
       args := argumentsOf(u)
       nargs := [arg::OutputForm for arg in args]$List(OutputForm)
-      val  := bodyOf(u)::OutputForm
+      val  := u.body::OutputForm
       fortFormatHead(fname, [ftype], args)
       fort_format_types(ftype_s, nargs)
-      dispfortexp1$Lisp ["="::OutputForm, fname::OutputForm,
-                         val]@List(OutputForm)
-      dispfortexp1$Lisp "RETURN"::OutputForm
-      dispfortexp1$Lisp "END"::OutputForm
-      void()$Void
+      o_val := fname::OutputForm = val
+      dispStatement(o_val)
+      dispStatement('RETURN::OutputForm)
+      dispStatement('END::OutputForm)
 
 )abbrev domain SWITCH Switch
 

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

@@ -275,7 +275,7 @@ SymbolTable() : exports == implementation where
     empty  : () -> %
       ++ empty() returns a new, empty symbol table
     declare! : (L Symbol, FortranType, %) -> FortranType
-      ++ declare!(l, t, tab) creates new entrys in tab, declaring each of l
+      ++ declare!(l, t, tab) creates new entries in tab, declaring each of l
       ++ to be of type t
     declare! : (Symbol, FortranType, %) -> FortranType
       ++ declare!(u, t, tab) creates a new entry in tab, declaring u to be of

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

@@ -7,7 +7,7 @@
 ++ AMS Classifications:
 ++ Keywords:
 ++ References:
-++ Description:
+++ Description: Domain representing components of Fourier series.
 FourierComponent(E : OrderedSet):
        OrderedSet with
          sin : E -> %
@@ -31,6 +31,7 @@ FourierComponent(E : OrderedSet):
    coerce(x) : OutputForm ==
      hconcat((if x.SinIfTrue then message("sin") else message("cos")),
               bracket((x.arg)::OutputForm))
+   x = y == x.arg = y.arg and x.SinIfTrue = y.SinIfTrue
    x<y ==
      x.arg < y.arg => true
      y.arg < x.arg => false
@@ -46,7 +47,7 @@ FourierComponent(E : OrderedSet):
 ++ AMS Classifications:
 ++ Keywords:
 ++ References:
-++ Description:
+++ Description: Domain of Fourier series.
 FourierSeries(R : Join(CommutativeRing, Algebra(Fraction Integer)),
               E : Join(OrderedSet, AbelianGroup)):
        Algebra(R) with
@@ -90,7 +91,7 @@ FourierSeries(R : Join(CommutativeRing, Algebra(Fraction Integer)),
          makeCos(diff, r) + makeCos(sum, -r)
        makeSin(sum, r) + makeSin(diff, r)
      sin? t2.k =>
-       makeSin(sum, r) + makeSin(diff, r)
+       makeSin(sum, r) - makeSin(diff, r)
      makeCos(diff, r) + makeCos(sum, r)
    x1*x2 ==
      empty?(x1) => 0

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

@@ -1,10 +1,10 @@
 )abbrev domain FPARFRAC FullPartialFractionExpansion
-++ Full partial fraction expansion of rational functions
 ++ Author: Manuel Bronstein
 ++ Date Created: 9 December 1992
 ++ References: M.Bronstein & B.Salvy,
 ++             Full Partial Fraction Decomposition of Rational Functions,
 ++             in Proceedings of ISSAC'93, Kiev, ACM Press.
+++ Description: Full partial fraction expansion of rational functions.
 FullPartialFractionExpansion(F, UP) : Exports == Implementation where
   F  : Join(Field, CharacteristicZero)
   UP : UnivariatePolynomialCategory F

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

@@ -62,7 +62,7 @@ Factored(R : IntegralDomain) : Exports == Implementation where
       ++ (flag = "irred").
 
     numberOfFactors : % -> NonNegativeInteger
-      ++ numberOfFactors(u) returns the number of factors in \spadvar{u}.
+      ++ numberOfFactors(u) returns the number of factors in \spad{u}.
 
     primeFactor : (R, NonNegativeInteger) -> %
       ++ primeFactor(base, exponent) creates a factored object with
@@ -89,13 +89,13 @@ Factored(R : IntegralDomain) : Exports == Implementation where
 
     map :     (R -> R, %) -> %
       ++ map(fn, u) maps the function \userfun{fn} across the factors of
-      ++ \spadvar{u} and creates a new factored object. Note: this clears
+      ++ \spad{u} and creates a new factored object. Note: this clears
       ++ the information flags (sets them to "nil") because the effect of
       ++ \userfun{fn} is clearly not known in general.
 
     mergeFactors : (%, %) -> %
-      ++ mergeFactors(u, v) is used when the factorizations of \spadvar{u}
-      ++ and \spadvar{v} are known to be disjoint, e.g. resulting from a
+      ++ mergeFactors(u, v) is used when the factorizations of \spad{u}
+      ++ and \spad{v} are known to be disjoint, e.g. resulting from a
       ++ content/primitive part split. Essentially, it creates a new
       ++ factored object by multiplying the units together and appending
       ++ the lists of factors.
@@ -110,10 +110,10 @@ Factored(R : IntegralDomain) : Exports == Implementation where
 
     if R has IntegerNumberSystem then
       rational?    : % -> Boolean
-        ++ rational?(u) tests if \spadvar{u} is actually a
+        ++ rational?(u) tests if \spad{u} is actually a
         ++ rational number (see \spadtype{Fraction Integer}).
       rational     : % -> Fraction Integer
-        ++ rational(u) assumes spadvar{u} is actually a rational number
+        ++ rational(u) assumes \spad{u} is actually a rational number
         ++ and does the conversion to rational number
         ++ (see \spadtype{Fraction Integer}).
       rationalIfCan : % -> Union(Fraction Integer, "failed")
@@ -126,7 +126,7 @@ Factored(R : IntegralDomain) : Exports == Implementation where
 
   Implementation ==> add
 
-    -- For ordered R, the fct part is a sorted list.  Othewise we
+    -- For ordered R, the fct part is a sorted list.  Otherwise we
     -- use quadratic loops to match factors.  Code assumes that
     -- factors either are equal or coprime, this may fail if
     -- factors of two different kinds meet in an operation.
@@ -609,8 +609,8 @@ FactoredFunctionUtilities(R) : Exports == Implementation where
   Exports ==> with
     refine : (FR, R -> FR) -> FR
       ++ refine(u, fn) is used to apply the function \userfun{fn} to
-      ++ each factor of \spadvar{u} and then build a new factored
-      ++ object from the results.  For example, if \spadvar{u} were
+      ++ each factor of \spad{u} and then build a new factored
+      ++ object from the results.  For example, if \spad{u} were
       ++ created by calling \spad{nilFactor(10, 2)} then
       ++ \spad{refine(u, factor)} would create a factored object equal
       ++ to that created by \spad{factor(100)} or
@@ -654,12 +654,12 @@ FactoredFunctions2(R, S) : Exports == Implementation where
   Exports ==> with
     map : (R -> S, Factored R) -> Factored S
       ++ map(fn, u) is used to apply the function \userfun{fn} to every
-      ++ factor of \spadvar{u}. The new factored object will have all its
+      ++ factor of \spad{u}. The new factored object will have all its
       ++ information flags set to "nil". This function is used, for
       ++ example, to coerce every factor base to another type.
     map_preserving : (R -> S, Factored R) -> Factored S
       ++ map_preserving(fn, u) is used to apply the function \userfun{fn}
-      ++ to every factor of \spadvar{u}.  The new factored object will
+      ++ to every factor of \spad{u}.  The new factored object will
       ++ have the same flags as original.
 
   Implementation ==> add

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

@@ -117,7 +117,7 @@ ListMonoidOps(S, E, un) : Exports == Implementation where
 ++  When S is an OrderedSet, then FreeMonoid(S) has order: for two
 ++  elements \spad{x} and \spad{y} the relation \spad{x < y}
 ++  holds if either \spad{length(x) < length(y)} holds or if these lengths
-++  are equal and if \spad{x} is smaller than \spad{y} w.r.t. the
+++  are equal and if \spad{x} is smaller than \spad{y} with respect to the
 ++  lexicographical ordering induced by \spad{S}.
 FreeMonoid(S : SetCategory) : FMcategory == FMdefinition where
     NNI ==> NonNegativeInteger
@@ -187,8 +187,8 @@ FreeMonoid(S : SetCategory) : FMcategory == FMdefinition where
             OrderedMonoid
             lexico : (%, %) -> Boolean
               ++ \spad{lexico(x, y)} returns \spad{true} iff \spad{x} is
-              ++ smaller than \spad{y} w.r.t. the pure lexicographical
-              ++ ordering induced by \spad{S}.
+              ++ smaller than \spad{y} with respect to the pure
+              ++ lexicographical ordering induced by \spad{S}.
 
     FMdefinition ==> ListMonoidOps(S, NonNegativeInteger, 1) add
         Rep := ListMonoidOps(S, NonNegativeInteger, 1)

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

@@ -334,7 +334,7 @@ FunctionSpaceToExponentialExpansion(R, FE, x, cen) : _
       -- a power series.
       (deg := order(ups, 1)) < 0 =>
         -- this "can't happen"
-        error "exp of function with sigularity"
+        error "exp of function with singularity"
       deg > 0 => [exp(ups)]
       lc := coefficient(ups, 0); varOpList := opsInvolvingX lc
       not opInOpList?('log, varOpList) => [exp(ups)]

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

@@ -1,13 +1,12 @@
-)abbrev category ES ExpressionSpace
+)abbrev category ESC2 ExpressionSpace2
 ++ Category for domains on which operators can be applied
 ++ Author: Manuel Bronstein
 ++ Date Created: 22 March 1988
 ++ Description:
 ++ An expression space is a set which is closed under certain operators;
 ++ Keywords: operator, kernel, expression, space.
-ExpressionSpace() : Category == Defn where
+ExpressionSpace2(K : KernelCategory(%)) : Category == Defn where
   N   ==> NonNegativeInteger
-  K   ==> Kernel %
   OP  ==> BasicOperator
   SY  ==> Symbol
   PAREN  ==> '%paren
@@ -345,6 +344,8 @@ ExpressionSpace() : Category == Defn where
            (u := retractIfCan(x)@Union(Integer, "failed")) case Integer
                   and pred?(u@Integer)
 
+)abbrev category ES ExpressionSpace
+ExpressionSpace() : Category == ExpressionSpace2(Kernel(%))
 
 )abbrev package ES1 ExpressionSpaceFunctions1
 ++ Lifting of maps from expression spaces to kernels over them
@@ -385,7 +386,7 @@ ExpressionSpaceFunctions2(E : ExpressionSpace, F : ExpressionSpace) : with
     map(f, k) ==
       (operator(operator k)$F) [f x for x in argument k]$List(F)
 
-)abbrev category FS FunctionSpace
+)abbrev category FSC2 FunctionSpace2
 ++ Category for formal functions
 ++ Author: Manuel Bronstein
 ++ Date Created: 22 March 1988
@@ -393,13 +394,13 @@ ExpressionSpaceFunctions2(E : ExpressionSpace, F : ExpressionSpace) : with
 ++   A space of formal functions with arguments in an arbitrary
 ++   ordered set.
 ++ Keywords: operator, kernel, function.
-FunctionSpace(R : Comparable) : Category == Definition where
+FunctionSpace2(R : Comparable, K : KernelCategory(%)) : Category ==
+                                                   Definition where
   OP ==> BasicOperator
   O  ==> OutputForm
   SY ==> Symbol
   N  ==> NonNegativeInteger
   Z  ==> Integer
-  K  ==> Kernel %
   Q  ==> Fraction R
   PR ==> Polynomial R
   MP ==> SparseMultivariatePolynomial(R, K)
@@ -409,7 +410,7 @@ FunctionSpace(R : Comparable) : Category == Definition where
   SPECIALEQUAL ==> '%specialEqual
   SPECIALINPUT ==> '%specialInput
 
-  Definition ==> Join(ExpressionSpace, RetractableTo SY, Patternable R,
+  Definition ==> Join(ExpressionSpace2(K), RetractableTo SY, Patternable R,
                      FullyPatternMatchable R, FullyRetractableTo R) with
        ground?   : % -> Boolean
          ++ ground?(f) tests if f is an element of R.
@@ -666,7 +667,7 @@ FunctionSpace(R : Comparable) : Category == Definition where
             x := op(- first args)
             od? => -x
             x
-        elt(op, args)$ExpressionSpace_&(%)
+        elt(op, args)$ExpressionSpace2_&(%, K)
 
       eval(x : %, s : List SY, n : List N, l : List(% -> %)) ==
         eval(x, s, n, [y +-> f(first(y)) for f in l]$List(List % -> %))
@@ -1154,6 +1155,10 @@ FunctionSpace(R : Comparable) : Category == Definition where
         convert(x : %) : Pattern(Float) ==
           convert(numer x) / convert(denom x)
 
+)abbrev category FS FunctionSpace
+FunctionSpace(R : Comparable) : Category ==
+    Join(FunctionSpace2(R, Kernel(%)), ExpressionSpace)
+
 )abbrev package FS2 FunctionSpaceFunctions2
 ++ Lifting of maps to function spaces
 ++ Author: Manuel Bronstein

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

@@ -227,7 +227,7 @@ GaloisGroupPolynomialUtilities(R, UP) : Exports == Implementation where
 ++ [6] Bernard Beauzamy, Vilmar Trevisan and Paul S. Wang, Polynomial
 ++ Factorization: Sharp Bounds, Efficient Algorithms,
 ++ J. Symbolic Computation (1993) 15, 393-413
-++ [7] Augustin-Lux Cauchy, Exercices de Math\'ematiques Quatri\`eme Ann\'ee.
+++ [7] Augustin-Louis Cauchy, Exercices de Math\'ematiques Quatri\`eme Ann\'ee.
 ++ De Bure Fr\`eres, Paris 1829 (reprinted Oeuvres, II S\'erie, Tome IX,
 ++ Gauthier-Villars, Paris, 1891).
 ++ Description:

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

@@ -520,6 +520,7 @@ ComplexPatternMatch(R, S, CS) : C == T where
        import from PatternMatchPushDown(R, S, CS)
        import from PatternMatchResultFunctions2(R, PS, CS)
        import from PatternMatchResultFunctions2(R, CS, PS)
+       import from Integer
 
        ivar : PS := '%i::PS
 

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

@@ -283,7 +283,7 @@ EuclideanGroebnerBasisPackage(Dom, Expon, VarSet, Dpol) : T == C where
 
              -----------------------------
 
-             --- erase elements in D fullfilling crit B
+             --- erase elements in D fulfilling crit B
 
    ecritBonD(h : Dpol, D : List(critPair))==
          empty?(D) => []