Why do we consider enumeration up to $w$ instead of leaving it to as many ordinal numbers?

A few minutes ago I asked a question about a "proof" that $ \mathbb{R}$ is enumerable that crossed my mind: What's wrong with this "proof" that $ \mathbb{R}$ is enumerable?

I was told to look into ordinal numbers, and that after crossing $ \omega$ we stop considering something to be an enumeration.

Why is this the case? Are there negative consequences if we don’t put this limitation?

Edit: I always thought of $ \mathbb{N}$ as the "counting numbers" – but… when we cross over to ordinals like $ \omega$ , $ \omega+1$ , etc, aren’t we still effectively counting?

Complexity of enumeration vs complexity of counting

I have a problem understanding difference between complexity of enumeration and counting. We can solve every counting problem using enumeration algorithm.

Now, I have problem with the following. Let say that we have to count the number of positive integers less or equal than positive integer $ N$ . We know that the answer is $ N$ and therefore we can solve the counting problem in $ \mathcal{O}(1)$ . Corresponding enumeration problem is to output every positive number and this can be done in $ \mathcal{O}(N)$ steps and I believe that this is pseudo-polynomial complexity and that in fact complexity is exponential.

Are these complexity assumptions correct? Is the number of solutions of counting problem always bounded by the time complexity of corresponding enumeration algorithm?

Any hints or suggestions appreciated.

Can you verify a word’s position in an enumeration faster than performing the enumeration?

Pt 1. Given as input the tuple: (word, natural number)–does there exist a verifier, that runs faster than a fixed enumerator, that can accept if the word is in the position of the natural number in the enumeration by the fixed enumerator, and reject if it is not?

I suspect the answer is no. In that case…

Pt 2. Is there a way to get around this by adding a “tagging” function to the enumerator so that a verifier can be given something like (word#tag, natural number) so that it almost immediately knows, from the tag, if the word is in the position of the natural number (do there exist such ‘modified languages’) AND IT CAN’T BE FOOLED! Of course you can stick a natural number onto a word, but how can you do this so the verifier can BE SURE you aren’t lying…? Trying to figure out a way to tag the words (or generate a description for the words in a language (modify the language being enumerated/the enumerator)) so that stuck on to the words enumerated is the positions their the enumeration, and this information is reliable and can be verified quickly.

Any ideas? 🙂

Enumeration of a class of languages

Can you enumerate a class of languages in such a way that the description of every language/ machine enumerated encodes where it was in the enumeration?

Ex:if you are given the description of the bth machine/language enumerated you could quickly check, by some tag or marker in the description of the bth machine / language, that it was indeed the bth machine/language in the enumeration by an enumerator E.

Can you modify any enumerator for a class of languages so that it does this? Or can such an enumerator E be rigged up to do this for any enumerable class of languages?

To give context, my goal is for a verifier to accept, as one part of its input, the machine/language enumerated, and be able to see, quickly, what position that machine/language was in the enumeration by the enumerator E.

Thank you!

How to prevent Directory Enumeration Attacks (DirB or Directory Buster)

I am dabbling in pen testing (OWASP Juice Shop) and I realized many web application attacks start from enumeration where the attacker uses DirB to find vulnerable Web Objects or Directories to attack or access. So what i want to know is how to prevent such things from happening, to stop the attack before it can occur.

Because in OWASP Juice Shop, it is seen that the ftp directory of the site can be enumerated via DirB, so what are some recommendations to take to prevent such things from happening? And what are the risks of such attacks?

Tools for file system enumeration (LFI/directory traversal exploitation)

I’m familiar about a tool called DirBuster which allows to enumerate files and directories on a server. Is there any tool which allows to enumerate servers internal (non-public) files and directories, e.g. through some LFI/path traversal exploit which would look like:

www.example.com/show-file-contents.php?file=/etc/passwd.

What if there is specific logic for one particular value of an enumeration class?

Background: I have seem some argument for using enumeration classes instead of enum in C#, in particular, this section from a book available at MSDN. On the references there is this “Enums are Evil” article which in turn makes quite a good point on the matter.

One of the reasons quoted is particularly convincing:

Imagine the following phone call between Frank, a customer, and Darren the developer:

Frank: Hi Darren; I need a new value for the person status about his financial standings. We have currently Low, Medium and High, but we need ‘undefined’ as a new value.

Darren: I see.

Frank: When can you implement that?

Darren: Uups Frank. We just finished our sprint this week. The earliest we can plan this is for the sprint after the current one. That takes about 5 weeks.

Frank: What? It’s just another value not a whole new functionality!

Darren: Calm down Frank; we have these cool enum’s in place that saved us a lot of development time. To extend them I have to add it in the code and create a new build. We have to plan it for the next sprint.

Frank: Are you nuts? I don’t know what you talking about. I’m an ordinary user and just want to have another value on the user interface.

Darren: Sorry for that. I can’t do it earlier.

I’ve been through that already and it really feels like it is much more natural to allow the user to persist to the database the values he uses, like CardTypes as shown in the first MSDN link I provided:

public class CardType : Enumeration {     public static CardType Amex = new CardType(1, "Amex");     public static CardType Visa = new CardType(2, "Visa");     public static CardType MasterCard = new CardType(3, "MasterCard");      public CardType(int id, string name)     : base(id, name)     {     } } 

The problem: All of this is fine, and using these “enumeration classes” instead of enum has a lot of advantage. But now suppose the user comes and says that there is some specific rule for a specific item on the enumeration (for example, there is a very specific rule just for the Visa card).

With enums this is fairly easy. We would just perform a very natural check if (cardType == CardType.Visa). The point is: the values are all there on code to be checked.

But with enumerations the values are dynamical and added by the user. So the best I could consider would be to check for a string, querying the database’s table containing the enumeration values for the specific item.

But I think this is too error prone – say the user alters the string for that enumeration, the query wouldn’t work anymore. Further if the user made any typo when writing, it also wouldn’t work.

Is there some better method?

In summary: if we use enumration classes instead of enum and if there is a business rule for a specific item that the user is adding dynamically, how can we verify and address that in a more reliable way than “checking a string”?

Circular (bracelets) permutations with alike things(reflections are equivalent) using polya enumeration

Circular permutations of N objects of n1 are identical of one type, n2 are identical of another type and so on, such that n1+n2+n3+….. = N? A similar question exists but it doesn’t address the case where reflections are under the same equivalent class.$ $ \frac{1}{N}\sum_{d | N} \phi(d) p_d^{N/d}$ $ This is when reflections are not the same. How does the equation change under this new restriction.

Note: I couldn’t comment on that question due to my low reputation, so I made this question.

Pólya Enumeration Theorem and Chemical Compounds

How many different chemical compounds can be made by attaching H, CH3, or OH radicals to each of the carbon atoms in the benzene ring of Figure 1? (Assume that all of the C–C bonds in the ring are equivalent.)

Figure 1: Figure 1

I understand the overall method of the Pólya-Burnside Method of Enumeration but I don’t understand how to apply it to a chemical compound problem like this. Any help would be great, thank you in advance!