passagemath-fricas 10.5.39__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/divisor.spad

@@ -2,7 +2,6 @@
 ++ Author: Manuel Bronstein
 ++ Date Created: 27 Jan 1989
 ++ Keywords: ideal, algebra, module.
-++ Examples: )r FRIDEAL INPUT
 ++ Description: Fractional ideals in a framed algebra.
 FractionalIdeal(R, F, UP, A) : Exports == Implementation where
   R : EuclideanDomain
@@ -176,10 +175,10 @@ FractionalIdeal(R, F, UP, A) : Exports == Implementation where
       i
 
 )abbrev package FRIDEAL2 FractionalIdealFunctions2
-++ Lifting of morphisms to fractional ideals.
 ++ Author: Manuel Bronstein
 ++ Date Created: 1 Feb 1989
 ++ Keywords: ideal, algebra, module.
+++ Description: Lifting of morphisms to fractional ideals.
 FractionalIdealFunctions2(R1, F1, U1, A1, R2, F2, U2, A2):
  Exports == Implementation where
   R1, R2 : EuclideanDomain
@@ -209,10 +208,10 @@ FractionalIdealFunctions2(R1, F1, U1, A1, R2, F2, U2, A2):
              for j in minIndex b .. maxIndex b]$Vector(A2)
 
 )abbrev package MHROWRED ModularHermitianRowReduction
-++ Modular hermitian row reduction.
 ++ Author: Manuel Bronstein
 ++ Date Created: 22 February 1989
 ++ Keywords: matrix, reduction.
+++ Description: Modular hermitian row reduction.
 -- should be moved into matrix whenever possible
 ModularHermitianRowReduction(R) : Exports == Implementation where
   R : EuclideanDomain
@@ -464,7 +463,6 @@ ModularHermitianRowReduction(R) : Exports == Implementation where
 ++ Author: Manuel Bronstein
 ++ Date Created: 27 Jan 1989
 ++ Keywords: ideal, algebra, module.
-++ Examples: )r FRIDEAL INPUT
 ++ Description: Module representation of fractional ideals.
 FractionalIdealAsModule(R, F, UP, A, ibasis) : Exports == Implementation where
   R     : EuclideanDomain
@@ -563,7 +561,6 @@ FractionalIdealAsModule(R, F, UP, A, ibasis) : Exports == Implementation where
         module(basis i) * module(ibasis)
 
 )abbrev category FDIVCAT FiniteDivisorCategory
-++ Category for finite rational divisors on a curve
 ++ Author: Manuel Bronstein
 ++ Date Created: 19 May 1993
 ++ Description:
@@ -571,7 +568,7 @@ FractionalIdealAsModule(R, F, UP, A, ibasis) : Exports == Implementation where
 ++ is finite formal sums SUM(n * P) where the n's are integers and the
 ++ P's are finite rational points on the curve.
 ++ Keywords: divisor, algebraic, curve.
-++ Examples: )r FDIV INPUT
+++ Examples: )r divisor.input
 FiniteDivisorCategory(F, UP, UPUP, R) : Category == Result where
   F   : Field
   UP  : UnivariatePolynomialCategory F
@@ -631,7 +628,6 @@ FiniteDivisorCategory(F, UP, UPUP, R) : Category == Result where
         divisor(h - (r * dp)::Fraction(UP)::R, d, g)
 
 )abbrev domain HELLFDIV HyperellipticFiniteDivisor
-++ Finite rational divisors on an hyperelliptic curve
 ++ Author: Manuel Bronstein
 ++ Date Created: 19 May 1993
 ++ Description:
@@ -640,7 +636,6 @@ FiniteDivisorCategory(F, UP, UPUP, R) : Category == Result where
 ++ P's are finite rational points on the curve.
 ++ The equation of the curve must be  y^2 = f(x) and f must have odd degree.
 ++ Keywords: divisor, algebraic, curve.
-++ Examples: )r FDIV INPUT
 HyperellipticFiniteDivisor(F, UP, UPUP, R) : Exports == Implementation where
   F   : Field
   UP  : UnivariatePolynomialCategory F
