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

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

@@ -350,7 +350,7 @@ graphically by a diagram known as the lambda cube)
 or cartesian products.
 \item Polymorphism (terms depend on types) - For example : we can define
 functions which can be applied to parameters with different types.
-\item Dependant Types (types depend on terms)
+\item Dependent Types (types depend on terms)
 \end{itemize}
 \end{itemize}
 Initially, not all of these options are supported by this framework and
@@ -479,23 +479,23 @@ Untyped() : Exports == Implementation where
 
   NNI==> NonNegativeInteger
   PR ==> Record(rft : %, pout : NNI)
-    ++ parse result includes string returned and new index
+    -- parse result includes string returned and new index
 
   Exports ==> VarCat()
 
   Implementation ==> add
 
     Rep := Record(nme : String)
-      ++ At the moment an untyped variable is represented by a string
-      ++ representing the name of the variable.
-      ++ So why wrap it in a Record structure.
-      ++ The main reason is because I am planning to expand this as
-      ++ explained in the text part of this pamphlet.
-      ++ Also it seems like a good idea to keep a similar structure to
-      ++ typed variables.
-      ++ Also I could not get it to work unwrapped. I vaguely recall that
-      ++ I couldn't get the constructor to return an unwrapped value, but
-      ++ it may have been some other issue and that's not the main reason.
+      -- At the moment an untyped variable is represented by a string
+      -- representing the name of the variable.
+      -- So why wrap it in a Record structure.
+      -- The main reason is because I am planning to expand this as
+      -- explained in the text part of this pamphlet.
+      -- Also it seems like a good idea to keep a similar structure to
+      -- typed variables.
+      -- Also I could not get it to work unwrapped. I vaguely recall that
+      -- I couldn't get the constructor to return an unwrapped value, but
+      -- it may have been some other issue and that's not the main reason.
 
     -- constructs variable with a name but no type
     var(n : String) : % ==
@@ -583,15 +583,15 @@ Typed() : Exports == Implementation where
 
   NNI==> NonNegativeInteger
   PR ==> Record(rft : %, pout : NNI)
-    ++ parse result includes string returned and new index
+    -- parse result includes string returned and new index
 
   Exports ==> VarCat()
 
   Implementation ==> add
 
     Rep := Record(nme : String, typ : ILogic)
-      ++ name of variable
-      ++ and type of variable
+      -- name of variable
+      -- and type of variable
 
     -- constructs variable with a name but no type
     var(n : String) : % ==
@@ -863,16 +863,16 @@ about how to coerce to/from this algebra see below.
 ++ Keywords:
 ++ References:
 ++ http://www.euclideanspace.com/prog/scratchpad/mycode/computation/lambda/
-++ An implementation of untyped lambda-calculus
+++ Description: An implementation of untyped lambda-calculus
 
 Lambda(UT) : Exports == Implementation where
 
  UT : VarCat
  NNI==> NonNegativeInteger
  PR ==> Record(rft : %, pout : NNI)
-   ++ parse result includes term returned and new index
+   -- parse result includes term returned and new index
  x<<y ==> hconcat(x::OutputForm,y::OutputForm)
-   ++ macro to simplify output
+   -- macro to simplify output
 
  Exports == CoercibleTo(OutputForm) with
   lambda : (deBruijn : NNI) -> %
@@ -923,7 +923,7 @@ Lambda(UT) : Exports == Implementation where
     ++ its variable appear in its expression
   getChildren : (n : %) -> List %
     ++ returns 2 child nodes if this is a compound term
-    ++ returns 1 child node if this is a lamda term
+    ++ returns 1 child node if this is a lambda term
     ++ otherwise returns []
   subst : (n : %, a : %, b : %) -> %
     ++ substitution of 'a' for 'b' in 'n'
@@ -962,30 +962,30 @@ Lambda(UT) : Exports == Implementation where
          compoundTerm : Record(c1 : %, c2 : %), _
          lambdaTerm : Record(c3 : %, nm : UT)_
          )
