Singular

Thank you very very much, now is more clear!
best
Michele

[quote="Michele T"]
just to be sure just look at the second example:
This is what I did:
[code]
> LIB "matrix.lib";
> ring R = 0,(x,y,z), dp;
> matrix B[3][3] = 2y, x, 0, -z,0,y, 0, -z,2z;
> matrix v[3][14]= x,0,0,-2y,2x,0,0,0,z,2y,0,-z,0,2z, 0,2x,0,0,-2y,-x,y,0,0,z,y,0,0,0, 0,0,3x,0,0,-2y,0,2y,0,0,z,0,z,0;
> print(v);
x,0, 0, -2y,2x, 0, 0,0, z,2y,0,-z,0,2z,
0,2x,0, 0, -2y,-x, y,0, 0,z, y,0, 0,0,
0,0, 3x,0, 0, -2y,0,2y,0,0, z,0, z,0
> print( gauss_col (transpose(jacob(B)) + transpose(jacob(-v))) );
1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,1,0,0,0,0,0,0
[/code]
so does this means that the only solution is the zero one?
[/quote]

Should not 'v' look as follows?
[code]
x,0, 0, -2y,2x, 0, 0,0, z,2y,0, -z,0,2z,0,
0,2x,0, 0, -2y,-x, y,0, 0,z, -y,0, 0,0, -z,
0,0, 3x,0, 0, -2y,0,2y,0,0, z, 0, z,0, 0
[/code]

Besides, i'm sorry:
1. it's better to construct the system as i show below,
and
2. for the intersection you clearly need the row-reduced block-triangular form (use '''gauss_row''' instead!):

[code]
> def N = transpose(jacob(B)); N = N, transpose(jacob(-v)); print(N);
0, 1, 0,-1,0, 0, 0,-2,0,0, 0, 0, 0, 0, 0,0, 0, 0,
0, 0, 0,0, -2,0, 0,0, 1,0, 0, 0, 0, 0, 0,0, 0, 0,
0, 0, 0,0, 0, -3,0,0, 0,0, 0, 0, 0, 0, 0,0, 0, 0,
2, 0, 0,0, 0, 0, 2,0, 0,0, 0, 0, -2,0, 0,0, 0, 0,
0, 0, 1,0, 0, 0, 0,2, 0,-1,0, 0, 0, 1, 0,0, 0, 0,
0, 0, 0,0, 0, 0, 0,0, 2,0, -2,0, 0, 0, 0,0, 0, 0,
0, 0, 0,0, 0, 0, 0,0, 0,0, 0, -1,0, 0, 1,0, -2,0,
-1,0, 0,0, 0, 0, 0,0, 0,0, 0, 0, -1,0, 0,0, 0, 1,
0, -1,2,0, 0, 0, 0,0, 0,0, 0, 0, 0, -1,0,-1,0, 0

> print( gauss_row (N) );
0, 0, 0, 0, 0, 1,0, 0,0,0, 0,0, 0,0,0, 0,0,0,
0, -1/2,0, 1/2,0, 0,0, 1,0,0, 0,0, 0,0,0, 0,0,0,
0, 0, 0, 0, -2,0,0, 0,1,0, 0,0, 0,0,0, 0,0,0,
0, 0, 0, 0, -2,0,0, 0,0,0, 1,0, 0,0,0, 0,0,0,
-1,0, 0, 0, 0, 0,-1,0,0,0, 0,0, 1,0,0, 0,0,0,
0, 1, 1, -1, 0, 0,0, 0,0,-1,0,0, 0,1,0, 0,0,0,
0, 0, -3,1, 0, 0,0, 0,0,1, 0,0, 0,0,0, 1,0,0,
0, 0, 0, 0, 0, 0,0, 0,0,0, 0,1/2,0,0,-1/2,0,1,0,
-2,0, 0, 0, 0, 0,-1,0,0,0, 0,0, 0,0,0, 0,0,1

[/code]


this is a homogeneous linear system for your parameters:
(rows correspond to the {var*gen} basis), the 1st three cols correspond to the (free) span of B, let's call them: (p,q,r),
while the rest 15 - to the parameters from ''v'': (a_1, a_2, a_3, a_4, a_5, a_6, b_2, b_3, b_4, b_5, b_6, c_1, c_3, c_5, c_6 )

Due to that system you have p,q,r,a_1,a_2,a_4,a_6,b_2,b_4,c_1 as free parameters,
the 1st row says: a_3 = 0,
while all other parameters are linearly expressed via the free parameters:
2nd row => -(-1/2 q + 1/2 a_1) = a_5
3rd row => -(-2 a_2) = a_6
and so on...

i hope this helps,
O.

The fact is that I'm not sure on how to interpret the last outcome...
thank you!

I think I do, thank you very much.
just to be sure just look at the second example:
This is what I did:
[code]
> LIB "matrix.lib";
> ring R = 0,(x,y,z), dp;
> matrix B[3][3] = 2y, x, 0, -z,0,y, 0, -z,2z;
> matrix v[3][14]= x,0,0,-2y,2x,0,0,0,z,2y,0,-z,0,2z, 0,2x,0,0,-2y,-x,y,0,0,z,y,0,0,0, 0,0,3x,0,0,-2y,0,2y,0,0,z,0,z,0;
> print(v);
x,0, 0, -2y,2x, 0, 0,0, z,2y,0,-z,0,2z,
0,2x,0, 0, -2y,-x, y,0, 0,z, y,0, 0,0,
0,0, 3x,0, 0, -2y,0,2y,0,0, z,0, z,0
> print( gauss_col (transpose(jacob(B)) + transpose(jacob(-v))) );
1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,1,0,0,0,0,0,0
[/code]
so does this means that the only solution is the zero one?Thank you again!!

