Find all finite dimensional simple Lie algebras satisfying certain conditions

Let $mathfrak{g}$ be a finite dimensional simple Lie algebra over $mathbb{C}$. Suppose that $mathfrak{g}$ can be generated by five nonzero elements $x,y,x’,y’,hin mathfrak{g}$, which satisfy the following relations:

$$(x,y)=h, (h,x)=2x, (h,y)=-2ytag{1}$$
$$(x’,y’)=h, (h,x’)=2x’, (h,y’)=-2y’tag{2}$$
$$(x,x’)=(y,y’)=0tag{3}$$

Basically, ${x,y,h}$ and ${x’,y’,h}$ each form a $mathfrak{sl}(2)$, sharing the same CSA, and with $(x,x’)=(y,y’)=0$. We can represent the relations graphically as follows:
Graphical representation of the generators

Question: what are all possibilities of $mathfrak{g}$? My conjecture is that $mathfrak{g}$ can only be $mathfrak{sl}(2)$, with $x=lambda x’, y’=lambda y$, for some $lambdain mathbb{C}$, but I have no idea how to prove it.

(A vague idea: maybe we can first prove that there exist $fin mathrm{Aut}(mathfrak{g})$ with $f(x)=x’,f(y)=y’,f(h)=h$, and then use our knowledge of automorphisms of simple Lie algebra to restrict the possibilities of $mathfrak{g}$?)

finite automata – Constructing a NFA from a regular expression

I have the following regular expression $R=ab^*(epsilon cup c) cup c^*a$ and I want to construct the NFA that accepts languages defined by that regular expression.
I started by constructing the NFA that accepts $R=ab^*(epsilon cup c)$

NFA R1

Next I tried to continue the concatenation part by adding the following to the NFA as follows:
NFA R2

Is that correct? is there a quick approach to construct NFA from long regular expressions?

Could the halting problem in theory be solved for any finite set of Turing Machines?

Your logic is somewhat correct. I will start by discussing the new definition you tried to give for the halting problem, and then move on to explain the finite set of TMs.


Halting problem, with size less than the TM that solves it

This idea is certainly interesting, but it has some inherent problems with it.

First is a syntax problem. What language is here? Since $N$ is not bounded, this cannot be expressed as a usual computational problem with TMs. In order to formalize this you might want to create a new definition.

The second problem, is a bit more subtle: How do you define the “size” of a TM?
For example, if you decide to define it as the running time of the algorithm, then obviously is such a $B$ for every $N$ (just do a loop that does nothing for $N-1$ steps and after that accept). But if you define it as the length of the code plus the length of the inputs, then you can show that there is no such $B$ for big enough $N$. (the formal halting problem gets two inputs $A,X$ where $A$ is a program code and $X$ is some string, and you create a new TM that simulates it with only one input instead of two, reducing the size)

Those examples are obviously two opposite sides of a wide spectrum. You want to formally define the problem and the definition of the size of a TM before you can think of whether or not its possible.


Finite set of TM

The formalization of the halting problem $H$ is as follows: $H={langle M, x rangle : M text{ is a TM }land M(x)text{ halts}}$

With this definition, even if you restrict it so $M$ would be in a predefined finite set of TMs, and even if this set contains only one TM, this is an undecidable problem! The counterexample, is $U$ – the universal TM. We will use a slightly different version of it, since we dont need its full power. $U$ (in this context) gets one input, which is a string representing a TM, and $U$ simulates this TM with the input $epsilon$. Then solving whether $U$ halts on some input or not, is undecidable, since its equivalent to the problem called $H_epsilon$ which is known to be undecidable.

However, if you would restrict the $H_epsilon$ problem itself for only a finite set of TMs, the problem becomes decidable, and even more! It becomes a regular language. This is because for each $TM$ in this finite set we know beforehand whether or not it halts, and we dont have to actually do any computation apart from assigning each of those $TM$ the correct label we already know.

ag.algebraic geometry – Covering abelian varieties over finite fields with the product of curves

Question. Given an $n$-dimensional abelian variety $X$ over a finite field, is it possible to find smooth projective curves
$C_1,ldots, C_n$ such that there exists a finite regular map
$C_1times ldots times C_nrightarrow X$?