-    ++ this allows us to represent potentially nested lambda
-    ++ expressions as a tree structure where the nodes are
-    ++ one of:
-    ++ 1) boundTerm: Record(varBound: NNI)
-    ++    This represents a bound variable using De Bruijn index.
-    ++       varBound = De Bruijn index which is a integer where,
-    ++             1=inside inner lambda term
-    ++             2= next outer lambda term,
-    ++             3= next outer and so on.
-    ++
-    ++ 2) freeTerm: UT
-    ++    This represents an unbound variable so De Bruijn index
-    ++    is not used.
-    ++
-    ++ 3) compoundTerm: Record(c1: %, c2: %)
-    ++   Adjacent nodes represent function application
-    ++
-    ++ 4) lambdaTerm: Record(c3: %, nm: UT)
-    ++    when used the outer term should be a lambdaTerm although
-    ++    lambda terms may also be nested within the tree structure
-    ++    c3 holds the subnodes
-    ++    nm is the bound term for this lambda node
-    ++   There is only one bound term for each lambda node, if more
-    ++   are required then lambda nodes can be nested.
+    -- this allows us to represent potentially nested lambda
+    -- expressions as a tree structure where the nodes are
+    -- one of:
+    -- 1) boundTerm: Record(varBound: NNI)
+    --    This represents a bound variable using De Bruijn index.
+    --       varBound = De Bruijn index which is a integer where,
+    --             1=inside inner lambda term
+    --             2= next outer lambda term,
+    --             3= next outer and so on.
+    --
+    -- 2) freeTerm: UT
+    --    This represents an unbound variable so De Bruijn index
+    --    is not used.
+    --
+    -- 3) compoundTerm: Record(c1: %, c2: %)
+    --   Adjacent nodes represent function application
+    --
+    -- 4) lambdaTerm: Record(c3: %, nm: UT)
+    --    when used the outer term should be a lambdaTerm although
+    --    lambda terms may also be nested within the tree structure
+    --    c3 holds the subnodes
+    --    nm is the bound term for this lambda node
+    --   There is only one bound term for each lambda node, if more
+    --   are required then lambda nodes can be nested.
 
   -- Constructs a reference to a bound variable from its deBruijn
   -- index
@@ -1638,13 +1638,19 @@ page, where there is explanation and tutorial.
 ++ Keywords:
 ++ References:
 ++ http://www.euclideanspace.com/prog/scratchpad/mycode/computation/ski/
+++ Description: This domain implements SKI combinators.
+++ Ski combinators were introduced by Moses Schoenfinkel and Haskell
+++ Curry with the aim of eliminating the need for variables in
+++ mathematical logic.  It is equivalent to lambda calculus but
+++ it can be used for doing, without variables, anything that
+++ would require variables in other systems.
 
 SKICombinators(UT) : Exports == Implementation where
 
  UT : VarCat
  NNI==> NonNegativeInteger
  PR ==> Record(rft : %, pout : NNI)
-   ++ parse result includes term returned and new index
+   -- parse result includes term returned and new index
 
  Exports == SetCategory with
   ski : (x : %, y : %) -> %
@@ -1702,23 +1708,23 @@ SKICombinators(UT) : Exports == Implementation where
          nd : Record(c1 : %, c2 : %), _
          vr : UT_
          )
-    ++ this allows us to represent a combinator expression
-    ++ as a tree structure where the nodes are one of:
-    ++
-    ++ 1) lf: Symbol
-    ++     This node contains the combinator terms themselves currently
-    ++     coded as:
-    ++     I combinator = "I"::Symbol
-    ++     K combinator = "K"::Symbol
-    ++     S combinator = "S"::Symbol
-    ++
-    ++ 2) Record(c1: %, c2: %)
-    ++     This represents a branch in the tree.  Adjacent nodes
-    ++     represent function application.
-    ++
-    ++ 3) UT
-    ++     this represents a variable (function)
-    ++
+    -- this allows us to represent a combinator expression
+    -- as a tree structure where the nodes are one of:
+    --
+    -- 1) lf: Symbol
+    --     This node contains the combinator terms themselves currently
+    --     coded as:
+    --     I combinator = "I"::Symbol
+    --     K combinator = "K"::Symbol
+    --     S combinator = "S"::Symbol
+    --
+    -- 2) Record(c1: %, c2: %)
+    --     This represents a branch in the tree.  Adjacent nodes
+    --     represent function application.
+    --
+    -- 3) UT
+    --     this represents a variable (function)
+    --
 
   -- Constructs a node combinator over another combinators
   ski(x : %, y : %) : % == [[x, y]]