@@ -808,7 +803,6 @@ HyperellipticFiniteDivisor(F, UP, UPUP, R) : Exports == Implementation where
       reduce makeDivisor(a, bb, 1)
 
 )abbrev domain FDIV FiniteDivisor
-++ Finite rational divisors on a curve
 ++ Author: Manuel Bronstein
 ++ Date Created: 1987
 ++ Description:
@@ -816,7 +810,7 @@ HyperellipticFiniteDivisor(F, UP, UPUP, R) : Exports == Implementation where
 ++ is finite formal sums SUM(n * P) where the n's are integers and the
 ++ P's are finite rational points on the curve.
 ++ Keywords: divisor, algebraic, curve.
-++ Examples: )r FDIV INPUT
+++ Examples: )r divisor.input
 FiniteDivisor(F, UP, UPUP, R) : Exports == Implementation where
   F   : Field
   UP  : UnivariatePolynomialCategory F
@@ -945,9 +939,9 @@ FiniteDivisor(F, UP, UPUP, R) : Exports == Implementation where
         divisor ideal [b::RF::R, h]$Vector(R)
 
 )abbrev package FDIV2 FiniteDivisorFunctions2
-++ Lift a map to finite divisors.
 ++ Author: Manuel Bronstein
 ++ Date Created: 1988
+++ Description: Lift a map to finite divisors.
 FiniteDivisorFunctions2(R1, UP1, UPUP1, F1, R2, UP2, UPUP2, F2):
  Exports == Implementation where
   R1   : Field

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

@@ -26,7 +26,7 @@ InnerEigenPackage(F : Field) : Exports == Implementation
      eigenvalues : (M, UP -> Factored(UP)) ->  List Eigenvalue
        ++ eigenvalues(m, fac) returns the eigenvalues of the
        ++ matrix m.  Eigenvalues in base field are given
-       ++ explicitly, other are represented by mininal polynomial.
+       ++ explicitly, other are represented by minimal polynomial.
        ++ fac is a factorizer for polynomials over F.
 
      eigenvector : (Eigenvalue, M)  ->  List AV
@@ -124,14 +124,7 @@ InnerEigenPackage(F : Field) : Exports == Implementation
      else
 
          characteristicPolynomial(A : M) : UP ==
-              dimA := nrows A
-              dimA ~= ncols A => error " The matrix is not square"
-              dimA = 0 => 1$UP
-              B : Matrix(UP) := zero(dimA, dimA)
-              for i in 1..dimA repeat
-                  for j in 1..dimA repeat  B(i, j) := A(i, j)::UP
-                  B(i, i) := B(i, i) - monomial(1, 1)$UP
-              determinant B
+              char_pol_via_berkovitz(A)$CharacteristicPolynomial4(F)
 
      eigenvalues(A : M, fac : UP -> Factored(UP)) : List Eigenvalue ==
          pol := characteristicPolynomial(A)
@@ -260,7 +253,7 @@ EigenPackage(R) : Exports == Implementation where
        ++ returns the generalized eigenvectors
        ++ of the matrix relative to the eigenvalue alpha.
        ++ The integers k and g are respectively the algebraic and the
-       ++ geometric multiplicity of tye eigenvalue alpha.
+       ++ geometric multiplicity of the eigenvalue alpha.
 
      generalizedEigenvector  : (EigenForm, M) -> List M
        ++ generalizedEigenvector(eigen, m) returns the generalized
