## 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.

## DFA for language

I want to give a DFA for the language which contains the words X ∈ {0,1,2}* for which the number of 0’s + number of 1’s is even AND the number of 1’s + the number of 2’s is odd.

I tried many automatons so far but I haven’t succeeded with any.

## 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.

## automata – First order logic formula of given language

Consider a language over {a, b} starting with b, having odd number of b and even number of bb in a word belongs to a language. 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?

## 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

## ranger – What language do undead speak?

I really need help with creating my ranger. For my “favored enemy,” I chose undead, but I don’t know what language they speak (if they speak one at all). Do I just look for a single undead (e.g. a Ghoul speaks Common) and say that is what all undead speak? Please help me.

## 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?