## nt.number theory – Uniqueness of decomposition for positive-definite integral bilinear forms?

Let $$Lambda$$ be a lattice, that is a free finitely generated abelian group with a symmetric bilinear form.

In general, decomposition of lattices into indecomposable orthogonal sublattices is not unique. For example, if $$U$$ is a hyperbolic plane ($$e_1^2 = e_2^2 = 0$$, $$e_1 cdot e_2 = 1$$), then $$U oplus langle -1 rangle simeq langle 1, -1, -1 rangle$$, however $$U notsimeq langle 1, -1 rangle$$.

Is the orthogonal decomposition into indecomposables unique if we assume $$Lambda$$ to be positive-definite?

Thanks!

## perverse sheaves – Decomposition of direct image of a smooth morphism, Deligne’s theorem, motives

Let $$f : X to Y$$ be projective and smooth morphism of complex algebraic varieties. Here we care about the algebraic topology of $$X$$ and $$Y$$, so use classical topology for simplicity.

I can take the constant sheaf $$mathbb{Q}_X$$ and (derived) push it forward to get $$f_* mathbb{Q}_X in D^b_c(Y,mathbb{Q})$$. There is a celebrated theorem of Deligne that $$f_* mathbb{Q}_X$$ is semi-simple, i.e. isomorphic to a direct sum of its cohomology sheaves. The argument uses hard Lefschetz along the fibres. (It is also true that each summand is a semi-simple local system, as a polarizable VHS, however I want to ignore that extra piece of information below.)

Suppose I replace $$mathbb{Q}$$ with $$k := mathbb{F}_p$$.

Question: Is it true that $$f_* k_X in D^b_c(Y,k)$$ is always semi-simple? That is, does it always split as a direct sum of its (not-necessarily semi-simple) cohomology sheaves.

I had always assumed the answer was no, but woke up this morning feeling unusually optimistic. (I have tried several times to produce a counter-example.) I understand that this is deep water, and I am happy with a heuristic answer either way (potentially using motives).

## Rank decomposition of matrices over \$mathbb F_2\$

Given an integer matrix $$Minmathbb Z^{ntimes n}$$ of real rank $$k$$ what is the minimum and maximum number of rank $$1$$ matrices $$B_1$$ to $$B_t$$ we require so that $$Mequivsum_{i=1}^tB_ibmod 2$$?

1. If $$mathbb F_2$$ rank of $$M$$ is $$k’$$ then we need $$t=k’$$. I am asking the best gap between $$k$$ and $$k’$$.

2. If $$k’=n$$ when is $$k?
I guess the converse $$k' and $$k=n$$ does not happen.

## blocks – Magento 2.4.3 – Notice: Undefined property: \$_view – Decomposition of Controllers

I have been trying to create module in Magento 2.4.3 that has significant changes where decomposition is favored instead of inheritance – https://community.magento.com/t5/Magento-DevBlog/Decomposition-of-Magento-Controllers/ba-p/430883

The below code is successfully working in 2.2 however is throwing error even after changing classes and running in version 2.4.3. Unable to load the users.phtml file that will be called using the controller and block while throwing error – `Undefined property: \$_view`

Controller – VendorMyModuleControllerIndex.php

``````<?php

namespace EinfochipsSalesStaffController;

use MagentoFrameworkAppActionHttpGetActionInterface;
use MagentoFrameworkViewResultPageFactory;

class Index implements HttpGetActionInterface
{
/** @var PageFactory */
protected \$resultPageFactory;
public function __construct(PageFactory \$resultPageFactory)
{
\$this->resultPageFactory = \$resultPageFactory;
}

public function execute()
{
return \$this->resultPageFactory->create();
}
}
``````

Controller – VendorMyModuleControllerIndexIndex.php

``````<?php
namespace VendorMyModuleControllerIndex;

use MagentoFrameworkAppActionHttpGetActionInterface;
use MagentoFrameworkViewResultPageFactory;

