## Ways to enumerate an enumerable set of languages?

Given some computably enumerable collection of languages, what are the different ways you can enumerate them? For example, you can enumerate them by the machines that compute them–how is this done? What are some other methods?

## complexity theory – Are the languages in \$P\$ enumerable in \$PSPACE\$?

$$P$$ is $$RE$$ and $$coP$$ is $$RE$$ therefore $$P$$ is $$R$$ and we can enumerate a list of machines (in some lexicographic order (providing an index)) for the languages in $$P$$.

Can such a list be enumerated in $$PSPACE$$? Or, easier: is there a choice of enumerator that can enumerate $$b$$ in $$PSPACE$$, for any particular choice of machine (language) $$b$$ in $$P$$?

## Machines – show that there is an infinitely decidable quantity in every infinitely enumerable quantity

I encountered this problem: Show that there is an infinitely decidable set in every infinitely enumerable set.

As an attempt to solve the problem, I could only imagine constructive evidence. Let the alphabet be without loss of generality $$Sigma = {0.1 }$$. The construction is as follows, let's assume that $$TM$$ $$M$$ recognizes an infinite number that can be calculated $$L$$we can form a decidable language $$D subseteq L$$ as follows:

1) List all entered words lexicographically $$w$$ in the $$Sigma ^ *$$ and repeat steps $$a-b:$$

a) at the $$k$$Walk step $$M$$ on input words $${w_0, w_1, …, w_k }$$ to the $$k$$ Steps where words $${w_0, w_1, …, w_k }$$ are arranged lexicographically

b) if $$M$$ accepts an input word $$w in {w_0, w_1, …, w_k }$$ Include from step 2 $$w$$ in a temporary language $$D_ {temp}$$

2) Partition the words into $$D_ {temp}$$ in two that start with $$0$$ are $$in D$$while those who start with $$1$$ are $$not in D$$along with all the other words $$Sigma ^ * – D_ {temp}$$.

Step (1) does not loop in a word $$w$$ since each run from step (1) is limited to a finite number of $$k$$ Steps. Is this construction okay? Or did I miss something …

## Complexity Theory – Use Rice's theorem to prove that the following property of a recursive enumerable language L is undecidable

This exercise comes from the book "Languages ​​and Machines: An Introduction to Theory of Computation" by Thomas Sudkamp. It refers to Exercise 12 (b) Chapter 12. For a language L that can be recursively enumerated, I have to prove that the following property is undecidable:

The text says that it is sufficient to prove that it is a non-trivial property.

I tried to solve the exercise as follows:

Consider the empty language $$emptyset$$that contains only the empty string
in other words $$emptyset$$ = {$$lambda$$}. Then $$emptyset ^ –$$ This is the negation of the empty set. Will contains a string that it is not $$lambda$$, In this way I found a language that is finite and fulfills the property, but I also found another language that does not fulfill the property because $$emptyset ^ –$$ it is not finite. In summary, the property is not trivial, and according to Rice's theorem, it is impossible to determine this property.

I'm not sure if I'm doing the right thing here and I haven't found a solution to this exercise … Can anyone help me or at least tell me if I'm doing it right?

Thank you very much.

## automata – Turing machine and Recursively Enumerable Language

Indicates whether a TM accepts a recursively enumerable language. Decidable or not?

And what if the question was whether a TM accepted on RE language. Decidable or not?

I think the first one should be right as it is $$TRIVIAL$$ Accept property from TM $$REL$$

and the second should be partially decidable, right? how $$Membership$$ The problem of recursively enumerable language is undecidable, so we can conclude that our question whether a Turing machine accepts $$a$$ RE language is also undecidable?

## turing machines – recursive vs recursively enumerable vs non recursive enumerable vs. unpredictable

I can not tell if there are differences between nonrecursive enumerable and unpredictable values. What makes one or the other language?

Is it safe to assume that all recursive languages ​​are decidable, or is it possible to have an undecidable language that is recursive?

Are all recursively enumerable languages ​​semi-decidable (like the problem of stopping)?

Please give examples if possible. I spent hours trying to figure out these concepts, and it just does not feel right.

## Recursively enumerable ordinal numbers

Is there an explicit list of Church-Kleene ordinal numbers? $$omega_1 ^ {CK}$$? A general explanation of what it means that an atomic number is calculable and / or recursively enumerable could also be helpful.

## Does the language of all TMs * not * accept a specific string, Enumerable?

Is the following language in RE?
$$L = { langle M rangle: M text {is a TM that does not accept} 010 }$$

I could use Rice's theorem with the property $$P = {L: 010 text {is not in} L }$$ to show it is not in Rbut how do i show it is in RE?

## – iterating through an enumerable list and checking if the property in the list is repeated during the foreach rounds

I have a list called People that contains Id, DataNasc, and so on. I need to get these data into a list view in HTML using Razor (or they can be from the cshtml page in the CS files).

Suppose that person 1 has Id 1, DataNasc 3/23/2000.
And Person 2 (shown on the second back of Foreach in the view) has Id 2 and DataNasc also 3/23/2000, equal to Person 1.

I would like to make a request of the type:
"If the value of the DataNasc property in the People List is the same for more than one person, return all the people born that day."

Can someone help me?

I'm using C # Asp.Net MVC 4 with Razor View.

I'm new to C #, I've tried to do that, stop thinking that it does not make much sense, but I'm trying to maybe illustrate what I wanted, albeit with the wrong logic.

``````@foreach (var element in Model.People)
{
for (int i = 0; i <Model.Count (); i ++)
{
var arr = Model.People.ToArray ();
if (item.DataNasc == arr[i].DataNasc)
{
go[i].DataNasc
}
}
}
``````