ag.algebraic geometry – Killing cohomology of structure sheaf by pullback along Frobenius and finite etale covers

On a smooth projective variety $X$ over a finite field, you can pullback any element in $H^1(X,mathcal{O}_X)$ by a combination of Frobenius and finite etale cover so it gets killed. In order to prove it I consider an element $alpha$ in the cohomology group. This corresponds to an extension of $mathcal{O}_X$ by itself. Since this cohomology group is finite and Frobenius acts on it, there is some $n$ and $m$ ($m>n$) such that $F^{*n}alpha=F^{*m}alpha$. By Prop 2.3 this means that you can pullback the extension $F^{*n}alpha$ so it becomes a trivial vector bundle. Now the short exact sequence corresponding to $F^{*n}alpha$ consists of three trivial vector bundles so it splits. This means pullback of $F^{*n}alpha$ to some finite etale cover is trivial.

My question: is it possible to kill elements in $H^i(X,mathcal{O}_X)$ by a combination of pullback along Frobenius and finite etale covers? ($i>1$)

complexity theory – For every non-trivial language $A$ and every finite strict subset $B subsetneq A$, it’s holds that $A le_m A setminus B$

It’s claim 1 from Bader Abu Radi‘s solution to this question.

My solution (have no idea how wrong it is):
$B$ finite $Rightarrow$ $Bin R Rightarrow$ exists TM $langle M_Brangle$ that halts $B$.
Let’s define reduction $f$ from $A$ to $A setminus B$, in the following way $f(langle M_Brangle , x)=langle M_Arangle$

When $M_A$ implemented on input $w$ like this:

  1. Run $M_B$ on $w$ and answer on the same way

$xin B Rightarrow M_B$ accept $xRightarrow M_A$ accept $xRightarrow xin M_A$

$xnotin B Rightarrow M_B$ reject $xRightarrow M_A$ reject $xRightarrow xnotin M_A$

So the reduction $A le_m A setminus B$ true.

As I wrote early not sure how wrong is it, additionaly what’re the changes that should be done to proof the second claim ($A setminus B le_m A$) from the same answer.

abstract algebra – Why is the cyclotomic polynomial quotient ring isomorphic to a product of finite fields?

I am looking at the ring $R = mathbb{Z}(X)/(Phi_m(X), p)$ where $Phi_m$ is the $m$th cyclotomic polynomial and $p$ is a prime. What I want to show is that $R$ can be split into $l$ copies of $mathbb{F}_{p^d}$ where $d$ is the smallest integer such that $p^d equiv 1 mod m$ and $lcdot d = phi(m)$, the degree of the polynomial.

The condition in some sources I have looked at says that $p$ cannot divide $m$ and that $p$ cannot be ratified in $mathbb{Q}(zeta_m)$ where $zeta_m$ is the $m$th root of unity. I cannot make the connection of why this is necessary. I don’t even know if the polynomial have to be cyclotomic, or that it is sufficient that they are irreducible in $mathbb{Z}(X)$. Any tips would be much appreciated.

finite fields – Does Mathematica limit the size of a set of permutation group generators?

I tried to generate general and special linear groups PGL2 and PSL2 over finite fields using straightforward algorithms over finite fields: The generators are permutations defined as the additive group, multiplicative group, and inversion over the field.
Although my algorithms work properly for fields of size < 100 (PSL2), resp. <74 (PGL2), for larger input they generated substantially smaller permutation groups. For instance,
(full code below)

GroupOrder@PSL2(97) 

gives the expected results 456288

GroupOrder@PSL2(101)

gives 5100.

Moreover, for n=97 my code generates counterintuitively smaller PGL2(97) than PGS2(97)

GroupOrder@PGL2(97)

answers 9408 (the correct size is 912576=2*456288)

I believe the error is neither algebraic nor in my code, because it only appears from a certain number upwards and moreover, the limit is smaller for pgl than for psl. Therefore I hypotheses I exceed the maximum allowed number of generators. Is it true?

code for PGL2 and PSL2