I was thinking maybe using the space filling curve, we have a sequence of space-filling curves that cover all rational points, picking $n$ of them we can define a map from their product to $X$, by first mapping the product to the product of $n$-copies of $X$ and then taking the sum of it. This gives a regular map from product of $n$ curves to $X$ which is surjective let’s say on $mathbb{F}_{p^m}$ points, which we can take $m$ to be arbitrarily large. The only problem is that one needs to verify that image of this map is $n$-dimensional. Although I don’t know how to prove it, it seems intuitively obvious.

finite automata – Constructing a NFA that accept complement of language L of another NFA

Is there a general way to do it? The answer is yes: one way to do it is to find a DFA that accepts $L$ (for example with the powerset construction), make it complete (by adding a sink state), and swap final states and non-final states. The automaton is deterministic, but it is a special case of non deterministic.

Is there a polynomial time way to do it? I don’t know, since the construction above can be exponential time in the number of states (because of the powerset construction).

Finite loop on a NFA

Some of this depends on what you mean by “tries.” But here is a reasonable first whack.

Suppose that the password is ab and you want to give a person two tries. Take q0 to be the initial state, take q2 to be the only accepting state, take q3 to mean “first try failed, initalize second try” (and it might light a light, warning the inputter that their first try failed). Also take q5 to be the (non-accepting) state meaning two-try failure.

Coming from q0 are two arrows, one to q1 labeled a and one to q3 labelled b. From q1 are two arrows, one to q2 labeled b and one to q3 labeled a. From q2 is a loop, labeled any.

You get the idea. From q3 are two arrows, one to q4 labeled a and one to q5 labeled b. From q4 come two arrows, one to q2 labeled b and one to q5 labeled a. From q5 is a loop, labeled any.

This is of course hopelessly naive from a security standpoint. But it gets across the basic idea.

ag.algebraic geometry – Rational varieties over finite fields admit an open set isomorphic to an affine space

This paper roughly claims that given a projective variety $X$ over a finite field, there is a finite map $f:Xrightarrow mathbb{P}^n$ such that if $H$ is a hyperplane in $mathbb{P}^n$ and $U=mathbb{A}^n$ is the complement of $H$, then the induced map $f:f^{-1}(U)rightarrow U$ is étale.

So let us consider that $X$ is a rational smooth projective variety. Since $f:f^{-1}(U)rightarrow U$ is étale and $X$ and $mathbb{P}^n$ have isomorphic function fields then it implies that $f:f^{-1}(U)rightarrow U$ is an isomorphism. So this implies that there is actually an affine $f^{-1}(U)$ in $X$ which is $mathbb{A}^n$.

I am not sure whether I’m making any mistakes or not, but this seems a little bit odd.

Question. Is there any way to understand the complement of
$f^{-1}(U)$? Like whether it is a smooth variety or not?

architecture – Is a language which terminates in a given amount of real-time still Turing complete for all finite problems?

Background: this is a continuation of this question here, further expanding the thought experiment.

In short, you have a magic calculation machine which has the following properties.
The machine is:

  • Fast. The rigid definition is that the processor frequency can be arbitrarily high (though not infinite).
  • Finite. (NEW) Any program that runs on this processor has a fixed, finite input and output size. If the program tries to output more information than it’s pre-determined output size, the machine immediately exits. It is not possible to alter these values.
  • Frugal. This means that the output of the machine is strictly the data that is outputted. This means that the state of the machine is not an output, and a program that loops infinitely without printing anything has the same output as a program that exits immediately. Expanding on the finite quality of our machine, this means that both of the previous examples are equivalent to any program which has a pre-determined output size of 0.
  • Fleeting. The processor has a pre-determined time of execution. This time can be arbitrarily high, but not infinite.

The question:

Given that the processor IS Turing complete with only the (fast) quality, is the processor with the other limitations also Turing complete?


I should note that a language is considered Turing complete if:

It can solve every problem that another Turing complete language can, OR
It can solve every problem that a Turing machine can solve.

The following should not necessarily exclude a program form Turing completeness:

The program cannot solve every problem that a Turing machine can solve in the same way.


Further more:

Does the halting problem occur for any program in this processor?

finite automata – new language accepted by FA when new transitions are added to a FA?

found this question online and I am trying to solve this question. I have solved this question but I think I might be missing some cases. Could someone verify if my answers are correct?

