Edit detail for SubDomain revision 7 of 7

PositiveInteger and NonNegativeInteger are subdomains of Integer.

Domain is a domain whose values are all domains. Categories are values of the domain SubDomain Domain. For example:

Integer

(1)

Ring

(2)

Unfortunately the original Axiom library did not include definitions of these domains.

[Integer,PrimeField(3)]

 LISP output:
(UNPRINTABLE UNPRINTABLE)

[Ring,Field]

 LISP output:
(UNPRINTABLE UNPRINTABLE)

OpenAxiom has implemented Domain and replaced SubDomain Domain with Category. Here we try to provide something similar for FriCAS.

)abbrev domain DOMAIN Domain
Domain():SetCategory
  == add
    coerce(x:%):OutputForm ==
      n:SExpression:=devaluate(x)$Lisp
      #n=1 => car(n) pretend OutputForm
      n pretend OutputForm
    x = y ==
      devaluate(x)$Lisp = devaluate(y)$Lisp

   Compiling FriCAS source code from file 
      /var/zope2/var/LatexWiki/1491057242942260927-25px004.spad using 
      old system compiler.
   DOMAIN abbreviates domain Domain 
------------------------------------------------------------------------
   initializing NRLIB DOMAIN for Domain 
   compiling into NRLIB DOMAIN 
   compiling exported coerce : $ -> OutputForm
Time: 0.01 SEC.

   compiling exported = : ($,$) -> Boolean
Time: 0 SEC.

(time taken in buildFunctor:  0)

;;;     ***       |Domain| REDEFINED

;;;     ***       |Domain| REDEFINED
Time: 0 SEC.

   Cumulative Statistics for Constructor Domain
      Time: 0.01 seconds

   finalizing NRLIB DOMAIN 
   Processing Domain for Browser database:
--->-->Domain(): Missing Description
------------------------------------------------------------------------
   Domain is now explicitly exposed in frame initial 
   Domain will be automatically loaded when needed from 
      /var/zope2/var/LatexWiki/DOMAIN.NRLIB/DOMAIN

)abbrev domain SUBDOM SubDomain
SubDomain(D:Domain):SetCategory
  == add
    coerce(x:%):OutputForm ==
      n:SExpression:=devaluate(x)$Lisp
      #n=1 => car(n) pretend OutputForm
      n pretend OutputForm
    x = y ==
      devaluate(x)$Lisp = devaluate(y)$Lisp

   Compiling FriCAS source code from file 
      /var/zope2/var/LatexWiki/1455332092143083773-25px005.spad using 
      old system compiler.
   SUBDOM abbreviates domain SubDomain 
------------------------------------------------------------------------
   initializing NRLIB SUBDOM for SubDomain 
   compiling into NRLIB SUBDOM 
   compiling exported coerce : $ -> OutputForm
Time: 0.01 SEC.

   compiling exported = : ($,$) -> Boolean
Time: 0 SEC.

(time taken in buildFunctor:  0)

;;;     ***       |SubDomain| REDEFINED

;;;     ***       |SubDomain| REDEFINED
Time: 0 SEC.

   Cumulative Statistics for Constructor SubDomain
      Time: 0.01 seconds

   finalizing NRLIB SUBDOM 
   Processing SubDomain for Browser database:
--->-->SubDomain(): Missing Description
------------------------------------------------------------------------
   SubDomain is now explicitly exposed in frame initial 
   SubDomain will be automatically loaded when needed from 
      /var/zope2/var/LatexWiki/SUBDOM.NRLIB/SUBDOM

[Integer,PrimeField(3)]

(3)

%.1

(4)

[Ring,Field,IntegerNumberSystem]

(5)

Also we would like to be able to coerce both Domain and SubDomain to InputForm

Integer::InputForm

   Cannot convert from type Domain to InputForm for value
   Integer()

Coercions like these are a special case in the Axiom interpreter. Here we modify the treatment for InputForm in references to '(InputForm) below.

From: interp/i-coerce.boot

coerceInteractive(triple,t2) ==
  -- bind flag for recording/reporting instantiations
  -- (see recordInstantiation)
  t1 := objMode triple
  val := objVal triple
  null(t2) or t2 = $EmptyMode => NIL
  t2 = t1 => triple
  t2 = '$NoValueMode => objNew(val,t2)
  if t2 is ['SubDomain,x,.] then t2:= x
  -- JHD added category Aug 1996 for BasicMath
  -- WSP modified for coercion to InputForm Sept 2008
  t1 in '((Category) (Mode) (Domain) (SubDomain (Domain))) =>
    t2 = $OutputForm => objNew(val,t2)
    t2 = '(InputForm) => objNewWrap(val,t2)
    NIL
  t1 = '$NoValueMode =>
    if $compilingMap then clearDependentMaps($mapName,nil)
    throwKeyedMsg("S2IC0009",[t2,$mapName])
  $insideCoerceInteractive: local := true
  expr2 := EQUAL(t2,$OutputForm)
  if expr2 then startTimingProcess 'print
  else startTimingProcess 'coercion
  -- next 2 lines handle cases like '"failed"
  result :=
    expr2 and (t1 = val) => objNew(val,$OutputForm)
    expr2 and t1 is ['Variable,var] => objNewWrap(var,$OutputForm)
    t2 = '(InputForm) => objNewWrap(val,t2)
    coerceInt0(triple,t2)
  if expr2 then stopTimingProcess 'print
  else stopTimingProcess 'coercion
  result

Value = T
; (DEFUN |coerceInteractive| ...) is being compiled.
;; The variable |$OutputForm| is undefined.
;; The compiler will assume this variable is a global.
Value = 2544

Now we get

a:=Integer::InputForm

(6)

interpret(a)$InputForm

(7)

unparse(a)$InputForm

(8)

b:=PrimeField(11)::InputForm

(9)

interpret(b)$InputForm

(10)

unparse(b)$InputForm

(11)

c:=DirectProduct(3,Fraction Integer)::InputForm

(12)

interpret(c)$InputForm

(13)

unparse(c)$InputForm

(14)

d:=Ring::InputForm

(15)

interpret(d)$InputForm

(16)

unparse(d)$InputForm

(17)

Here is a useful function for parsing input strings

parse(s:String):InputForm == ncParseFromString(s)$Lisp pretend InputForm

   Function declaration parse : String -> InputForm has been added to
      workspace.

parse("Integer")

Compiling function parse with type String -> InputForm

(18)

There are still problems problems with values of domains in types

)set output tex off

)set output algebra on