@@ -312,7 +305,8 @@ EigenPackage(R) : Exports == Implementation where
           matrix([[UP_to_F(v(i), x)] for i in 1..#v])
 
       characteristicPolynomial(m : M, x : SY) ==
-          numer((characteristicPolynomial(m)$IEP)(x::P::F))
+          up := char_pol_via_berkovitz(m)$CharacteristicPolynomial4(F)
+          numer(up(x::P::F))
 
       characteristicPolynomial(m : M) : P ==
           characteristicPolynomial(m, new()$SY)
@@ -381,14 +375,8 @@ CharacteristicPolynomialPackage(R : CommutativeRing) : C == T where
 
            ---- characteristic polynomial  ----
      characteristicPolynomial(A : M, v : R) : R ==
-       dimA := nrows A
-       dimA ~= ncols A => error " The matrix is not square"
-       dimA = 0 => 1$R
-       B : M := zero(dimA, dimA)
-       for i in 1..dimA repeat
-         for j in 1..dimA repeat  B(i, j) := A(i, j)
-         B(i, i) := B(i, i) - v
-       determinant B
+         up := char_pol_via_berkovitz(A)$CharacteristicPolynomial4(R)
+         up(v)
 
 --Copyright (c) 1991-2002, The Numerical ALgorithms Group Ltd.
 --All rights reserved.

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

@@ -2,7 +2,7 @@
 ++ Author: Manuel Bronstein
 ++ Date Created: 1987
 ++ Keywords: elementary, function, logarithm, exponential.
-++ Examples:  )r EF INPUT
+++ Examples:  )r elemfun.input
 ++ Description: Provides elementary functions over an integral domain.
 ElementaryFunction(R, F) : Exports == Implementation where
   R : Join(Comparable, IntegralDomain)

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

@@ -182,7 +182,7 @@ UnivariatePuiseuxSeriesWithExponentialSingularity(R, FE, var, cen) : _
       -- order singularity.
       -- 'failedTerms' will contain terms which have an exponential
       -- singularity, where we cannot say whether the limiting value
-      -- is zero or infinity. Only terms with a higher order sigularity
+      -- is zero or infinity. Only terms with a higher order singularity
       -- than the terms on 'infiniteList' are included.
       -- 'pSeries' will be a Puiseux series representing a term without an
       -- exponential singularity.  'pSeries' will be non-zero only when no

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

@@ -70,7 +70,7 @@ Export3D() : with
       unparse(convert(d)@InputForm)
 
   -- this writes SubSpace geometry to Wavefront (.OBJ) 3D file format
-  -- reqires SubSpace to contain 3 or 4 dimensional points over DoubleFloat
+  -- requires SubSpace to contain 3 or 4 dimensional points over DoubleFloat
   -- to export a function plot try:
   -- writeObj(subspace(makeObject(x*x-y*y,x=-1..1,y=-1..1)),"myfile.obj")
   -- colour dimension is ignored

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

@@ -13,10 +13,9 @@ Expression(R : Comparable) : Exports == Implementation where
   CF  ==> CombinatorialFunction(R, %)
   LF  ==> LiouvillianFunction(R, %)
   AN  ==> AlgebraicNumber
-  KAN ==> Kernel AN
   FSF ==> FunctionalSpecialFunction(R, %)
-  ESD ==> ExpressionSpace_&(%)
-  FSD ==> FunctionSpace_&(%, R)
+  ESD ==> ExpressionSpace2_&(%, K)
+  FSD ==> FunctionSpace2_&(%, R, K)
   POWER  ==> '%power
   SUP    ==> SparseUnivariatePolynomial
 
@@ -328,10 +327,18 @@ Expression(R : Comparable) : Exports == Implementation where
             lerchPhi(z, s, a) == lerchPhi(z, s, a)$FSF
             riemannZeta(z) == riemannZeta(z)$FSF
             charlierC(n, a, z) == charlierC(n, a, z)$FSF
+            hahn_p(n, a, b, c, z) == hahn_p(n, a, b, c, z)$FSF
+            hahnQ(n, a, b, c, z) == hahnQ(n, a, b, c, z)$FSF
+            hahnR(n, a, b, c, z) == hahnR(n, a, b, c, z)$FSF
+            hahnS(n, a, b, c, z) == hahnS(n, a, b, c, z)$FSF
             hermiteH(n, z) == hermiteH(n, z)$FSF
+            krawtchoukK(n, b, c, z) == krawtchoukK(n, b, c, z)$FSF
             jacobiP(n, a, b, z) == jacobiP(n, a, b, z)$FSF
             laguerreL(n, a, z) == laguerreL(n, a, z)$FSF
             meixnerM(n, b, c, z) == meixnerM(n, b, c, z)$FSF