Let N = (Σ ∪ {λ}, Q, δ, q0, {qf }) be a λ − NFA and let L = L(N) be the language accepted by N. For N assume q0 has no incoming transitions and qf has no outgoing transitions. For each of the following FAs that are modifications of N describe the language accepted by each in terms of L.

(a) A λ-transition is added from qf to q0.

(b) Add a λ-transition from q0 to every state reachable from q0 along a path with labels that may be λ or symbols from Σ.

(c) Add a λ-transition to qf from every state that reach qf along some path.

(d) The FA where both (b) and (c) are done.


a) L+

b) For this one I have defined a function suff, this takes all the valid strings in the original Language and generates new stings from them. For example, if L = {112,12} where alphabet is {1,2}

Then, suff(L) means suff(112) + suff(12)

where suff(112) = {112,12,2}, keeps chopping off the first symbol until u get empty string

Similarly, suff(12) = {12,2}

So, the final answer would be suff(L) + the empty string. (Is this correct?)

C) for this one, I defined pre which is similar to suff but chops off the last symbol.

pre(123) = {123,12,1}
pre(112) = {112,11,1}

So, the final ans is pre(L) + empty string

d) I need help with this one..

oa.operator algebras – Is there a finite depth irreducible subfactor of prime index and not group-subgroup?

Let $N subset M$ be a finite depth unital inclusion of II$_1$ factors. By Theorem 3.2 in this paper (Bisch, 1994), if the index $|M:N|$ is integer then for any intermediate subfactor $N subset P subset M$, $|M:P|$ and $|P:N|$ are also integer. In particular, if $|M:N|$ is prime then there is no proper intermediate (maximal subfactor).

A finite group subfactor remembers the group but a finite group-subgroup subfactor does not always remember the (core-free) inclusion of groups (Kodiyalam-Sunder, 2000). This paper (Izumi, 2002) provides a group-theoretical characterization of isomorphic group-subgroup subfactors. It is easy to see from this characterization that a maximal group-subgroup subfactor remembers the (core-free) inclusion, because the intersection of a core-free maximal subgroup with an abelian normal subgroup is trivial (see here).

A core-free inclusion of finite groups is the same thing than a transitive permutation group, and in the maximal case, replace transitive by primitive. Obviously, at prime degree, a transitive permutation group is always primitive.

So the number of maximal group-subgroup subfactors (up to dual) of index $n$ is exactly the number of primitive permutation groups of degree $n$, see OEIS/A000019 ($1, 1, 2, 2, 5, 4, 7, 7, 11, 9, 8, 6, 9, 4, dots$).

Here is a way to get the corresponding inclusion of finite groups $H subset G$ by GAP:

gap> NrPrimitiveGroups(5);
5
gap> for i in (1..5) do G:=PrimitiveGroup(5,i);; H:=Stabilizer(G,1);; Print((H,G)); od;
( Group( () ), C(5) )( Group( ( (2,4)(3,5) ) ), D(2*5) )( Group( ( (2,3,4,5) ) ), AGL(1, 5) )
( Group( ( (2,4)(3,5), (3,4,5) ) ), A(5) )( SymmetricGroup( ( 2 .. 5 ) ), S(5) )

The subfactors of index $2$ or $3$ are given by the groups $C_2$, $C_3$ and the inclusion $(S_2 subset S_3)$, and (dual) principal graphs $A_4$, $D_4$ and $A_6$. At index $4$, the subfactors of principal graph $E_i^{(1)}$, $i=6,7,8$ are all maximal (because $2$-supertransitive), but there is only two primitive permutation groups of degree $4$, giving the inclusion $A_3 subset A_4$ and $S_3 subset S_4$, with (dual) principal graphs $E_i^{(1)}$, $i=6,7$. So the maximal subfactor of index $4$ and (dual) principal graph $E_8^{(1)}$ is not a group-subgroup subfactor. Finally every finite depth subfactor of index $5$ is group-subgroup (Izumi-Morrison-Penneys-Peters-Snyder, 2015).

Conclusion, a finite depth maximal irreducible subfactor of integral index is not always group-subgroup, but the found counter-example (of principal graph $E_8^{(1)}$) is not of prime index. So the following question remains:

Question: Is there a finite depth irreducible subfactor of prime index and not group-subgroup?