Hello,
For my current research, I need to do some "Lazy" Linear algebra.
For example, I have a family of 20 vectors living in a vector space of
dimension 10^10. I know mathematically that this family contains 5
vectors independents and I want to get them!
So I consider vectors like lazy vectors (or functions) defined on a
(finite(but big)/infinite) enumerated set. I just want to extract a
rectangular matrix formed by some evaluations of rank `n` and stated the
`n` corresponding lines (or vectors) are thus independents.
This is a very hard problem of design... And I have a single use case
with my invariants of finite groups. In spite of my light experience, I
think that Sage (and Sage-combinat in particular) already contains big
parts of such technology. Very draftly, I need something between
LazyFamily and CombinatorialFreeModule.
I push a very first prototype on Sage-combinat :
lazy_combi_free_module-nb.patch
Here is a log of what I did to fix ideas:
##############################################################
Here is a big case (still finite)
I give already (but not echelonized) independents vector to the
method : echelon_form_extract
##############################################################
sage: C = LazyCombinatorialFreeModule(QQ,
IntegerRange(1,100000000000000000001))
sage: V1 = C.monomial(1)
sage: V2 = C.monomial(2)+V1
sage: V3 = C.monomial(3)+V2
sage: V4 = C.monomial(4)
sage: V5 = C.monomial(5)+V3
sage: for i in C.echelon_form_extract([V1,V2,V3,V4,V5]): i
....:
(V_{1}(x))_{x in {1, .., 100000000000000000000}}
(((V_{2}+V_{1})-(1V_{1}))(x))_{x in {1, .., 100000000000000000000}}
((((V_{3}+(V_{2}+V_{1}))-(1V_{1}))-(1((V_{2}+V_{1})-(1V_{1}))))(x))_{x
in {1, .., 100000000000000000000}}
(V_{4}(x))_{x in {1, .., 100000000000000000000}}
(((((V_{5}+(V_{3}+(V_{2}+V_{1})))-(1V_{1}))-(1((V_{2}+V_{1})-(1V_{1}))))-(1(((V_{3}+(V_{2}+V_{1}))-(1V_{1}))-(1((V_{2}+V_{1})-(1V_{1}))))))(x))_{x
in {1, .., 100000000000000000000}}
##############################################################
Here is an infinite case
I give 7 vectors to the method : echelon_form_extract
But as I know that they span a space of dimension 5, I give
an extra argument named `up_to_rank` which will have value
5 in this example
##############################################################
sage: C = LazyCombinatorialFreeModule(QQ, NN)
sage: X = C(lambda x:x, 'X')
sage: X2 = C(lambda x:x**2, 'X2')
sage: X3 = C(lambda x:x**3, 'X3')
sage: Xc = C(lambda x:x, 'Xc')
sage: X4 = C(lambda x:x**4, 'X4')
sage: X2c = C(lambda x:x**2, 'X2c')
sage: X5 = C(lambda x:x**5, 'X5')
sage: for i in C.echelon_form_extract([X,X2,X3,Xc,X4,X2c,X5], 5): i
....:
(X(x))_{x in Non negative integer semiring}
((X2-(1X))(x))_{x in Non negative integer semiring}
(((X3-(1X))-(3(X2-(1X))))(x))_{x in Non negative integer semiring}
((((X4-(1X))-(7(X2-(1X))))-(6((X3-(1X))-(3(X2-(1X))))))(x))_{x in Non
negative integer semiring}
(((((X5-(1X))-(15(X2-(1X))))-(25((X3-(1X))-(3(X2-(1X))))))-(10(((X4-(1X))-(7(X2-(1X))))-(6((X3-(1X))-(3(X2-(1X))))))))(x))_{x
in Non negative integer semiring}
(((X2c-(1X))-(1(X2-(1X))))(x))_{x in Non negative integer semiring}
((Xc-(1X))(x))_{x in Non negative integer semiring}
On this last example, the 5 first vectors returned are echelonized.
I you already feed the need of such feature or if you want to use it or
if you can give me some advises.... Go on!
I just did it to check it was feasible with the category framework and
the last (and finalized) feature of LazyFamily.
Thanks for your further comments,
Nicolas (the little).
--
You received this message because you are subscribed to the Google Groups
"sage-combinat-devel" group.
To post to this group, send email to sage-combinat-devel@googlegroups.com.
To unsubscribe from this group, send email to
sage-combinat-devel+unsubscr...@googlegroups.com.
For more options, visit this group at
http://groups.google.com/group/sage-combinat-devel?hl=en.
