## What Is the Complexity Class of Deciding Whether a Problem Is in NP? Is It Decidable?

Title says it all, but to clarify:

Define a problem, called $$IsInNP$$, as follows:

Given a Turing Machine $$M$$, $$IsInNP$$ is the problem of deciding if the problem that $$M$$ decides is in $$NP$$.

What is the complexity class of $$IsInNP$$? Is it even decidable? Is the answer the same for any other complexity class, like $$NP$$-hard? And are those questions even sensible to ask?

By the way, I am aware that the class $$NP$$ is not enumerable, but since I do not quite understand enumerability and it seems that recursively enumerable problems can be decidable, I do not know if that means that deciding whether a problem is in $$NP$$, or any other complexity class, is decidable.

Also, I am aware of Rice’s Theorem, and I believe it can be interpreted as saying that deciding whether a problem is in $$NP$$ is undecidable, but I am not certain.

Bonus question if the above questions are sensible: given a property $$S$$ that only $$NP$$ problems possess, does the above also mean that deciding whether a problem decided by a Turing Machine $$M_2$$ has property $$S$$ is in the same complexity class as $$IsInNP$$?

## Deciding which microservice should write to the database

Let’s assume the following architecture where

1. `EventCreatorApp` creates an `Event` which is logged to DB and sent to `WorkerApp` for processing
2. `WorkerApp` processes the event, handles failures, etc.
``EventCreatorApp --> [ DB ]         |          ---------> WorkerApp ``

Once `WorkerApp` is done, I want to update the event row in the DB with the outcome of running that event.

My question: Which app should write the outcome to the database?

If `WorkerApp` writes the outcome to the db the logic is nicely decoupled (one app creates events, one app executes events) but I have two apps writing to the db. What’s worst, I want to deploy `WorkerApp` on an AWS Lambda, and that would mean opening a new connection to the db for each event processed.

If `EventCreatorApp` writes the outcome to the db I don’t have any db access problems, but it feels like I’m pushing into `EventCreatorApp` some logic that doesn’t really belong there, and in general I’m coupling the two apps a bit since `EventCreatorApp` would have to wait for a response.

Which solution is best?

## Need help deciding which ubuntu distro to use on an old laptop [duplicate]

• What are the system requirements for each flavour of Ubuntu Desktop? 6 answers

I’m new here so let me know if anything what I’ve written here is against any kind of policy or something similiar.

Anyways, I wanted to ask you guys if you could advise me which linux/ubuntu distro should I use on my old laptop:
Intel Pentium PU 2177U 1.80GHz; 8GB Ram; 280 GB HDD 5400RPM; NVidia Geforce GT 710M

I’ve tried using lubuntu for a while but I ended up having few compatibility issues so I uninstalled that one. As I’m writing this I’m installing Xubuntu to see how the results will be there.
Furthermore do you think that ubuntu with minimal installation will work fine or not?

## Deciding which machine learning algorithm to use

I am making an android application that responds to what a user says. I have very little experience with machine learning and I am wondering which machine learning algorithm to use, or if I should even go this route.

Some information about the app…I am writing it in java and the application will have to handle anything a user says and then react based on what was said. Basically a homemade Alexa. The reactions are limited with some examples are a greeting, the weather, or play a song. So I would want to teach the application to know what to do based on what was said. Any information or insight will be greatly appreciated.

## Deciding on the dependancies of the objects

I have two classes namely:

• Document
• Classifier

At present, the document depends on the list of classifiers to determine the category of each paragraph in the document. The document merges the categories from each classifier based on some business rules.

The API looks something like:

``classifiers = [C1(), C2(), ...Cn()]  document = Document(text, classifiers) result = document.get_categories() ``

In my opinion, the document knows too much right now and it is becoming like God class. What if I do something like:

``document = Document(text) classifiers = [C1(document), C2(document), ...Cn(document)] ``

It looks a bit cleaner to me but I am not sure which object should be responsible for aggregating the results and which is a better OOP design?

## Deciding on a license for users purchasing digital files from a marketplace

I have a digital marketplace where users can sell anything such as photos, videos, 2d game graphics, etc…

I want a license stating any digital good you buy, you can use it for anything you want except reselling it. Is there a standard license for this? I was looking at creative commons, but I think that allows resell?

## What do I know, when deciding whether to cast Counterspell?

I’m not entirely clear on how Counterspell works, when trying to counter higher-level spells: the CS description only talks about disrupting a creature you can see, within 60 feet, casting a spell.

However, when trying to counter a higher level spell:

1. Do I know what spell is being cast?
2. Do I at least know (somehow intuit, based on VSM components) the level of the spell?
3. Or can I tell the spell/level of the spell by sensing a disturbance in The Weave? (I.e., if the spell is being cast using Subtle Spell, can I still tell what’s going on?)

The point of the question is to determine how fruitful CS can be in combat–if I know what the other guy/gal is casting (or at least the level), I can decide whether I want to spend my L8 slot to counter his/her L8 slot. But if I have no idea, and I end up using a L8 slot to counter a L3 spell… seems a bit painful.

## Deciding between lowriter and unoconv

16.04: I will need to batch convert a group of .docx files from the command line repeatedly / many times.

The two simple options seem to be lowriter (native) and unoconv (add-on package). I suspect that unonconv is preferred, however, it is not clear why.

Is there a particular feature (advantage) of unoconv that would prompt the user to go through the (trivial) additional step of configuring unoconv? Any pitfalls to avoid or lessons-learned are always appreciated.

## Methods for deciding between [odd number] players

When DM’ing and randomly determining a character to take damage or an effect, it’s easy to roll a die if you have an even number of players.

Does anybody have any ideas or methods they use for randomly choosing 1 out of an odd number of players? (where each player’s probability of getting choosen is even or very close to even)

## Which check would be best for deciding which personality of a multiple-personality character is in control? [on hold]

My brother is wanting to play a character with multiple personalities but we’re unsure how to actually go about switching which personality is in control.

The system he currently has is this:

Every 1d6 hours, do a wisdom check for inactive personality, and a wisdom save for active personality. If active personality fails save, inactive personality becomes the active personality.

I’m under the impression that there is probably a different save/check that would be better for this, but I can’t think of what it might be.