@@ -2288,15 +2294,15 @@ compUtil(UT) : Exports == Implementation where
  SU ==> SKICombinators UT
  NNI==> NonNegativeInteger
  x<<y ==> hconcat(x::OutputForm,y::OutputForm)
-   ++ macro to simplify output
+   -- macro to simplify output
 
  Exports ==> with
     coerce : (s : SU) -> LU
       ++ coerce SKI combinators to Lambda term.
       ++ this conversion is done by applying the following rules
-      ++ rule SL1: Ski[I] = \x.0
-      ++ rule SL2: Ski[K] = \x.\y.1
-      ++ rule SL3: Ski[S] = \x.\y.\z.(2 0 (1 0))
+      ++ rule SL1: Ski[I] = x.0
+      ++ rule SL2: Ski[K] = x.y.1
+      ++ rule SL3: Ski[S] = x.y.z.(2 0 (1 0))
       ++ rule SL4: Ski[(E1 E2)] = (Ski[E1] Ski[E2])
     coerce : (lam : LU) -> SU
       ++ coerce Lambda term to SKI combinators.
@@ -2305,10 +2311,10 @@ compUtil(UT) : Exports == Implementation where
       ++ all lambda terms have been eliminated.
       ++ rule LS1: Lam[x] => x
       ++ rule LS2: Lam[(E1 E2)] => (Lam[E1] Lam[E2])
-      ++ rule LS3: Lam[\x.E] => (K Lam[E]) (if x does not occur free in E)
-      ++ rule LS4: Lam[\x.x] => I
-      ++ rule LS5: Lam[\x.\y.E] => Lam[\x.Lam[\y.E]] (if x occurs free in E)
-      ++ rule LS6: Lam[\x.(E1 E2)] => (S Lam[\x.E1] Lam[\x.E2])
+      ++ rule LS3: Lam[x.E] => (K Lam[E]) (if x does not occur free in E)
+      ++ rule LS4: Lam[x.x] => I
+      ++ rule LS5: Lam[x.y.E] => Lam[x.Lam[y.E]] (if x occurs free in E)
+      ++ rule LS6: Lam[x.(E1 E2)] => (S Lam[x.E1] Lam[x.E2])
     coerce : (s : SU) -> ILogic
       ++ coerce combinators to intuitionistic logic
       ++ this is known as the Curry-Howard isomorphism

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

@@ -90,6 +90,11 @@ AlgebraicNumber() : Exports == Implementation where
     makeUnivariate(p : P, k : Kernel %) : SUP % ==
       map(x +-> x::%,
             univariate(p, k))$SparseUnivariatePolynomialFunctions2(P, %)
+
+    import from P
+    import from List(K)
+    import from Fraction(Z)
+
     -- public
     a, b : %
     differentiate(x : %) : % == 0
@@ -142,19 +147,22 @@ AlgebraicNumber() : Exports == Implementation where
        for k in l repeat
            z := norm(z, k)
        z
-    belong? op           == belong?(op)$ExpressionSpace_&(%) or has?(op, ALGOP)
+    belong? op == belong?(op)$ExpressionSpace2_&(%, K) or has?(op, ALGOP)
 
     convert(x : %) : InputForm ==
       coerceToType(convert(x pretend Rep)$Rep)$InputFormFunctions1(%)
 
     convert(x : %) : Float ==
+      import from Expression(Float)
       retract map(y +-> y::Float, x pretend FE)$ExpressionFunctions2(Z, Float)
 
     convert(x : %) : DoubleFloat ==