After switching from vectors over k[x..z] to vectors in k^{n * nrows(A)}, -
it is already linear algebra and you use Gauss to intersect two K-vector spaces.

one can do that directly over k[x..z] but i think it's better to understand what is actually going on.

just start with your 1st example:

you wanted to intersect <(x,0)^t, (0,y)^t>_k with <(y,0)^t, (0,x)^t>_k:

[code]
> ring R = 0,(x,y), dp; matrix A[2][2] = x, 0, 0, y; print(A);
x,0,
0,y
> matrix v[2][2] = y, 0, 0, x; print(v);
y,0,
0,x
[/code]
Now switch to the basis {x*gen(1) y*gen(1) x*gen(2) y*gen(2)}:
[code]
> print(transpose(jacob(A)));
1,0,
0,0,
0,0,
0,1
> print(transpose(jacob(v)));
0,0,
0,1,
1,0,
0,0
[/code]
so you just intersect <(1,0,0,0)^t, (0,0,0,1)^t>_k with <(0,0,1,0)^t, (0,1,0,0)^t>_k:

[code]
> LIB "matrix.lib"; print( gauss_col (transpose(jacob(A)) + transpose(jacob(-v))) );
1,0,0,0,
0,1,0,0,
0,0,1,0,
0,0,0,1
[/code]

now you simply read off relations on parameters:
in this example they all are zero, i.e. only the zero point
(btw, zero is ALWAYS a solution for your problem)

do you understand?

O.

yes, I know what is the Gauss algorithm.
why do i need to change to such bases?
sorry but i'm not very good at computations...
thank you.
best
Michele

after computing a K-basis of the space spanned by columns from A (already explained above) you intersect it with the space given by your conditions (seems to be encoded by the vector ''v'').

I think that your task reduces to a simple linear algebra problem if you switch to the following K-basis:
{ var(i) * gen(j) | 1<=i<=nvars(basering), 1<= j <= nrows(A) } (e.g. using ''jacob'')

ps: do you know about the Gauss algorithm?

O.

what do you mean? I'm trying to understand if there is a way to compute values for the parameters in v such that it belongs to the vector spaces spanned by the columns of A.

fine. so what about 'v'?

O.

yes, I agree also because I already know that the column were linearly independent over C[x,y,z].
thank you again.
best
Michele

Hi,

let's consider the 1st problem (no restrictions):
[quote]
v=(B_11*X_1+...+B_1n*X_n, ..., B_n1*X_1+...+B_nn*X_n)^t
[/quote]

[code]
option(redTail); option(redSB); LIB "matrix.lib"; // some init
ring R = 0,(x,y,z), dp; // common ring for both examples
matrix A[2][2] = x,0, 0,y; // 1st example
matrix B[3][3] = 2y, x, 0, -z,0,y, 0, -z,2z; // 2nd example

// Let's COMPUTE column bases:
print( gauss_col(B) );
// x,0,
// 0,y
print( gauss_col(A) );
// -2*y,2*x,-x,
// z, y, 0,
// 0, 0, z
[/code]

Which means that the spaces spanned by the columns of the matrices A or B look as follows:

1st example: a (x, 0)^t + b (0,y)^t, for any a,b
2nd example: a (-2y,z,0)^t + b (2x,y,0)^t + c (-x,0,z), for any a,b,c

those a,b,c are your free parameters...

Do you agree with these results?

O.

ps: you can use gauss_col since input is homogeneous of the same degree!

Hi,
you are right, my first post was badly written....
so v=(B_11*X_1+...+B_1n*X_n, ..., B_n1*X_1+...+B_nn*X_n)^t but then I have some restriction on the B_ij, like some of them are zero.....
thank you
Michele

Hi,

I am not sure about your vector 'v':

In the 1st example the vector 'v' is NOT of the form [code] (B_11*X_1+...+B_1n*X_n, ..., B_n1*X_1+...+B_nn*X_n)^t[/code]
It is also the case in your second example.

From your initial question it seems that your are looking for the k-basis of the space spanned by the columns of the matrix 'A'
(which seems to be an easy linear algebra problem), while in your examples you look for a subspace in it...

Please clarify the use of 'v'.

Regards,
O.

other example:
Let A= | 2y x 0 |
| -z 0 y |
| 0 -z 2z |

and V= | xa_1+2xa_5-2ya_4+2yb_5+zb_4-zc_1+2zc_5 |
| 2xa_2-xa_6-2ya_5+yb_2-yb_6+zb_5-zc_6 |
| 3xa_3-2ya_6+2yb_3+zb_6+zc_3 |

where I have parameters a_1..a_6,b_1..b_6,c_1..c_6.
the fact is that I'm able after long time to compute it by hands but if the matrix become bigger is too long....
thank you
Michele

Thanks.

What about some non-trivial examples?

Regards,
Oleksandr