+            meixnerP(n, b, c, z) ==  meixnerP(n, b, c, z)$FSF
+            racahR(n, a, b, c, d, z) ==  racahR(n, a, b, c, d, z)$FSF
+            wilsonW(n, a, b, c, d, z) == wilsonW(n, a, b, c, d, z)$FSF
 
             if % has RetractableTo(Integer) then
                 hypergeometricF(la, lb, x) == hypergeometricF(la, lb, x)$FSF
@@ -596,21 +603,20 @@ Expression(R : Comparable) : Exports == Implementation where
                 retractIfCan(x : %) : Union(Q, "failed") == retractIfCan(x)$Rep
 
                 if not(R is AN) then
-                    k2expr  : KAN -> %
-                    smp2expr : SparseMultivariatePolynomial(Integer, KAN) -> %
+                    EI ==> Expression(Integer)
+                    ER ==> Expression(R)
                     R2AN    : R  -> Union(AN, "failed")
                     k2an    : K  -> Union(AN, "failed")
                     smp2an  : MP -> Union(AN, "failed")
 
-                    coerce(x : AN) : % == smp2expr(numer x) / smp2expr(denom x)
-                    k2expr k ==
-                        map(x +-> x::%, k)$ExpressionSpaceFunctions2(AN, %)
+                    cor1(c : Integer) : R == c::R
 
-                    smp2expr p ==
-                        map(k2expr, x +-> x::%, p
-                           )$PolynomialCategoryLifting(IndexedExponents KAN,
-                             KAN, Integer, SparseMultivariatePolynomial(
-                               Integer, KAN), %)
+                    corR(xe : EI) : ER ==
+                        map(cor1, xe)$FunctionSpaceFunctions2(
+                            Integer, EI, R, ER)
+
+                    coerce(x : AN) : % ==
+                        corR(x pretend EI) pretend %
 
                     retractIfCan(x : %) : Union(AN, "failed") ==
                         ((n := smp2an numer x) case AN) and
@@ -623,8 +629,11 @@ Expression(R : Comparable) : Exports == Implementation where
                              u@Q::AN
                         "failed"
 
+                    AN_op?(op : BasicOperator) : Boolean ==
+                        has?(op, ALGOP) or belong?(op)$ExpressionSpace2_&(%, K)
+
                     k2an k ==
