Edit detail for SandBoxSymbolic revision 34 of 35

Symbolic Integers

A simple form of symbolic computation using just Variable and Integer.

a:Union(Variable a,Integer)

b:Union(Variable b,Integer)

c:=a*3-b*2

(1)

p:UP(x,Integer):=x*2-7

(2)

pc := p c

(3)

f(x)==x^3-x^2+1

fb := f b

Compiling function f with type Variable(b) -> Polynomial(Integer)

(4)

a:=1

(5)

b:=-3

(6)

c

(7)

eval(pc,['a=a,'b=b])

(8)

eval(c,['a=a,'b=b])

(9)

eval(fb,['a=a,'b=b])

(10)

a:=3.14  -- not permitted!

   Cannot convert right-hand side of assignment
   3.14

      to an object of the type Union(Variable(a),Integer) of the 
      left-hand side.
a:='b    -- not permitted!

   Cannot convert right-hand side of assignment
   b

      to an object of the type Union(Variable(a),Integer) of the 
      left-hand side.

For more complex cases it is necessary to define a new domain of "indeterminants". These are symbols and unevaluated expressions that can be evaluated at a later time. This domain is modeled after InputForm? which provides all of the basic functionality.

)abbrev domain INDET Indeterminant
++ Description:
++   This domain provides basic support for symbols and unevaluated expressions
++   Based on InputForm
-- Author: Bill Page
Indeterminant():
  Join(SExpressionCategory(String,Symbol,Integer,DoubleFloat,OutputForm),
       ConvertibleTo SExpression) with
    eval: % -> Any
      ++ eval(f) evaluates f with current values of symbols
    "+"      : (%, %) -> %
      ++ \spad{a + b}
    "-"      : (%, %) -> %
      ++ \spad{a - b}
    "-"      : % -> %
      ++ \spad{-a}
    "*"      : (%, %) -> %
      ++ \spad{a * b}
    "/"      : (%, %) -> %
      ++ \spad{a / b}
    "**"     : (%, NonNegativeInteger) -> %
      ++ \spad{a ** b}
    "**"     : (%, Integer) -> %
      ++ \spad{a ** b}
    coerce : Integer -> %
 == SExpression add
    Rep := SExpression

    eval x == interpret(x pretend InputForm)

    coerce(x:Integer):% == convert(x)
    coerce(x:%):OutputForm == expr x

    convert(x:%):SExpression == x pretend SExpression
    convert(x:DoubleFloat):% == convert(x)$Rep

    s1 + s2 ==
      convert [convert("+"::Symbol), s1, s2]$List(%)

    s1 - s2 ==
      convert [convert("-"::Symbol), s1, s2]$List(%)

    _-(s1) ==
      convert [convert("-"::Symbol), s1]$List(%)

    s1 * s2 ==
      convert [convert("*"::Symbol), s1, s2]$List(%)

    s1:% ^ n:Integer ==
      convert [convert("^"::Symbol), s1, convert n]$List(%)

    s1:% ^ n:NonNegativeInteger == s1 ^ (n::Integer)

    s1 / s2 ==
      convert [convert("/"::Symbol), s1, s2]$List(%)

   Compiling FriCAS source code from file 
      /var/lib/zope2.10/instance/axiom-wiki/var/LatexWiki/1574131120306297741-25px002.spad
      using old system compiler.
   INDET abbreviates domain Indeterminant 
------------------------------------------------------------------------
   initializing NRLIB INDET for Indeterminant 
   compiling into NRLIB INDET 
   compiling exported eval : $ -> Any
Time: 0.03 SEC.

   compiling exported coerce : Integer -> $
Time: 0 SEC.

   compiling exported coerce : $ -> OutputForm
Time: 0 SEC.

   compiling exported convert : $ -> SExpression
      INDET;convert;$Se;4 is replaced by x 
Time: 0 SEC.

   compiling exported convert : DoubleFloat -> $
Time: 0 SEC.

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

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

   compiling exported - : $ -> $
Time: 0 SEC.

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

************* USER ERROR **********
available signatures for ^: 
     ^: ((|Integer|),(|NonNegativeInteger|)) -> (|Integer|)
     ^: ((|Integer|),(|PositiveInteger|)) -> (|Integer|)
NEED ^: ($,(|Integer|)) -> ?
****** comp fails at level 3 with expression: ******
(DEF (^ |s1| |n|) (NIL $ (|Integer|)) (NIL NIL NIL)
 (|convert|
  ((|elt| (|List| $) |construct|) (|convert| (|::| "^" (|Symbol|))) |s1|
   (|convert| |n|))))
