Edit detail for SubDomain revision 6 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.01 SEC.

   Cumulative Statistics for Constructor Domain
      Time: 0.02 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)

K := Fraction Integer

(18)

g := matrix [[1,0,0,0], [0,-1,0,0], [0,0,-1,0], [0,0,0,-1]]

(19)

D := CliffordAlgebra(4,K, quadraticForm g)

(20)

D::InputForm

(21)

unparse %

(22)

We can easily implement similar functionality at the Spad (algebra library) level by extending the InputFormFunction1 package.

)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-25px011.spad using 
      old system compiler.
   INFORM1 abbreviates package InputFormFunctions1 
------------------------------------------------------------------------
   initializing NRLIB INFORM1 for InputFormFunctions1 
   compiling into NRLIB INFORM1 
   compiling exported domainToInputForm : () -> InputForm
Time: 0.01 SEC.

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

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

(time taken in buildFunctor:  0)

;;;     ***       |InputFormFunctions1| REDEFINED

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

   Cumulative Statistics for Constructor InputFormFunctions1
      Time: 0.18 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)

(23)

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

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

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

Compiling function parse with type String -> InputForm

(24)