sum8tion's profile - activity

I've found that if I define a list

Sage: list1 = [1,2,3]

and then try to remove an element

Sage: list2 = list1.remove(2)

but then

Sage: print(list2)

returns

None

I have a bit of a follow-up, lets say I want the latex name to have a bar over it for conjugation, like $\bar{v}$. My n

Thank you!

Say I have the following list of variables.

v = {(i,j): var("v_{}{}".format(i, j), latex_name="v_{{}{}}") for i in range(2) for j in range(2)}

How do I make it so that when I use the

show(v[0,0])

command, I get $v_{0,0}$ as output? I've tried stuff like

v = {(i,j): var("v_{}{}".format(i, j), latex_name="v_{i,j}") for i in range(2) for j in range(2)}

and

v = {(i,j): var("v_{}{}".format(i, j), latex_name="v_{{i}{j}}") for i in range(2) for j in range(2)}

but it only ever give me stuff like $v_{i,j}$ where it's just the literal symbols $i$ and $j$, not the entries of

v[k,m]

for some $k$ and $m$ I plug in, like 0, 0.

The ultimate problem I'm trying to solve, is that given two integers p and q, I would like to create a list (say "List1"), whose entries are (all of the) lists of length 2q which:

1) For all L in List1, the first q entries are between 0 and pq-1 (inclusive), and the next q entries are between pq and 2pq-1 (inclusive)

2) For all L in List1, the entries are strictly increasing, that is for all 1<=i<=2pq, L[i] < L[i+1]

I have a way of doing this which is very "brute force", where I first construct the list of lists of length 1, then the list of lists of length 2, etc.
I'm imagining (hoping) there exists some way for me to just iterate over all 2q -tuples (without repetition) of numbers from 1 to 2pq Something along the lines of

List1 = []
for x in 2q-tuples of [0, 1, 2, ..., 2pq-1]:
    if x satisfies 1) and 2):
        List1.append(x)

I suppose I would want to convert x to a list before appending to List1, or many there's some way to iterate over lists instead of tuples. That's not so important, I just want an efficient way to construct these lists.