+      import from Expression(DoubleFloat)
       retract map(y +-> y::DoubleFloat,
                   x pretend FE)$ExpressionFunctions2(Z, DoubleFloat)
 
     convert(x : %) : Complex(Float) ==
+      import from Expression(Complex(Float))
       retract map(y +-> y::Complex(Float),
                   x pretend FE)$ExpressionFunctions2(Z, Complex Float)
 

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

@@ -29,7 +29,7 @@ ContinuedFraction(R) : Exports == Implementation where
 
   Exports ==> Join(Algebra R, Algebra Q, Field) with
     continuedFraction :        Q -> %
-      ++ continuedFraction(r) converts the fraction \spadvar{r} with
+      ++ continuedFraction(r) converts the fraction \spad{r} with
       ++ components of type \spad{R} to a continued fraction over
       ++ \spad{R}.
 
@@ -47,63 +47,63 @@ ContinuedFraction(R) : Exports == Implementation where
       ++ \spad{continuedFraction(b0, [1, 1, 1, ...], [b1, b2, b3, ...])}.
 
     partialNumerators :   % -> Stream R
-      ++ partialNumerators(x) extracts the numerators in \spadvar{x}.
+      ++ partialNumerators(x) extracts the numerators in \spad{x}.
       ++ That is, if \spad{x = continuedFraction(b0, [a1, a2, a3, ...],
       ++ [b1, b2, b3, ...])}, then \spad{partialNumerators(x) =
       ++ [a1, a2, a3, ...]}.
 
     partialDenominators : % -> Stream R
       ++ partialDenominators(x) extracts the denominators in
