## Prove with pumping theorem that the language { \$a^n b^n b^m a^m | n ≠ m \$ } is not context free

I’m having a trouble proving it to be context free, with an example if I take w = $$a^k b^k b^{k+1} a^{k+1}$$

then it would be problematic if the partition of $$vxy$$ with $$|v| = |y|$$ was in the $$b^{k+1} a^{k+1}$$ part as I can’t get it to be equal with $$k$$ or make the amount of $$a$$ and $$b$$ different

It is also allowed to be proven with Ogden’s Lemma

## What algorithms/data structures should I look into for parametric & subtyping polymorphism implementation in a toy language?

I’ve been trying to replicate a simple imperative OOP language that supports subtype and parametric polymorphism. So far I’ve got the basics down: simple control flow statements, variable declaration/assignment, function declaration & calls.

Thing is, my implementation so far is pretty on-the-fly, I’ve been using pretty elementary concepts to implement the things listed above: dictionaries for variable/function declarations (with a few guards to keep track of scope), a stack for program execution, and 2 class hierarchies for expressions (things that can be evaluated and return a value) and statements (things that modify the program state). Subtyping and generics on the other hand sound a little more complex and I’m trying to find some resources to see how I could implement them.

At the type level, the project is extremely simple – I only support a few primitives as of right now. I have an interface for Types that all primitives implement:

``````public interface Type {
boolean instanceOf(Type other);
Value getDefaultValue();
}
``````

so integers for instance look something like this:

``````public class IntType implements Type {
public boolean instanceOf(Type other) { return this.getClass().equals(other.getClass()); }
public IntValue getDefaultValue() { return new IntValue(0); }
public String toString() { return "int"; }
}
``````

Extending the code in an OO direction would imply the following:

the ability to declare new types (classes) => I’ll probably need a new dictionary-like structure for types

classes have member variables and methods => whatever the new representation for types is, it’ll need to have a list of variables and methods (don’t think I’ll bother with access specifiers yet)

a way to define subtyping relationships between classes => most likely a function that tells us whether B is a subtype of A for any A, B

parameterizing means implementing some sort of symbolic types that are replaced at run time just like with variables

And then all this stuff needs to be implemented in a way that can be type checked at compile time.

So if anyone has any resources that cover this sort of stuff please let me know.

## Assign ID to menu items in default language

I’m using the next code in functions.php in order to generate an id for the menu elements with the title of the menu page item.

My site is multilanguage so it changes the id depending on the language you’re browsing on.
This is the code I’m using and what I’m looking for is to assign an unique id for every language generated by the default language title

``````function custom_nav_menu_item_id(\$id, \$item) {
\$title = sanitize_title_with_dashes(\$item->title);
return \$title;
}

``````

## Prove language is not Turing-recognizable using contradiction

Show that the language L = {<M>| M is a TM and does not accept <M>} is not Turing-recognizable.

Note: Prove by contradiction. No need for reduction.

This is the problem I am trying to solve. I’m confused on how to do this without using reduction.

## First order logic formula of given language

Consider a language over {a, b}, $$L = b(a^* bb)^*$$ any first order formula can not express this language. Because this require counting of letter/word which is not possible with first order logic. Is this reasoning correct?

## unity – UnityEditor.SyncVS.SyncSolution putting wrong language version in generated files

I’m working on getting our Unity projects building in bamboo for our build server. We have a cli step that runs through the Unity commands for creating a build. It works fine on several projects, but for some reason this particular project I’m working on I’m getting an error that states I need to use c# version 7.2 or newer. If I log in to the build server and open the .csproj files in notepad and check the language version, it’s setting them to 7.0. However, if I deactivate the cli step so that the build job only clones the project, then manually log in and open unity and go through the process so it generates the .csproj files, then check them, the language version is set to 8.0. The project works fine locally on my own pc. And it works when setup manually on the build server pc, but when ran through the cli step, it generates them at an earlier c# version. This leads me to believe there is a problem with the UnityEditor.SyncVS.SyncSolution step in my commands. I’m just not sure what it could be, or why it’s behaving differently for this project as opposed to other projects that are using the same code base (where the problem is said to occur), same Unity version, same build server, etc. Anyone else experience this issue or have any thoughts on a solution?

## automata – Finding the language of a given CFG

I’m trying to find the language of the given CFG
$$S to aB mid bA mid a \ A to bAA mid aS \ B to aBB mid bS$$
I understand that the productions $$S to aB, S to bA, A to aS$$ and $$B to bS$$, correspond to the language where the number of a’s are equal to the number of b’s, but how do I interpret the other productions? Any help is appreciated!

## hreflang – Does Google show the pages we have in the local language by IP address?

hreflang – Does Google show the pages we have in the local language by IP address? – Webmasters Stack Exchange

## Undead don’t have a dedicated language

In general, they speak languages they knew in life. Here’s a couple of examples:

### Zombie

Languages understands the languages it knew in life but can’t speak

Languages the languages it knew in life

### Skeleton

Languages Understands all languages it knew in life but can’t speak

There are plane-specific undead like Death Knight which speaks the corresponding language (Abyssal in this case). Most undead usually understand or speak Common.

Since Favored Enemy still has to grant additional language proficiency, the player is usually free to choose any non-secret language people in the game world speak. The exact list depends on the setting and your DM.

See also If a Ranger chooses “fey” as their Favored Enemy, what languages can they choose from?

## computability – Algorithmically find a formal grammar for a recursively enumerable formal language

The algorithmic problem is as follows.

The input is the source code of a program accepting an integer as input and outputting a finite binary sequence. This program defines a recursively enumerable formal language.

The output is a formal grammar generating this language.

How can we solve this problem?