On 02/20/2012 11:20 PM, Matthew Rocklin wrote:
@Aaron Thanks for the feedback, the KroneckerDelta anecdote is hilarious. I suspect that a lot of current work could be refactored with a good linear algebra module. There is even a current GSoC project discussing units that could make use of it. Lots of things that SymPy finds difficult are easily representable as vector spaces. Thanks also for updating the page, ground types is not something I know much about. I'll add to the projects page when I get some time.

@Alan I completely agree about abstract index notation. I have a small section of the wiki page on tensor indexing. There I pose that we might be able to use indexing as a way to define most operations. The tricky thing with this project is how to describe all tensor-ish operations with a single syntax that can be applied to a wide variety of applications. Can we create a single system which can be cleanly extended to include both Riemannian geometry and dense matrix computations? My current thought is that indexed expressions are a powerful-yet-general description that these representations all share. Any work done on indexed expressions (such as your idea of finding symmetries) would apply for all application projects.

I really appreciate the input so far. I think that if only one person thinks about this project then it will likely end up as just-another-linear-algebra-module. Extra perspectives greatly reduce this risk. I would be interested in what people could see coming out of a general linear algebra system. What projects would this facilitate?

On Mon, Feb 20, 2012 at 9:38 PM, Alan Bromborsky <abrombo@xxxxxxxxxxx <mailto:abrombo@xxxxxxxxxxx>> wrote:

On 02/20/2012 10:00 PM, Aaron Meurer wrote:

I updated the section on that page about ground types to be a
little
clearer about what we want there. Many things will actually
involve
improvements to Poly() to get things to work (for example, the
addition of a Frac() class).

Aaron Meurer

On Mon, Feb 20, 2012 at 7:40 PM, Aaron
Meurer<asmeurer@xxxxxxxxx <mailto:asmeurer@xxxxxxxxx>> wrote:

On Mon, Feb 20, 2012 at 2:19 PM, Matthew
Rocklin<mrocklin@xxxxxxxxx <mailto:mrocklin@xxxxxxxxx>>
wrote:

Hi Everyone,

I would like to create a general tensor/linear algebra
framework for SymPy.
I'd like to hear ideas from the community about this.

We already have a few linear algebraic projects within
SymPy
(i.e. Matrices, SparseMatrices, MatExprs,
Indexed/IndexedBase code
generation, Physics stuff, Geometric Algebra (sort
of)) but they don't
communicate well. It would be nice to create a general
and abstract
framework off of which these projects and others could
hang and interact
more naturally.

I'm writing the community about this for two reasons.
Reason one: I'd like feedback as to whether or not
this sort of undertaking
is a good idea. If it is I'd welcome some thoughts on
how it should be done
and how it could be useful for future work.

Definitely. One problem right now is that a lot of
modules duplicate
work, because we don't really have a good centrailzed
module for
things. For example, over GCI, a student merged together
three
independent KroneckerDelta implementations (one in
sympy/physics/quantum, one in sympy/physics/secondquant,
and one in
sympy/functions/special/tensor_functions.py). No doubt
there are
other things still duplicated.

That's also why even if we are implementing some of these
things to
help with physics, we should try to separate mathematical
concepts
from physical concepts in the implementation.

Reason two: I think I can separate this work into a
few pieces, each of
which would make for a good GSoC project for this year
or next. Is this
endeavor something into which the community would want
to invest resources?

I think so. Some projects may depend on others (e.g.,
we're limited in
what we can do with slow matrices). But feel free to do
this and add
the ideas to the GSoC ideas page. That page needs more
ideas that
have more descriptions on them (like the ones at the
bottom). Not
only will this help potential students, but it will help
us a lot when
we apply.

Aaron Meurer

Here are some projects that interest me

Framework design - we need a sufficiently general
framework (this is hard
and probably has to be half completed before GSoC time)
Abstract Vector Spaces
Tensor Math - Krastanov was talking about this and I
think it's a great
idea. There is a lot of good multilinear algebra out
there that SymPy
doesn't currently touch at all.
General storage - Efficient NDArray classes (dense,
mutable, sparse,
functional, numpy, external programs) - views of
NDArrays (transpose,
slices).
Theorem proving type system for
tensors/matrices

http://scicomp.stackexchange.com/questions/74/symbolic-software-packagbasic
es-for-matrix-expressions

I've dumped some thoughts on the following wiki page
https://github.com/sympy/sympy/wiki/Linear-Algebra-Vision

Comments or questions are welcome.

-Matt

--
You received this message because you are subscribed
to the Google Groups
"sympy" group.
To post to this group, send email to
sympy@xxxxxxxxxxxxxxxx <mailto:sympy@xxxxxxxxxxxxxxxx>.
To unsubscribe from this group, send email to
sympy+unsubscribe@xxxxxxxxxxxxxxxx
<mailto:sympy%2Bunsubscribe@xxxxxxxxxxxxxxxx>.
For more options, visit this group at
http://groups.google.com/group/sympy?hl=en.

I am rewriting the geometric algebra module using noncommuting
symbols to represent base vectors and base multivectors and let
general multivectors be linear combinations of the base
multivectors and let sympy do the heavy
lifting with regard to simplification and other operations. The
current GA module was written before I understood what sympy could
do and is a real mess from the point of view of being an
extensible module.

Someone should employ all the inherent abilities of sympy to write
a module for Tensors using Penrose's abstract index
http://en.wikipedia.org/wiki/Abstract_index_notation notation
especially allowing for simplifications using tensor symmetries
and also allow for symbolic differentiation.



-- You received this message because you are subscribed to the Google
Groups "sympy" group.
To post to this group, send email to sympy@xxxxxxxxxxxxxxxx
<mailto:sympy@xxxxxxxxxxxxxxxx>.
To unsubscribe from this group, send email to
sympy+unsubscribe@xxxxxxxxxxxxxxxx
<mailto:sympy%2Bunsubscribe@xxxxxxxxxxxxxxxx>.
For more options, visit this group at
http://groups.google.com/group/sympy?hl=en.


--
You received this message because you are subscribed to the Google Groups "sympy" group.
To post to this group, send email to sympy@xxxxxxxxxxxxxxxxx
To unsubscribe from this group, send email to sympy+unsubscribe@xxxxxxxxxxxxxxxxx
For more options, visit this group at http://groups.google.com/group/sympy?hl=en.
I have one suggestion for concrete tensors as opposed to abstract tensors. Represent concrete tensors with numpy arrays stuffed with sympy scalars and let numpy do the heavy lifting of concrete tensor operations.

--
You received this message because you are subscribed to the Google Groups
"sympy" group.
To post to this group, send email to sympy@xxxxxxxxxxxxxxxxx
To unsubscribe from this group, send email to
sympy+unsubscribe@xxxxxxxxxxxxxxxxx
For more options, visit this group at
http://groups.google.com/group/sympy?hl=en.