-      ++ \spadvar{x}.  That is, if \spad{x = continuedFraction(b0,
+      ++ \spad{x}.  That is, if \spad{x = continuedFraction(b0,
       ++ [a1, a2, a3, ...], [b1, b2, b3, ...])}, then
       ++ \spad{partialDenominators(x) = [b1, b2, b3, ...]}.
 
     partialQuotients :    % -> Stream R
       ++ partialQuotients(x) extracts the partial quotients in
-      ++ \spadvar{x}.  That is, if \spad{x = continuedFraction(b0,
+      ++ \spad{x}.  That is, if \spad{x = continuedFraction(b0,
       ++ [a1, a2, a3, ...], [b1, b2, b3, ...])}, then
       ++ \spad{partialQuotients(x) = [b0, b1, b2, b3, ...]}.
 
     wholePart :           % -> R
-      ++ wholePart(x) extracts the whole part of \spadvar{x}.  That
+      ++ wholePart(x) extracts the whole part of \spad{x}.  That
       ++ is, if \spad{x = continuedFraction(b0, [a1, a2, a3, ...],
       ++ [b1, b2, b3, ...])}, then \spad{wholePart(x) = b0}.
 
     reducedForm :         % -> %
-      ++ reducedForm(x) puts the continued fraction \spadvar{x} in
+      ++ reducedForm(x) puts the continued fraction \spad{x} in
       ++ reduced form, i.e.  the function returns an equivalent
       ++ continued fraction of the form
       ++ \spad{continuedFraction(b0, [1, 1, 1, ...], [b1, b2, b3, ...])}.
 
     approximants :        % -> Stream Q
       ++ approximants(x) returns the stream of approximants of the
-      ++ continued fraction \spadvar{x}. If the continued fraction is
+      ++ continued fraction \spad{x}. If the continued fraction is
       ++ finite, then the stream will be infinite and periodic with
       ++ period 1.
 
     convergents :         % -> Stream Q
       ++ convergents(x) returns the stream of the convergents of the
-      ++ continued fraction \spadvar{x}. If the continued fraction is
+      ++ continued fraction \spad{x}. If the continued fraction is
       ++ finite, then the stream will be finite.
 
     numerators :          % -> Stream R
       ++ numerators(x) returns the stream of numerators of the
-      ++ approximants of the continued fraction \spadvar{x}. If the
+      ++ approximants of the continued fraction \spad{x}. If the
       ++ continued fraction is finite, then the stream will be finite.
 
     denominators :        % -> Stream R
       ++ denominators(x) returns the stream of denominators of the
-      ++ approximants of the continued fraction \spadvar{x}. If the
+      ++ approximants of the continued fraction \spad{x}. If the
       ++ continued fraction is finite, then the stream will be finite.
 
     extend :              (%, Integer) -> %
-      ++ extend(x, n) causes the first \spadvar{n} entries in the
-      ++ continued fraction \spadvar{x} to be computed.  Normally
+      ++ extend(x, n) causes the first \spad{n} entries in the
+      ++ continued fraction \spad{x} to be computed.  Normally
       ++ entries are only computed as needed.
 
     complete :            % -> %
-      ++ complete(x) causes all entries in \spadvar{x} to be computed.
-      ++ Normally entries are only computed as needed.  If \spadvar{x}
+      ++ complete(x) causes all entries in \spad{x} to be computed.
+      ++ Normally entries are only computed as needed.  If \spad{x}
       ++ is an infinite continued fraction, a user-initiated interrupt is
       ++ necessary to stop the computation.
 
@@ -118,6 +118,7 @@ ContinuedFraction(R) : Exports == Implementation where
     Rep :=  Record(value : Record(whole : R, fract : Str), reduced? : Boolean)
 
     import from Str
+    import from Stream(Q)
 
     genFromSequence :     Stream Q -> %
     genReducedForm :      (Q, Stream Q, MT)    -> Stream Rec

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

@@ -20,6 +20,8 @@ CRApackage(R : EuclideanDomain) : Exports == Implementation where
         ++ multiEuclideanTree(l, r) \undocumented{}
   Implementation == add
 
+    import from Integer
+
     BB := BalancedBinaryTree(R)
     x : BB
 

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

@@ -89,7 +89,7 @@ ComplexRootFindingPackage(R, UP) : public == private where
        ++ Note: this function depends on \spadfunFrom{abs}{Complex}.
      pleskenSplit : (UP, R, Boolean)  ->  FR UP
        ++ pleskenSplit(poly, eps, info) determines a start polynomial {\em start}
-       ++ by using "startPolynomial then it increases the exponent
+       ++ by using "startPolynomial" then it increases the exponent
        ++ n of {\em start ^ n mod poly} to get an approximate factor of
        ++ {\em poly}, in general of degree "degree poly -1". Then a divisor
        ++ cascade is calculated and the best splitting is chosen, as soon
@@ -100,7 +100,7 @@ ComplexRootFindingPackage(R, UP) : public == private where
        ++ If {\em info} is {\em true}, then information messages are issued.
      pleskenSplit : (UP, R)  ->  FR UP
        ++ pleskenSplit(poly, eps)  determines a start polynomial {\em start}\
-       ++ by using "startPolynomial then it increases the exponent
+       ++ by using "startPolynomial" then it increases the exponent
        ++ n of {\em start ^ n mod poly} to get an approximate factor of
        ++ {\em poly}, in general of degree "degree poly -1". Then a divisor
        ++ cascade is calculated and the best splitting is chosen, as soon
@@ -109,7 +109,7 @@ ComplexRootFindingPackage(R, UP) : public == private where
        --++ to use the whole information to get a split into more than 2
        --++ factors.
      reciprocalPolynomial : UP  -> UP
-       ++ reciprocalPolynomial(p) calulates a polynomial which has exactly
+       ++ reciprocalPolynomial(p) calculates a polynomial which has exactly
        ++ the inverses of the non-zero roots of p as roots, and the same
        ++ number of 0-roots.
      rootRadius : (UP, R) -> R
@@ -145,6 +145,7 @@ ComplexRootFindingPackage(R, UP) : public == private where
 
    private ==> add
 
+     import from List(UP)
 
      Rep := ModMonic(C, UP)
 
@@ -244,7 +245,7 @@ ComplexRootFindingPackage(R, UP) : public == private where
        notFoundSplit : Boolean := true
        while notFoundSplit repeat
        --  if info then
-       --    lof : L OF := ["not successfull, new exponent:", nn::OF]
+       --    lof : L OF := ["not successful, new exponent:", nn::OF]
        --    print hconcat lof
          psR := psR * psR * sR   -- exponent (2*d +1)
          -- be careful, too large exponent results in rounding errors

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

@@ -1,6 +1,5 @@
 )abbrev category FFCAT FunctionFieldCategory
 )boot $tryRecompileArguments := nil
-++ Function field of a curve
 ++ Author: Manuel Bronstein
 ++ Date Created: 1987
 ++ Description: This category is a model for the function field of a
@@ -129,9 +128,10 @@ FunctionFieldCategory(F, UP, UPUP) : Category == Definition where
       ++ hyperelliptic() returns \spad{p(x)} if the curve is the hyperelliptic
       ++ defined by \spad{y^2 = p(x)}, "failed" otherwise.
     algSplitSimple         : (%, UP -> UP) -> REC
-      ++ algSplitSimple(f, D) returns \spad{[h, d, d', g]} such that \spad{f=h/d},
-      ++ \spad{h} is integral at all the normal places w.r.t. \spad{D},
-      ++ \spad{d' = Dd}, \spad{g = gcd(d, discriminant())} and \spad{D}
+      ++ algSplitSimple(f, D) returns \spad{[h, d, d', g]} such that
+      ++ \spad{f=h/d}, \spad{h} is integral at all the normal places
+      ++ with respect to \spad{D}, \spad{d' = Dd},
+      ++ \spad{g = gcd(d, discriminant())} and \spad{D}
       ++ is the derivation to use. \spad{f} must have at most simple finite
       ++ poles.
     if F has Field then
@@ -381,10 +381,9 @@ FunctionFieldCategory(F, UP, UPUP) : Category == Definition where
 )boot $tryRecompileArguments := true
 
 )abbrev package MMAP MultipleMap
-++ Lifting a map through 2 levels of polynomials
 ++ Author: Manuel Bronstein
 ++ Date Created: May 1988
-++ Description: Lifting of a map through 2 levels of polynomials;
+++ Description: Lifting of a map through 2 levels of polynomials.
 MultipleMap(R1, UP1, UPUP1, R2, UP2, UPUP2) : Exports == Implementation where
   R1   : IntegralDomain
   UP1  : UnivariatePolynomialCategory R1
@@ -412,7 +411,6 @@ MultipleMap(R1, UP1, UPUP1, R2, UP2, UPUP2) : Exports == Implementation where
           p)$UnivariatePolynomialCategoryFunctions2(Q1, UPUP1, Q2, UPUP2)
 
 )abbrev package FFCAT2 FunctionFieldCategoryFunctions2
-++ Lifts a map from rings to function fields over them
 ++ Author: Manuel Bronstein
 ++ Date Created: May 1988
 ++ Description: Lifts a map from rings to function fields over them.
@@ -436,7 +434,6 @@ FunctionFieldCategoryFunctions2(R1, UP1, UPUP1, F1, R2, UP2, UPUP2, F2):
       reduce(map(f, lift f1)$MultipleMap(R1, UP1, UPUP1, R2, UP2, UPUP2))
 
 )abbrev package CHVAR ChangeOfVariable
-++ Sends a point to infinity
 ++ Author: Manuel Bronstein
 ++ Date Created: 1988
 ++ Description:
@@ -583,12 +580,11 @@ ChangeOfVariable(F, UP, UPUP) : Exports == Implementation where
       [pr.exponent, d / pr.coef, */(pr.radicand)]
 
 )abbrev domain RADFF RadicalFunctionField
-++ Function field defined by y^n = f(x)
 ++ Author: Manuel Bronstein
 ++ Date Created: 1987
 ++ Keywords: algebraic, curve, radical, function, field.
-++ Description: Function field defined by y^n = f(x);
-++ Examples: )r RADFF INPUT
+++ Description: Function field defined by y^n = f(x).
+++ Examples: )r radff.input
 RadicalFunctionField(F, UP, UPUP, radicnd, n) : Exports == Impl where
   F       : UniqueFactorizationDomain
   UP      : UnivariatePolynomialCategory F