-                        not(belong?(op := operator k)$AN) => "failed"
+                        not(AN_op?(op := operator k)) => "failed"
                         is?(op, 'rootOf) =>
                             args := argument(k)
                             a2 := args.2
@@ -635,24 +644,28 @@ Expression(R : Comparable) : Exports == Implementation where
                             s1u case "failed" => "failed"
                             s1 := s1u@Symbol
                             a1 := args.1
-                            denom(a1) ~= 1 =>
+                            denu := retractIfCan(denom(a1)::%
+                                                )@Union(AN, "failed")
+                            denu case "failed" =>
                                 error "Bad argument to rootOf"
+                            den1 := denu@AN
                             eq := univariate(numer(a1), k1)
                             eqa : SUP(AN) := 0
                             while eq ~= 0 repeat
                                 cc := leadingCoefficient(eq)::%
                                 ccu := retractIfCan(cc)@Union(AN, "failed")
                                 ccu case "failed" => return "failed"
-                                eqa := eqa + monomial(ccu@AN, degree eq)
+                                eqa := eqa + monomial(ccu@AN/den1, degree eq)
                                 eq := reductum eq
                             rootOf(eqa, s1)$AN
-                        arg : List(AN) := empty()
+                        arg : List(AN) := []
                         for x in argument k repeat
                             if (a := retractIfCan(x)@Union(AN, "failed"))
                               case "failed" then
                                 return "failed"
                             else arg := concat(a@AN, arg)
-                        (operator(op)$AN) reverse!(arg)
+                        (operator(op)$EI)(reverse!(arg) pretend List(EI))
+                            pretend(AN)
 
                     smp2an p ==
                         (x1 := mainVariable p) case "failed" =>

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

@@ -201,13 +201,13 @@ FreeDivisionAlgebra(VAR, F) : Exports == Implementation where
 
     qzero? : (%, NNI, NNI, NNI, NNI) -> Boolean
       ++ \spad{qzero?(f, i_min, i_max, j_min, j_max)} is the
-      ++ spezified block zero (in the system matrix)?
+      ++ specified block zero (in the system matrix)?
     qzero? : (%, NNI, NNI, NNI, NNI, NNI) -> Boolean
       ++ \spad{qzero?(f, i_min, i_max, j_min, j_max, l)} is the
-      ++ spezified block zero in matrix l?
+      ++ specified block zero in matrix l?
     qzero? : (%, NNI, NNI, NNI, NNI, M1) -> Boolean
       ++ \spad{qzero?(f, i_min, i_max, j_min, j_max, m)} is the
-      ++ spezified block zero in the (system) matrix corresponding
+      ++ specified block zero in the (system) matrix corresponding
       ++ to the monomial m?
 
     blockStructure : (%) -> Matrix(NNI)
@@ -356,7 +356,7 @@ FreeDivisionAlgebra(VAR, F) : Exports == Implementation where
     factor : (%) -> List(%)
       ++ \spad{factor(f)} factorizes f in f=f_1*f_2*...*f_k with
       ++ atoms (irreducible elements) f_i. Notice that this factorization
-      ++ is unique only with respect to similiarity.
+      ++ is unique only with respect to similarity.
 
     factorizationTransformations : (%, NNI, NNI, List(EQG)) -> List(Matrix(F))
       ++ \spad{factorizationTransformations(f,k_rows,k_cols,sol)}
@@ -397,7 +397,7 @@ FreeDivisionAlgebra(VAR, F) : Exports == Implementation where
       ++ right minimization step with respect to the pivot block with
       ++ the rows/columns (i_min, ..., i_max).
     minimize : (%) -> %
-      ++ \spad{minimize(f)} minimizes the unterlying ALS by applying
+      ++ \spad{minimize(f)} minimizes the underlying ALS by applying
       ++ left and right block minimization steps. Minimality is only
       ++ guaranteed if the remaining blocks are refined.
 
@@ -2397,7 +2397,7 @@ FreeDivisionAlgebra(VAR, F) : Exports == Implementation where
         f.flg_refined := true
       f
 
-    -- FIXME: Detection of splitted zero blocks?
+    -- FIXME: Detection of split zero blocks?
     refinePERM! (f:%, i_min:NNI, i_max:NNI) : % ==
       n := f.size
       flg_tmp := false

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

@@ -408,7 +408,7 @@ ModularFactorizationGeneral(PA : Type, MMT : Type, MD : Type, PMD : Type,
       ++ irreducibles over field described by md.  pv is assumed
       ++ square-free and monic, md is info representing finite field.
     ddfact : (PA, MD) -> LDD
-      ++ ddfact(pv, md) computes distint degree factorization of
+      ++ ddfact(pv, md) computes distinct degree factorization of
       ++ pv.  pv is assumed square-free and monic, md is info representing
       ++ finite field.
     irreducible? : (PA, MD) -> Boolean

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

@@ -194,7 +194,7 @@ FiniteAlgebraicExtensionField(F : Field) : Category == _
         ++ be \spadfun{Frobenius}(a, k) which is {\em a^(q^k)},
         ++ where {\em q=size()\$F}.
       linearAssociatedOrder : % -> SparseUnivariatePolynomial F
-        ++ linearAssociatedOrder(a) retruns the monic polynomial {\em g} of
+        ++ linearAssociatedOrder(a) returns the monic polynomial {\em g} of
         ++ least degree, such that \spadfun{linearAssociatedExp}(a, g) is 0.
       linearAssociatedLog : % -> SparseUnivariatePolynomial F
         ++ linearAssociatedLog(a) returns a polynomial {\em g}, such that
@@ -445,7 +445,7 @@ FiniteFieldCategory() : Category ==_
        PolynomialFactorizationExplicit) with
     charthRoot : % -> %
       ++ charthRoot(a) takes the characteristic'th root of {\em a}.
-      ++ Note: such a root is alway defined in finite fields.
+      ++ Note: such a root is always defined in finite fields.
     -- the reason for implementing the following function is that we
     -- can implement the functions order, getGenerator and primitive? on
     -- category level without computing the, may be time intensive,

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

@@ -76,22 +76,13 @@ File(S : SetCategory) : FileCategory(FileName, S) with
             ++ If f is not open for reading, or if f is at the end of file
             ++ then \spad{"failed"} is the result.
     == add
-        FileState ==> SExpression
+        FileState ==> BasicFile
         IOMode    ==> String
 
         Rep := Record(fileName :    FileName,   _
                     fileState :   FileState,  _
                     fileIOmode :  IOMode)
 
-        defstream(fn : FileName, mode : IOMode) : FileState ==
-            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]
-
         f1 = f2 ==
             f1.fileName = f2.fileName
         coerce(f : %) : OutputForm ==