****** level 3  ******
$x:= (DEF (^ s1 n) (NIL NIL NIL) (NIL NIL NIL) (convert ((elt (List $) construct) (convert (:: ^ (Symbol))) s1 (convert n))))
$m:= $EmptyMode
$f:=
((((|s1| #) (|n| #) (* #) (+ #) ...)))

   >> Apparent user error:
   unspecified error

Symbolic Matrices

)clear all

   All user variables and function definitions have been cleared.

m:Union(Indeterminant,Matrix Integer)

   You cannot now use Indeterminant in the context you have it.
n:Union(Indeterminant,Matrix Integer)

   You cannot now use Indeterminant in the context you have it.
a:Union(Indeterminant,Integer)

   You cannot now use Indeterminant in the context you have it.
b:Union(Indeterminant,Integer)

   You cannot now use Indeterminant in the context you have it.
ab:=(3*a+b)*(a-2*b)

(11)

a:=1$Integer  -- because 0 and 1 can be symbolic!

(12)

eval ab

(13)

b:=0$Integer

(14)

a:=-10

(15)

eval ab

(16)

mn1:= m*n-n*m

(17)

mn2:=(m+n)*(m-n-1)

(18)

m:=matrix [[1,2],[3,4]]

(19)

n:=matrix [[-1,-2],[-3,4]]

(20)

eval mn1

(21)

eval mn2

(22)

)clear all

   All user variables and function definitions have been cleared.

d: Union(Variable d, Float)

d*2

(23)

will be problematic, and the assignment between symbolic integers is not allowed.

a: Union(Variable a, Integer)

b: Union(Variable b, Integer)

b:=a

   a is declared as being in Union(Variable(a),Integer) but has not 
      been given a value.

p:=2*d

(24)

eval(p,d=3.14)

(25)

But there is still a problem since I can write:

a:Union(Variable a,Integer)

a:=3.14

   Cannot convert right-hand side of assignment
   3.14

      to an object of the type Union(Variable(a),Integer) of the 
      left-hand side.
p:=2*a

(26)

eval(p,a=3.14)

(27)

and Axiom does not complain about the eval request because as far as Polynomial Integer is concerned d is just a Symbol.

In the case of the example Indeterminant domain, evaluation of symbolic expressions is always delayed so an appropriate eval operation could be defined that properly respects the type.

c:Union(Variable(c),Symbol)

c:=a

(28)

PS: In the light of polynomial, (2d) is a non-zero polynomial, so that it's always safe to write (1/(2d)), but it's actually non-safe to do it in the domain of float(or integer).

b:=a is meaningless, of course. But there are many scenarios

)clear all

   All user variables and function definitions have been cleared.

i:=10

(29)

a: Union(Variable a, Integer)

b: Union(Variable b, Integer)

b:= (i>0=>1; a)

(30)

which is meaningful.

We wish to place a restriction on the possible values that certain symbols can take. Such symbols and expressions formed from them certainly cannot live in a numeric domain such as Float. Except in certain circumstances (mentioned previously) I think a domain such as a:Union(Variable(a),Float) and the domains to which it can be coerced (such as Polynomial, Expression, ...) does already represent such a symbolic expressions fairly well.

But 1) What is Symbolic Float? Can you give a description?

And 2) How can I express the concept of "non-zero polynomial" in Axiom? I might use a domain that does not include zero for example a:Union(Variable(a),PositiveInteger) but there is no general domain of NonZero anything.

Ok, back to my own point. what's the justification of that the multiplication of two floats returns a polynomial float? Even the value is unknown, the type is certain, and float is closed under multiplication, so the return must be still a float, right?

AFAIK, Axiom currently support only polynomials with coefficients of known values. Then the only zero-polynomial(Integer) is 0$Polynomial Integer, others are non-zero polynomials.

But Axiom currently does not have any domain whose values are symbolic expressions which only evaluate to values in some specific domain. Polynomial is one of the existing domains in Axiom whose values are symbolic expressions (of a very specific type). Symbolic expression in the domain Expression are more general but still rather restricted in form. Finally there is InputForm? which consists of fully unevaluated expressions of the most general form allowed in Axiom.

Perhaps what you have called "Symbolic Float" could be implemented as an extension of the domain I called "Indeterminant" above.

Re: nonzero polynomials --Bill Page, Tue, 08 Jul 2008 22:35:03 -0700 reply

yixin.cao wrote:

the only zero-polynomial(Integer) is 0$Polynomial Integer, others are non-zero polynomials.

But a polynomial containing at least one monomial term is symbolic. Certain combinations of values substituted for the symbols may result in zero (such values are called is "solution").

yixin.cao wrote:

In the light of polynomial, (2d) is a non-zero polynomial, so that it's always safe to write (1/(2d))

If a value of 0 is subsituted for d in this "non-zero polynomial" then in what sense is 1/(2d) safe?

For the second question: Yes, polynomial (x-1) might be evaluated to 0 (all of Integer,Float,Complex?), but this doesn't change the matter of (x-1) is not a zero-polynomial. Well, do you think (x**2-1)/(x-1) = (x+1) is legal and guaranteed in the domain of polynomial? But it's not in the domain of Float/Integer. You don't want to modify the rule of polynomial to accommodate this, right?

The polynomial 0, which may be considered to have no terms at all, is called the zero polynomial. (from http://en.wikipedia.org/wiki/Polynomial)

Domain "Indeterminant" is a good example for this, thanks.

x:Polynomial Float

p:=(x^2-1)/(x-1)

(31)

eval(p,x=1)

(32)

is certainly legal and safe in the domain of polynomial where the result is required to be a polynomial although it seems that Axiom is being careful to give the result type as Fraction Polynomial Float and not automatically Polynomial Float.

Do you agree that it is not safe if all we know about x is that it is a symbol which can be replaced with a Float?

In this case a domain like Indeterminant can deal with it.

)library INDET

   Indeterminant is now explicitly exposed in frame initial 
   Indeterminant will be automatically loaded when needed from 
      /var/aw/var/LatexWiki/INDET.NRLIB/INDET
w:Union(Integer,Indeterminant)

q:=(w^2-1)/(w-1)

(33)

w:=1

(34)

eval(q)

   >> Error detected within library code:
   division by zero