@@ -779,12 +775,10 @@ RadicalFunctionField(F, UP, UPUP, radicnd, n) : Exports == Impl where
         zero?(((radcand() exquo (monomial(1, 1)$UP-point::UP))::UP) point)
 
 )abbrev domain ALGFF AlgebraicFunctionField
-++ Function field defined by f(x, y) = 0
 ++ Author: Manuel Bronstein
 ++ Date Created: 3 May 1988
 ++ Keywords: algebraic, curve, function, field.
 ++ Description: Function field defined by f(x, y) = 0.
-++ Examples: )r ALGFF INPUT
 AlgebraicFunctionField(F, UP, UPUP, modulus) : Exports == Impl where
   F      : Field
   UP     : UnivariatePolynomialCategory F

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

@@ -90,6 +90,8 @@ CycleIndicators : Exports == Implementation where
   Implementation ==> add
     import from PartitionsAndPermutations
     import from IntegerNumberTheoryFunctions
+    import from Factored(Integer)
+    import from Fraction(Integer)
 
     trm : PTN -> SPOL RN
     trm pt == monomial(inv(pdct(pt) :: RN), pt)
@@ -235,7 +237,7 @@ CycleIndicators : Exports == Implementation where
 ++ Keywords:
 ++ Examples:
 ++ References:
-++ Description: This package is to be used in conjuction with
+++ Description: This package is to be used in conjunction with
 ++             the CycleIndicators package. It provides an evaluation
 ++             function for SymmetricPolynomials.
 -- Currently unused.

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

@@ -3,6 +3,7 @@
 ++ References:
 ++  A. Arnold, M. Monagan, Calculating cyclotomic polynomials,
 ++  Math. Comp. 80 (276) 2011, 2359-2379.
+++ Description: Utilities for computations with cyclotomic polynomials.
 CyclotomicUtilities : Exports == Implementation where
   iT ==> Integer
   pA ==> PrimitiveArray(iT)
@@ -33,6 +34,8 @@ CyclotomicUtilities : Exports == Implementation where
 
   Implementation ==> add
 
+    import from Factored(Integer)
+
     lU ==> Union(List(Integer), "failed")
 
     recursive_check_even : (pA, Integer, Integer, Integer,

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

@@ -30,6 +30,8 @@ CylindricalAlgebraicDecompositionUtilities(R, P) : PUB == PRIV where
 
   PRIV == add
 
+     import from Integer
+
      gcdBasisAdd : (P, List(P)) -> List(P)
        -- add one polynomial to list of pairwise relatively prime polynomials
 
@@ -212,6 +214,8 @@ Cell(TheField) : PUB == PRIV where
 
     RepT ==> List(SCELL)
 
+    import from SCELL
+
     simpleCells(c) == c pretend RepT
 
     Rep := RepT
@@ -322,6 +326,8 @@ CylindricalAlgebraicDecompositionPackage(TheField) : PUB == PRIV where
      PACK1 ==> CylindricalAlgebraicDecompositionUtilities(ThePols, RUP)
      PACK2 ==> CylindricalAlgebraicDecompositionUtilities(TheField, BUP)
 
+     import from Integer
+
      specialise(lpols, cell) ==
          lpols = [] => error("specialise: empty list of pols")
          sp := samplePoint(cell)

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

@@ -184,7 +184,7 @@ DefiniteIntegrationTools(R, F) : Exports == Implementation where
         -- select!(s +-> keeprec?(i.halfinf.endpoint, s), l)
         ep := i.halfinf.endpoint
         select!(s +-> keeprec?(ep, s), l)
-      error "findRealZero: should not happpen"
+      error "findRealZero: should not happen"
 
     checkBudan(p, a, b, incl?) ==
       r := retractIfCan(b)@Union(F, "failed")