@@ -100,16 +91,16 @@ File(S : SetCategory) : FileCategory(FileName, S) with
         open fname ==
             open(fname, "input")
         open(fname, mode) ==
-            fstream := defstream(fname, mode)
+            fstream := open(fname, mode)$BasicFile
             [fname, fstream, mode]
         reopen!(f, mode) ==
             if f.fileIOmode = "output" then flush(f)
             fname := f.fileName
-            f.fileState := defstream(fname, mode)
+            f.fileState := open(fname, mode)$BasicFile
             f.fileIOmode := mode
             f
         close! f ==
-            SHUT(f.fileState)$Lisp
+            close!(f.fileState)$BasicFile
             f.fileIOmode := "closed"
             f
         name f ==
@@ -119,25 +110,22 @@ File(S : SetCategory) : FileCategory(FileName, S) with
         read! f ==
             f.fileIOmode ~= "input" =>
                 error "File not in read state"
-            x : None := fri_read(f.fileState)$Lisp
-            eof_marker?(x)$Lisp =>
-                error "End of file"
-            x pretend S
+            read(f.fileState)$BasicFile pretend S
         readIfCan! f ==
             f.fileIOmode ~= "input" =>
                 error "File not in read state"
-            x : None := fri_read(f.fileState)$Lisp
-            eof_marker?(x)$Lisp => "failed"
-            x pretend S
+            res1 : Union(None, "failed") := readIfCan(f.fileState)$BasicFile
+            res1 case "failed" => "failed"
+            (res1::None) pretend S
         write!(f, x) ==
             f.fileIOmode ~= "output" =>
                 error "File not in write state"
-            fri_write(x, f.fileState)$Lisp
+            write!(f.fileState, x pretend None)$BasicFile
             x
 
         flush f ==
             f.fileIOmode ~= "output" => error "File not in write state"
-            FORCE_-OUTPUT(f.fileState)$Lisp
+            flush(f.fileState)$BasicFile
 
 
 )abbrev domain TEXTFILE TextFile
@@ -154,7 +142,6 @@ File(S : SetCategory) : FileCategory(FileName, S) with
 ++   in these files using the native character set of the computer.
 
 TextFile : Cat == Def where
-    StreamName ==> Union(FileName, "console")
 
     Cat == FileCategory(FileName, String) with
         writeLine! : (%, String) -> String
@@ -187,7 +174,7 @@ TextFile : Cat == Def where
           ++ this test is always true.
 
     Def == File(String) add
-        FileState ==> SExpression
+        FileState ==> BasicFile
 
         Rep := Record(fileName :   FileName,    _
                       fileState :  FileState,   _
@@ -254,21 +241,14 @@ KeyedAccessFile(Entry) : KAFcategory == KAFcapsule where
 
     KAFcapsule == add
 
-        FileState ==> SExpression
+        FileState ==> BasicKeyedAccessFile
         IOMode    ==> String
 
 
         Cons := Record(car : SExpression, cdr : SExpression)
         Rep := Record(fileName :    Name,     _
                       fileState :   FileState,   _
-                      fileIOmode :  IOMode)
-
-        defstream(fn : Name, mode : IOMode) : FileState ==
-            mode = "input"  =>
-                rMkIstream(fn::String)$Lisp
-            mode = "output" =>
-                rMkOstream(fn::String)$Lisp
-            error ["IO mode must be input or output", mode]
+                      fileIOmode :  IOMode, rpos : Integer)
 
         ---- From Set ----
         f1 = f2 ==