How do you assign (different) LaTex names to elements of a list? Say I have the following list of variables. v = {(i,j)

How to create lists of n-tuples efficiently? The ultimate problem I'm trying to solve, is that given two integers p and

How to create lists of n-tuples efficiently? The ultimate problem I'm trying to solve, is that given two integers p and

I have the following setup

M = Manifold((4), 'M', field='complex')
U = M.open_subset('U')
x = U.chart(names=tuple('x_%d' % i for i in range(4)))
eU = x.frame()

Form0 = M.mixed_form(comp=([0,0,0,0,0]))
Form1 = M.mixed_form(comp=([1,0,0,0,0]))

Clearly Form0 and Form1 are distinct mixed forms of M, but when I run

if Form0 != Form1:
    print('Not Equal')
else:
    print('Equal')

I get 'Equal' as the output, what's going wrong?

I apologize if this is a little abstract, but is it possible to create some sort of "for" or "while" loop that will pass to the next iterate if the computation for that specific iterate takes too long?
For example, it could be something along the lines of, for some function/procedure

F(n)

we have

for n in range(100):
    print(F(n))

but if for some n in the range, the computation of F(n) takes more than say, 1 minute CPU time, I want it to either just skip to computing F(n+1) and/or print "-1" in place of F(n).
So let's say F(0), F(1), and F(2) all take less than half a second to compute they print just fine, so then n gets set to n=3, and F(3) starts running, but let's say it runs for over a minute, I want it to be that the loop outputs "-1" (or something) and then moves on to computing F(4).

UPDATE: I'd also like to be able, if possible, to print out run times. So that the output would be something like

(F(1), time(1))
(F(2), time(2))
(F(3), times(3))
...

etc., where time(n) is the amount of time it took to compute F(n).

@mwageringel It's a little convoluted, by the symbolic variables I have set up are supposed to represent complex numbers, and part of the indexing reflects conjugation. Under this identification the matrices h[i] can be seen as Hermitian matrices. If you'd really like I can explain the details, but I don't think they're relevant to the question at hand.

@Frederic are computations in polynomial rings that much faster? I was under the impression they worked the same as symbolic rings. I tried rewriting the code using a polynomial ring, but it seemed to make no difference in the run time when q=4, and certainly q=5 still isn't feasible.

I'm dealing with some Hermitian matrices valued in symbolic expressions. I need to be able to compute inverses of these matrices, but they seem to get big pretty fast. That is it would nice to be able to do this in a reasonable amount of time with 10x10 matrices at least, and hopefully larger than that.
I'm currently running a cell where the inverses of 2 10x10 matrices are being computed, and it's taken well over 10 minutes.

Are there ways to exploit the fact that these matrices are Hermitian to compute the inverses faster, and/or are there better ways to compute inverses of symbolic matrices than the standard .inverse()??

EDIT: I originally avoided an example, because their construction is somewhat convoluted as you'll see below.

First we have two variables which for which I want to run the larger program for various choices thereof.

p = 1, q= 5

X = {(i): var("X_{}".format(i), latex_name="X_{}") for i in range(2*p*q)}

e = {(i,j,k): var("e_{}{}{}".format(i,j,k), latex_name="e_{{{}{}{}}}".format(i,j,k)) for i in range(2) for j in range(q) for k in range((p+q))}

The following creates a list L such that L[i] is the collection of lists of length i whose elements are integers between 0 and q-1 in strictly increasing order. This is used throughout the larger program.

L = [[[]]]

LL = []
for i in range(q):
    LL.append([i])
L.append(LL)

if q>=2:
    for k in range(2,q+1):
        LLL = []
        for i in range(binomial(q, k-1)):
            for j in range(q):
                if L[k-1][i][len(L[k-1][i])-1]<j:
                    mm = []
                    for t in L[k-1][i]:
                        mm.append(t)
                    mm.append(j)
                    LLL.append(mm)
        L.append(LLL)

Here, a matrix is defined which we be used to construct the matrices I'm interested in.

HE = matrix(SR, q, q)

for i in range(q):
    for j in range(q):
        prod = 0
        for k in range(p):
            prod -= (e[(0, i, k)]*e[(1, j, k)])
        for l in range(p+q):
            if l>=p:
                prod += (e[(0, i, l)]*e[(0, j, l)])
        HE[i,j] = prod

h = {(i): var("h_{}".format(i)) for i in range(q+1)}

for i in range(q+1):
    h[i] = matrix(SR, binomial(q, i), binomial(q, i))

h[0][0,0] = 1

for i in range(1, q+1):
    for z in L[i]:
        for w in L[i]:
            h[i][L[i].index(z), L[i].index(w)] = HE[z, w].det()

Finally, we come to the inverse matrices I would like to compute. It is absolutely necessary that I have these inverse matrices.

hinv = {(i): var("hinv_{}".format(i)) for i in range(q+1)}

for i in range(q+1):
    hinv[i] = h[i].inverse()

First, for context, I am working with holomorphic Hermitian vector bundles, and I need to compute the connection and curvature matrices, and compute some representatives for Chern classes and the Chern form.

Ultimately I want to have a matrix which is valued in differential forms, and when I multiply matrices, I want the component-wise multiplication to be the wedge product of forms.

When I naively try to build a matrix of forms 'by hand', or when I pre-define my matrix space to be valued in the module of differential forms, I get an error telling me that the space of differential forms is a not a ring.

For example,

import sys
import mpmath
sys.modules['sympy.mpmath'] = mpmath
M = Manifold(2, 'M', field='complex')
U = M.open_subset('U')
c_xy.<x,y> = U.chart()
e_xy = c_xy.frame()
a = M.diff_form(2, name='a')
a.parent()
eU = c_xy.frame()
a.degree()
a[eU,0,1] = x*y^2 + 2*x
a.display(eU)
A = matrix([[a, a], [a, a]])

prints out

Module Omega^2(M) of 2-forms on the 2-dimensional complex manifold M
2
a = (x*y^2 + 2*x) dx/\dy

and raises a type error:

TypeError: base_ring (=Module Omega^2(M) of 2-forms on the 2-dimensional complex manifold M) must be a ring

Suppose for some p and q we have a manifold

Sage: p=1
Sage: q=2

Sage: M = Manifold((2*p*q), 'M', field='complex')
Sage: U = M.open_subset('U')
Sage: x = U.chart(names=tuple('x_%d' % i for i in range(2*p*q)))
Sage: eU = x.frame()

and some differential forms

Sage: d = {(i): var("d_{}".format(i)) for i in range(2*p*q)}

Sage: for i in range(2*p*q):
Sage:     d[i] = M.diff_form(i)

I want to construct and/or inspect components of these differential forms in a systematic way, which is to say I want to be able to iterate over the components. So for example, one way in which I've tried to do this is to create lists.
For example, if we let

Sage: R = [eU, 0, 1]

I would want to say

Sage: d[2]R = 1

but this gives me a syntax error.
I've also tried something like

Sage: S = [0, 1]
Sage: d[2][eU, :]S = 1

but again I get a syntax error.