CliffordAlgebra(4,Fraction Integer, quadraticForm matrix [[1,0,0,0], [0,-1,0,0], [0,0,-1,0],
[0,0,0,-1]])

   (22)  CliffordAlgebra(4,Fraction Integer,MATRIX)

%::InputForm

   (23)
   (CliffordAlgebra  4  (Fraction (Integer))

     [[1(),0(),0(),0()], [0(),- 1(),0(),0()], [0(),0(),- 1(),0()],
      [0(),0(),0(),- 1()]]
     )

parse("CliffordAlgebra(4,Fraction Integer, quadraticForm matrix [[1,0,0,0], [0,-1,0,0],
[0,0,-1,0], [0,0,0,-1]])")

   (24)
   (CliffordAlgebra  4  (Fraction Integer)

     (quadraticForm

       (matrix

         (construct  (construct 1 0 0 0)  (construct 0 (- 1) 0 0)
          (construct 0 0 (- 1) 0)  (construct 0 0 0 (- 1)))
         )
       )
     )

interpret(%)

   (25)  CliffordAlgebra(4,Fraction Integer,MATRIX)

%::InputForm

   (26)
   ((Domain)  CliffordAlgebra  4  (Fraction (Integer))

     [[1(),0(),0(),0()], [0(),- 1(),0(),0()], [0(),0(),- 1(),0()],
      [0(),0(),0(),- 1()]]
     )

We can easily implement similar functionality at the Spad (algebra library) level by extending the InputFormFunction1 package. But limitation of FriCAS that prevent us from passing domain-values as parameters of functions mean we must do it this way.

)abbrev package INFORM1 InputFormFunctions1
--)boot $noSubsumption := false

++ Tools for manipulating input forms
++ Author: Manuel Bronstein
++ Date Created: ???
++ Date Last Updated: 19 April 1991
++ Description: Tools for manipulating input forms.

InputFormFunctions1(R:Type):with
  packageCall: Symbol -> InputForm
    ++ packageCall(f) returns the input form corresponding to f$R.
  interpret  : InputForm -> R
    ++ interpret(f) passes f to the interpreter, and transforms
    ++ the result into an object of type R.
  domainToInputForm: () -> InputForm
    ++ convert a domain to InputForm
 == add
  domainToInputForm():InputForm == devaluate(R)$Lisp

  packageCall name ==
    convert([convert("$elt"::Symbol), domainToInputForm(),
                                convert name]$List(InputForm))@InputForm

  interpret form ==

    retract(interpret(convert([convert("@"::Symbol), form,
          domainToInputForm()]$List(InputForm))@InputForm)$InputForm)$AnyFunctions1(R)

   Compiling FriCAS source code from file 
      /var/zope2/var/LatexWiki/8025279438643830910-25px014.spad using 
      old system compiler.
   INFORM1 abbreviates package InputFormFunctions1 
------------------------------------------------------------------------
   initializing NRLIB INFORM1 for InputFormFunctions1 
   compiling into NRLIB INFORM1 
   compiling exported domainToInputForm : () -> InputForm
Time: 0.05 SEC.

   compiling exported packageCall : Symbol -> InputForm
Time: 0.03 SEC.

   compiling exported interpret : InputForm -> R
Time: 0.07 SEC.

(time taken in buildFunctor:  0)

;;;     ***       |InputFormFunctions1| REDEFINED

;;;     ***       |InputFormFunctions1| REDEFINED
Time: 0 SEC.

   Cumulative Statistics for Constructor InputFormFunctions1
      Time: 0.15 seconds

   finalizing NRLIB INFORM1 
   Processing InputFormFunctions1 for Browser database:
--------(packageCall ((InputForm) (Symbol)))---------
--------(interpret (R (InputForm)))---------
--------(domainToInputForm ((InputForm)))---------
--->/usr/local/lib/fricas/target/x86_64-unknown-linux/../../src/algebra/INFORM1.spad-->InputFormFunctions1((domainToInputForm ((InputForm)))): Improper first word in comments: convert
"convert a domain to InputForm"
--------constructor---------
------------------------------------------------------------------------
   InputFormFunctions1 is now explicitly exposed in frame initial 
   InputFormFunctions1 will be automatically loaded when needed from 
      /var/zope2/var/LatexWiki/INFORM1.NRLIB/INFORM1

domainToInputForm()$INFORM1(PrimeField 7)

   (27)  (PrimeField 7)

interpret(parse("x^2+1"))$INFORM1(Polynomial Float)

          2
   (28)  x  + 1.0