@@ -284,28 +264,30 @@ KeyedAccessFile(Entry) : KAFcategory == KAFcapsule where
                 exists? fname =>
                     open(fname, "input")
                 reopen!(open(fname, "output"), "input")
-            [fname, defstream(fname, mode), mode]
+            [fname, open(fname, mode)$BasicKeyedAccessFile, mode, 0]
+
         reopen!(f, mode) ==
             close! f
             if mode ~= "closed" then
-                f.fileState := defstream(f.fileName, mode)
+                f.fileState := open(f.fileName, mode)$BasicKeyedAccessFile
                 f.fileIOmode  := mode
             f
         close! f  ==
             if f.fileIOmode ~= "closed" then
-                RSHUT(f.fileState)$Lisp
+                close!(f.fileState)$BasicKeyedAccessFile
                 f.fileIOmode  := "closed"
             f
         read! f ==
             f.fileIOmode ~= "input" => error ["File not in read state",f]
-            ks : List Symbol := RKEYIDS(f.fileName)$Lisp
-            empty?(ks) => error ["Attempt to read empty file", f]
-            ix := random(#ks)$Integer
-            k : String := PNAME(ks.ix)$Lisp
-            [k, SPADRREAD(k, f.fileState)$Lisp]
+            ks : List(String) := keys(f.fileState)$BasicKeyedAccessFile
+            #ks < f.rpos => error ["Attempt to read beyond end of file", f]
+            k : String := ks(f.rpos)
+            f.rpos := f.rpos + 1
+            [k, read(f.fileState, k)$BasicKeyedAccessFile pretend Entry]
         write!(f, pr) ==
             f.fileIOmode ~= "output" => error ["File not in write state",f]
-            SPADRWRITE(pr.key, pr.entry, f.fileState)$Lisp
+            write!(f.fileState, pr.key, pr.entry pretend None
+                  )$BasicKeyedAccessFile
             pr
         name f ==
             f.fileName
@@ -317,14 +299,13 @@ KeyedAccessFile(Entry) : KAFcategory == KAFcapsule where
             fn := new("", "kaf", "sdata")$Name
             open fn
         keys f ==
-            close! f
-            l : List SExpression := RKEYIDS(f.fileName)$Lisp
-            [PNAME(n)$Lisp for n in l]
+            reopen!(f, "input")
+            keys(f.fileState)$BasicKeyedAccessFile
         # f ==
             # keys f
         elt(f, k) ==
             reopen!(f, "input")
-            SPADRREAD(k, f.fileState)$Lisp
+            read(f.fileState, k)$BasicKeyedAccessFile pretend Entry
         setelt!(f, k, e) ==
             -- Leaves f in a safe, closed state.  For speed use "write".
             reopen!(f, "output")
@@ -334,12 +315,13 @@ KeyedAccessFile(Entry) : KAFcategory == KAFcapsule where
         search(k, f) ==
             not member?(k, keys f) => "failed"   -- can't trap RREAD error
             reopen!(f, "input")
-            (SPADRREAD(k, f.fileState)$Lisp)@Entry
+            read(f.fileState, k)$BasicKeyedAccessFile pretend Entry
         remove!(k : String, f : %)  ==
             result := search(k, f)
             result case "failed" => result
-            close! f
-            RDROPITEMS(NAMESTRING(f.fileName)$Lisp, LIST(k)$Lisp)$Lisp
+            reopen!(f, "output")
+            remove!(f.fileState, k)$BasicKeyedAccessFile
+            close!(f)
             result
         pack! f ==
             close! f