class Index extends VendorMyModuleControllerIndex
{

protected \$resultPageFactory;
public function __construct(PageFactory \$resultPageFactory)
{
\$this->resultPageFactory = \$resultPageFactory;
}

public function execute()
{

\$resultPage = \$this->resultPageFactory->create();
\$resultPage->getConfig()->getTitle()->set(__('Users'));
\$this->_view->getLayout()->getBlock('page.main.title')->setPageTitle('Users');
return \$resultPage;
}
}
``````

Block – VendorMyModuleBlockUsers.php

``````<?php
namespace VendorMyModuleBlock;

use MagentoFrameworkViewElementTemplateContext;
use MagentoFrameworkAppRequestInterface;
use MagentoStoreModelStoreManagerInterface;

class Users extends MagentoFrameworkViewElementTemplate {

public function __construct(
Context \$context,
RequestInterface \$request,
StoreManagerInterface \$storeManager,
array \$data = ()
) {
\$this->request = \$request;
\$this->storeManager = \$storeManager;
parent::__construct(\$context, \$data);
}
}
``````

XML – VendorMyModuleviewfrontendlayoutusers_index_index.xml

``````<?xml version="1.0"?>
<page xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" layout="2columns-left" xsi:noNamespaceSchemaLocation="urn:magento:framework:View/Layout/etc/page_configuration.xsd">
<update handle="customer_account"/>
<body>
<referenceContainer name="content">
</referenceContainer>
</body>
</page>
``````

users.phtml – VendorMyModuleviewfrontendtemplatesusers.phtml

``````<?php echo 'Test PHTML'; ?>
``````

## ring theory – Idempotent decomposition (in proof of Serre’s criterion for normality)

I am trying to understand the proof of Serre’s criterion for normality(the “Sufficiency” part). Let $$A$$ be commutative Noetherian ring. The proof:

Suppose $$A$$ satisfies $$S_2$$ and $$R_1$$. ($$S_i$$ and $$R_i$$ are explaned in the link) Then $$A$$ in particular satisfies $$S_1$$ and $$R_0$$; hence, it is reduced. If $$mathfrak {p}_{i},,1leq ileq r$$ are the minimal prime ideals of $$A$$, then the total ring of fractions $$K$$ of $$A$$ is the direct product of the residue fields $$kappa ({mathfrak {p}}_{i})=Q(A/{mathfrak {p}}_{i})$$: see total ring of fractions of a reduced ring. That means we can write $$1=e_{1}+dots +e_{r}$$ where $$e_{i}$$ are idempotents in $$kappa ({mathfrak {p}}_{i})$$ and such that $$e_{i}e_{j}=0,,ineq j$$

Question: Last claim I not understand. Why we can find idempotent $$e_i in kappa ({mathfrak {p}}_{i})$$ satisfying $$1=e_{1}+dots +e_{r}$$. Due to direct product decomposition of $$K$$ we can find $$f_i kappa ({mathfrak {p}}_{i})$$ with $$1=f_{1}+dots +f_{r}$$. But why these $$f_i$$ can be moreover choosen to be idempotent?

## string manipulation – \$P=QRS\$ decomposition of given list-3-unordered list

This is an extended version of my previous posts, \$P=QRS\$ decomposition of given list, P=QRS decomposition of given list -2 -unordered list

Inspired by @Bill, and considering multiplicities, mathematically, I know how to handle this but hard to implement such ideas.

First, I realized the

Extend @Bill’s comment for length $$5$$ input

