L₁ is regular. y can be expanded and w can also expanded. So x can be either "a" or "b".
So it is equivalent to
(a+b)⁺ a (a+b)⁺ a + (a+b)⁺ b (a+b)⁺ b
L₂ is CFL since it is equivalent to complement of L=ww.
Complement of L=ww is CFL.

L is DCFL.
We can make DPDA for this.

L is not LL(k) for any “k” look aheads. The reason is the language is a union of two languages which have common prefixes. For example strings {aa, aabb, aaa, aaabbb,….} present in language. Hence the LL(k) parser cannot parse it by using any lookahead “k” symbols.

Every subset of recursively enumerable need not be recursive. For example (a+b)* is a universal language and regular. Every language over alphabet {a,b} is subset of (a+b)*. This language is regular so it is recursively enumerable also and so many languages are known to be non-recursive which are definitely subset of (a+b)*. Thus every subset of recursively enumerable need not be recursive.
If L and L(complement) both are recursively enumerable then L must be recursive. It is a theorem.
Every CFL is CSL and CSL is closed under complement so complement of CFL must be CSL and every CSL is recursive. Thus the complement of CFL must be CSL, hence it must be recursive also.
If L1 and L2 are regular then their intersection must be regular, as regular languages are closed under intersection, so L1 intersection L2 must be regular, hence it must be DCFL, since every regular is also a DCFL.

Option1 is incorrect because it can generate “a” where n=1. so given condition(n>2) is violated. Option 2 is incorrect because it can generate “null string”. so given condition(n>2) is violated. Option3 is incorrect because it can generate “a” where n=1. so given condition(n>2) is violated. Option4 is correct because it can generate strings “ab,aaa, aaaab…...” where nn>2. so it is the correct option.

Option 1 is incorrect because every string generated by given grammar will contain only 0's and given option is generating string containing 1's also. Option 2 is incorrect because it can't generate "000". Option 3 is correct because it generates string same as given grammar do. Option 4 is incorrect because every string generated by given grammar will contain only 0's and given option is generating string containing 1's also.

→In the option C, a^mb^m:m>0, For a given “m” value always it generates one or more “a” s followed by Same number of “b” s.
→Example :
m=1 ⇒ ab
m=2⇒ aabb and so on.

The given grammar is left linear grammar which is also a regular grammar. Hence the highest type number which can be applied to the following grammar is Type 3 which is notation for regular grammar.

Total 6 productions are there.
E->E+T
E->T
T->T*F
T->F
F->(E)
F->id

Since A,B,C,D,E all derive something in grammar so {A,B,C,D,E} all are non terminals, also by default we represent non terminal with capital letters.

The grammar generates {a, b, aaa, aba, bab, bbb, aaaaa, aabaa, …}
So the grammar generate odd length palindrome.

Option(A) : it is correct option because L= {aⁿ bⁿ cⁿ} is a context sensitive language and it can also be accepted by the turing machine. Hence every CSL also recursive language.

Option(B): It is incorrect option.

Option(C): Yes it is true that recursively enumerable languages are closed under union.

Option(D): It is a correct option because recursively enumerable and recursive languages are closed under reversal.

NOTE: The difference between recursive and recursively enumerable language is that if a language is recursive then there will be definitely a turing machine which will halt and will say whether the string is accepted or not. But if a language is recursively enumerable then the turing machine will halt if the string is accepted but it is not necessary that the turing machine will halt to indicate that the string is not accepted. in this case the user might end up in infinite wait by thinking that turing machine will halt string acceptance process is still in progress.

As we know, for any regular expression R,
Rϕ = ϕR=ϕ
So L₁ L₂ * = ϕ
and L₁ * = {ϕ}* = {ϵ}
So L₁L₂* ∪ L₁* = {ϵ}

The given language is DCFL and hence recursive. First we will push 0’s in the stack and when we will see 2 then just read it and then pop 0’s corresponding to one 1.

The sequence of p is not in arithmetice progression form due to which it not context and not regular but can be accepted by turing machine.