05.05.2011 23:18, Tom Bachmann пишет:
I think that my statement is true, or at least should be true.
Everything that is not a symbol (or involves a symbol) is some concrete
mathematical entity, and all of its properties are settled (in
principle, in practice it might be hard to find out if a certain number
is e.g. positive, even if it is specified uniquely).
So basically I'm saying that things like "I'm an integer" or "I'm
commutative" are not really assumptions, they are type information if
you will. Integer(1) is not the same as Rational(1) is not the same as
eye (identity matrx).
I have tried to classify assumptions (I oriented and based on the
current usage of them, there is why I do not know what "are really
assumptions" or not, but it has a sense to make more accurate with this
question, of course):
"""
- related with symbols for simplification, e.g. Q.positive, Q.even.
- related with algebraic fields/rings, e.g. Q.real, Q.complex.
- related with some facts, e.g. .is_bounded, is_infinity, is_zero and so
on. They are help us to operate with calculation in core. Apparently
they are derived from the above other classes of assumptions (while
start-upping of the objects) (in this case e.g. is_zero is means that it
is a Zero for the ring). Or they can be derived from expression's
analyze: in this case we can create some class of assumption that are
calculated (in this case is_zero can be means but it this sort of
calculation is a difficult so called "zero test" problem). In any case
we can realize in mind with what we deal exactly (now in the core
somewhere we used is_zero in second sense)."""
May be updates will be for this, but I can offhand to think about
algorithms.
I see that the algorithm and syntax for the first class has no
difficulties apparantly. It is convinient to describe them locally
linked to symbols (or to the expression), and algorithm can be recurrent
to transform expression.
Yes, the second class is a type of information. The variants are how to
deal with this information. Obviously:
- We can also recurently analize this type of information for symbols.
- We can make automatic type conversion recurrently
(in binary mode):
Integer(1) + Integer(2) + Rational(7) ==>
Integer(3) + Rational(7) =>
Rational(10)
(at whole ADD arguments):
Integer(1) + Integer(2) + Rational(7) ==>
Rational(1) + Rational(2) + Rational(7) ==>
Rational(10)
- we can derive resulted field assumption/information of expression
from arguments:
(Integer(1) + Rational(1) is a Q.Rational)
(So we have field assumption/information attached to the
expression, taking into account yours remark that "not all of whose
properties are known")
So in particular ExtendedReal(1)/ExtendedReal(0) = oo,
ExtendedComplex(1)/ExtendedComplex(0) = zoo, Real(1)/Real(0) = nan, or
perhaps even an exception [unless we do some auto-conversion].
So we then have the following objects:
* algebras (or domains, or whatever) represent collections that are
typically manipulated together
* concrete elements of algebras. These are definite mathematical
objects, all of whose properties are known in principle.
* symbolic elements. These are elements which contain free symbols, and
not all of whose properties are known
For the last "not all of whose properties are known" I dont clear
imagine an example though.
Notice that every element that we ever compute with belongs to some
algebra. All assumptions are about "symbolic elements". They can be used
to do transformations of the expressions that would not be allowed for
all possible values of the free symbols, usually with the intent of
giving the user a better answer to a query [actually this seems a bit
vacuous ...].
Notice also that not everyhing that looks like a symbol is a symbolic
element (this is probably obvious to everyone but me): in e.g. a
polynomial algebra the generator X is a definite entity and *not* a free
symbol. Every statement that makes sense in this algebra is known about
X. A symbolic element would be a parametric family of polynomials,
something like X**2 + p*X + q. Here the p and q are symbols that
represent elements of the coefficient ring. It is sensible to make
assumptions about them, e.g. p > 0 or "X**2 + p*X + q is irreducible" or
whatever.
Interesting (and with series the same I suppose), I suppose that this
class of assumption related rather with first class/type of assumptions,
Or should it be separated to other class/type in the classification of
assumptions?
P.S.
I can read answers after May 10 only.
--
Alexey U.
--
You received this message because you are subscribed to the Google Groups
"sympy" group.
To post to this group, send email to sympy@googlegroups.com.
To unsubscribe from this group, send email to
sympy+unsubscr...@googlegroups.com.
For more options, visit this group at
http://groups.google.com/group/sympy?hl=en.