``````A5 = {a1, a2, a3, a4, a5};
p = Permutations(A5);
i = Permutations(IntegerPartitions(Length(A5), {3})((1)))
t1 = Flatten(Outer(TakeList, p, i, 1), 1);
Q1 = Map(#((1)) &, t1)
R1 = Map(#((2)) &, t1)
S1 = Map(#((3)) &, t1)
newQ1 = Table(Sort(Q1((i))), {i, 1, Length(Q1)})
newR1 = Table(Sort(R1((i))), {i, 1, Length(R1)})
newQ1 = Table(Sort(S1((i))), {i, 1, Length(S1)})

j = Permutations(IntegerPartitions(Length(A5), {3})((2)))
t2 = Flatten(Outer(TakeList, p, j, 1), 1);
Q2 = Map(#((1)) &, t2)
R2 = Map(#((2)) &, t2)
S2 = Map(#((3)) &, t2)
newQ2 = Table(Sort(Q2((i))), {i, 1, Length(Q2)})
newR2 = Table(Sort(R2((i))), {i, 1, Length(R2)})
newS2 = Table(Sort(S2((i))), {i, 1, Length(S2)})
``````

Then I divide the multiplicities by hand to match with the whole number of partitions that I want.

For example, here the number of decomposition into $$3,1,1$$ are $$10times 2times 3=60$$ and the number of decomposition into $$2,2,1$$ is $$10 times 3 times 3=90$$ and the total number is $$90$$. But the above or the previous method just gives 720 without considering the multiplicities. i.e.,

Length(Q1) + Length(Q2) =720, but on the other hand Length(Q1)/3! + Length(Q2)/(2! 2!) = 150.

So considering these partitions of letters are input and treat them with dividing multiplicities I can manage the decomposition, but I wonder whether there are more nice ways to decompose this $$P=QRS$$.

For length $$6$$ and further length, in principle, I can do this similarly, but want to know where there is a simpler way.

## string manipulation – P=QRS decomposition of given list -2 -unordered list

This is an extended version of my previous post, \$P=QRS\$ decomposition of given list

Based on the answer and comment of @Bill,

Form all permutations of P. Form Q as the first element of each of those, R as the second element and S all the rest of each perm. Then do this with R of length 2. And then of length 3. And … until you are down to S of length 1. Now start over with Q of length 2, etc, etc, etc.

for length $$3$$, I have done this via

``````A3 = Permutations({a1, a2, a3})
For(i = 1, i <= Length(A3), i++,
P(i) = Partition(A3((i)), 1));

For(i = 1, i <= Length(A3), i++,
Q(i) = P(i)((1));
R(i) = P(i)((2));
S(i) = P(i)((3)); );
Table(Flatten({Q(i), R(i), S(i)}), {i, 1, Length(A3)})
``````

It looks okay, but I am having trouble with length 4. With the same instruction I did

``````A4 = Permutations({a1, a2, a3, a4})
Length(A4)
For(i = 1, i <= Length(A4), i++,
P(i) = Partition(A4((i)), 1)
);

(*2+1+1*)
For(i = 1, i <= Length(A4), i++,
Q1(i) = Flatten({P(i)((1)), P(i)((2))});
R1(i) = P(i)((3));
S1(i) = P(i)((4));
)
(*1+2+1*)
For(i = 1, i <= Length(A4), i++,
Q2(i) = P(i)((1));
R2(i) = Flatten({P(i)((2)), P(i)((3))});
S2(i) = P(i)((4));
)
(*1+1+2*)
For(i = 1, i <= Length(A4), i++,
Q3(i) = P(i)((1));
R3(i) = P(i)((2));
S3(i) = Flatten({P(i)((3)), P(i)((4))});
)
``````

But here the size does not agree with what I expected; For length $$4$$ case there is three choices to divide, $$(1,1,2), (1,2,1),(2,1,1)$$ and by symmetry, for each of them there are $$12$$ of them so the total is $$36$$. But here individuals have $$24$$ and thus $$24times 3=72$$.

For example, $${1,2,3,4}$$ with $$(1,1,2)$$ decomposition, we have $$(1,2,34),(1,3,24),(1,4,23), (2,1,34),(2,3,14),(2,4,13),(3,1,24),(3,2,14),(3,4,12),(4,1,23),(4,2,13),(4,3,12)$$ 12 cases (One can think of this first by chossing $$2$$ elements among $$4$$ and multiplying the degeneracy $$2$$)

For $$P=QR$$ decomposition of an unordered set, the subset is enough for whole possible cases, but in this case, after dividing into $$P=QR$$ and $$R=R’S$$, the total size should be increased, and there are some problems for injecting more possible lists into the first partitions.

Before this setup, I just plugging all the possible cases of length $$4$$ individually, but I realized this is very inefficient and even produces typos(human error) for length $$5$$ and more than length $$5$$ cases.

Besides permutations, I tried to formulate similar things with partitions command but I realized the assign function of partition only produces partitions up to its length, not partition into three pieces or more than three. i.e., as a manual says

`````` Partition({a, b, c, d, e, f}, 3, 1)
``````

produces sequences of length 3 with offset 1…

Any ideas or explicit examples are welcome!

## string manipulation – \$P=QRS\$ decomposition decomposition of given list

This is an extension of my previous post \$P=QR\$ decomposition of given list

Now for this time, I want to decompose arbitrary list $$P$$ into three pieces for ordered or non-ordered cases.

Based on the response of @Bill, I consider $$P=QR’$$ and make $$R’=RS$$ decomposition, but I realized my input $$R$$ is no longer a list but a array of lists.

For example, based on the code from @Bill,

``````P={a1,a2,a3,a4};
(*ordered*)
Q=Table(Take(P,i),{i,Length(P)-1})
R=Table(Drop(P,i),{i,Length(P)-1})
(*unordered*)
Q=Subsets(P,{1,Length(P)-1})
R=Map(Complement(P,#)&,Q)
``````

To decompose $$R$$ into $$R_1, R_2$$, For each case of an array $$Q$$, I mean $$Q((i))$$, assign $$R((i))$$ as $$P$$ and then do the similar thing.

I want my code to do for the arbitrary given list, but this case, it seems not good.

Actually, I need $$P=QRST$$ decomposition but with $$P=QRS$$ I think I can handle $$P=QRST$$ decomposition easily.

## linear algebra – What is wrong with my simple method of calculating polar decomposition?

I am learning polar decomposition.

In the examples I have seen (for example http://buzzard.ups.edu/courses/2014spring/420projects/math420-UPS-spring-2014-buffington-polar-decomposition.pdf concrete calculations starting page 4), a first step is to calculate $$A^*A$$. Then this is eigendecomposed into $$U^{-1} D U$$ with $$D$$ diagonal and $$U$$ unitary (my choice of inverse $$U$$ term is for later). Because $$D$$ is diagonal it’s easy to calculate the square root, then it can be substituted: $$A^*A=U^{-1}sqrt{D}sqrt{D}U$$. If we were given $$A$$ as an matrix in a basis then all the terms so far have explicit numerical values from the eigendecomposition algorithm. Now at this point the reference procedures go on and do a few more steps.

However, I see that with $$U$$ unitary $$U^*=U^{-1}$$ and with $$D$$ diagonal $$sqrt{D}$$ is also diagonal and $$sqrt{D}^*=sqrt{D}$$. So $$A^*A=U^*sqrt{D}^*sqrt{D}U=(sqrt{D}U)^*(sqrt{D}U)$$. So simply $$A = sqrt{D}U$$ and the decomposition is solved. Things make me doubtful of this analysis:

• $$sqrt{D} U$$ is the polar decomposition directly. If it was possible to just read off the results at this stage, why would the published algorithms do more steps?
• I thought maybe my reasoning is a special case that does not work in all cases. However, in the examples I have seen, which seem quite “clean” (all real numbers, not apparently singular, etc.) it seems like the final results of the following calculations are different from these matrices. So, it’s not just my analysis is a special case, it is wrong.
• $$sqrt{D}$$ is positive definite diagonal. Maybe polar decomposition can break down into Unitary and Hermitian (actually I think sometimes not), but I don’t think it can break down into Unitary and Diagonal, that is too strong.

I think maybe $$D$$ if it is diagonal has complex eigenvalues and hence it is not Hermitian, which causes the problem. But everwhere I have read about this procedure it seems to be positive semidefinite.

Can you please let me know where my reasoning is wrong?

## Levy process decomposition and t at infinity

I have a small question it is know that one can decompose levy into 4 elements, 2 of them are continuous, and the are W_t – wiener process, and the second is a drift term: t.
But there is one thing I cant grasp, when t goes to infinity the process also goes to infinity, and it’s just made me think…
I know that maybe I’m oversimplifying, that why I’m here.
Am I looking at it all wrong?

Thanks!