<< FiniteFields`
PGL2(q_) :=Module({pField = (FactorInteger@q)((1, 1)), 
rField = (FactorInteger@q)((1, 2))},
fiFiQ = GF(pField, rField);  (* define the finite field *) 
elementsFiFoQ = fiFiQ /@ Tuples(Range(0, pField - 1), rField); (* list of elements of the finite field *) 
enumeratedElementsFiFiQ=MapThread(RuleDelayed, {elementsFiFoQ , Range(q)} ); (* enumerate elements of the field *) 
addPerm=PermutationCycles /@ (Outer(Plus, elementsFiFoQ, elementsFiFoQ) /. enumeratedElementsFiFiQ /. {0 -> 1}); (* permutations corresponding to the additive group *) 
multPerm=PermutationCycles /@ (Outer(Times, elementsFiFoQ((2 ;;)), elementsFiFoQ) /. enumeratedElementsFiFiQ /. {0 -> 1}); (* permutations corresponding to the multiplicative group *) 
invPerm=PermutationCycles@(({q + 1} ~ Join~(1/# & /@ elementsFiFoQ((2 ;;))) ~ Join~{1} ) /. enumeratedElementsFiFiQ /. {0 -> 1}); (* permutation corresponding to the inversion *) 
PermutationGroup@(addPerm (Union) multPerm (Union) {invPerm}))
   



PSL2(q_) :=Module({pField = (FactorInteger@q)((1, 1)), 
rField = (FactorInteger@q)((1, 2))},
fiFiQ = GF(pField, rField);  (* define the finite field *) 
elementsFiFoQ = fiFiQ /@ Tuples(Range(0, pField - 1), rField); (* list of elements of the finite field *) 
enumeratedElementsFiFiQ=MapThread(RuleDelayed, {elementsFiFoQ , Range(q)} ); (* enumerate elements of the field *) 
addPerm=PermutationCycles /@ (Outer(Plus, elementsFiFoQ, elementsFiFoQ) /. enumeratedElementsFiFiQ /. {0 -> 1}); (* permutations corresponding to the additive group *) 
multPerm=PermutationCycles /@ (Outer(Times, elementsFiFoQ((2 ;;)), elementsFiFoQ) /. enumeratedElementsFiFiQ /. {0 -> 1}); (* permutations corresponding to the multiplicative group *) 
invPerm=PermutationCycles@(({q + 1} ~ Join~ (-1/# & /@ elementsFiFoQ((2 ;;))) ~ Join~{1} ) /. enumeratedElementsFiFiQ /. {0 -> 1}); (* permutation corresponding to the -1/x *) 
PermutationGroup@(addPerm (Union) multPerm (Union) {invPerm}))

Every subset of a sigma finite measure space is finite?

Is it true that:

For (X, M(x), $mu$) a measure space

For $mu$ a SigmaFiniteMeasure

For "m" any measurable set in M(x)

Then $mu$(m)<$infty$

??

If it is so, why?

limit on finite sum with parameter

Thanks for contributing an answer to Mathematics Stack Exchange!

  • Please be sure to answer the question. Provide details and share your research!

But avoid

  • Asking for help, clarification, or responding to other answers.
  • Making statements based on opinion; back them up with references or personal experience.

Use MathJax to format equations. MathJax reference.

To learn more, see our tips on writing great answers.

finite automata – Is there a method to generate the complement of a context-free grammar?

If $L_0$ in a context-free language, this doesn’t guarantee that its complement is context free. For example, consider the language
$$L_0 = {a,b,c}^* setminus {a^nb^nc^n : n geq 0}.$$
This language is context-free, but is complement (with respect to ${a,b,c}$) is not.

Another way to formulate your question is as follows: given a context-free grammar for a language $L$, is there an algorithm that either constructs a context-free grammar for the complement of $L$, or determines that the complement of $L$ is not regular? Such an algorithm can be used to decide whether the complement of $L$ is context-free. However, this is undecidable, as we now show following Hendrik Jan’s notes.

Recall that given a grammar $G$ over an alphabet $Sigma$, it is undecidable whether $L(G) = Sigma^*$. Let $#$ be a new symbol, and construct a grammar for the language
$$ L = L_0 # Sigma^* cup Sigma^* # L(G), $$
where $L_0$ is a context-free language whose complement is not context-free (if $|Sigma| geq 3$, we can use the one above, and if $|Sigma| = 2$, we can encode $a,b,c$ as $a,ba,bba$; if $|Sigma| = 1$ then it is easy to check whether $L(G) = Sigma^*$). If $L(G) = Sigma^*$ then $L=Sigma^*#Sigma^*$, and so the complement of $L$ is context-free. Otherwise, suppose that $w notin L(G)$. Then
$$ overline{L} cap Sigma^* # w = (Sigma^* setminus L_0) # w, $$
which is not context-free, and so $overline{L}$ itself is not context-free (since the context-free languages are closed under intersection with a regular language). This shows that $overline{L}$ is context-free iff $L(G) = Sigma^*$.

The problem of deciding whether $L(G) = Sigma^*$ is actually not recursively enumerable. This means that there is no algorithm which, on input $G$, halts iff $L(G) = Sigma^*$ (however, there is a simple algorithm that halts iff $L(G) neq Sigma^*$, namely go over all words in $Sigma^*$ in parallel, and check whether each of them belongs to $L(G)$). Therefore there is no algorithm that, given a context-free grammar for a language $L$, halts iff the complement of $L$ is context-free.

In other words, even the following solution to your problem does not exist: an algorithm that attempts to construct a context-free grammar for the complement of the given context-free language, and either halts with the grammar, or never halts (if the complement is not context-free).

finite automata – Is there a method to generate the compliment of a context-free grammar?

Given the languages $L_0 = {w in {0,1}^*}$ such that $w$ is a palindrome and $L_1 = {w in {0,1}^*}$ such that $w$ is not a palindrome, meaning $L_1$ is the compliment of $L_0$, we want to find the grammar for both languages. $G(L_0) = S to epsilon | 0S0 | 1S1 | 0 | 1$ is easy to come up with, but $G(L_1)$ is much more complex.

In this case, we have the simple CFG $G_0$ and want to find the CFG $G_1$ that is its compliment which can be much more complex. Is there a method to derive the compliment of a CFG?

Is the finite automata constructed correctly?

Construct a NFA that accepts an arbitrary long sequence of zeros and one that ends with a zero followed by a zero or a one.

I took a look into the solution and saw the following state transition function (STF) where q0 is the initial state and q2 the acceptance state:

STF(0) = {(q0,q0), (q0,q1), (q1,q2)}

STF(1) = {(q0,q0), (q1,q2)}

So, there is no transition for q2 to another state, so can we just accept that the string ends when reached q2?
I mean, if we had the input 0011, we would still end in q2 on one path although the input should be rejected. My question is, if we are in a state q2 and there are no other arrows leading to another state but the input is not finished, in which state would I go if there is still a 1 in the input? Do I just stay in q2? But if yes, then we would accept strings that should be rejected?

Can someone help me out?

finite automata – Why is this automaton considered DFA?

Some people in the literature (very few actually) do not consider missing transitions as nondeterminism, and given a DFA, they allow themselves to remove all transitions that lead to states from which we cannot reach an accepting state. The reason for that is technical, as sometimes it may simplify proofs a bit. Or it could be a matter of taste.

Intuitively, allowing missing transitions is justified as nondeterminism, or guessing occurs only when we have a choice, that is, when we have at least two transitions $langle q, sigma, s_1 rangle$ and $langle q, sigma, s_2 rangle$, going out from the same state $q$, and are labeled with the same letter $sigma$. So, DFAs with missing transitions, or more accurately NFAs such that for every state $q$, and letter $sigma$, it holds that $|delta(q, sigma)|leq 1$, are considered deterministic in the sense that they have at most one run on a given input word.

The most common formal definition of a DFA does not allow missing transitions. Please note that it does not really matter to which definition you stick as long as you’re consistent with it.
Also, it is an easy exercise to see that modifying a DFA so that all transitions leading to a state from which we cannot reach an accepting state is easy (because detecting states that do not lead to an accepting state can be done in polynomial time), and this does not affect the automaton’s language. Conversely, given an automaton with missing transitions, you can direct all missing transitions to a rejecting sink which is a rejecting state with a self loop labeled with every letter.