Recursively plotting specific elements in a list of lists

I am trying to build band structures and am looking to generate a general code that will work regardless of my list size. Here is what I am trying to do: say I have a list like

list = {{0.0, 1, 2, 3}, {0.1, 4, 5, 6}, {0.2, 7, 8, 9}, {0.3, 10, 11, 12}}; 

and I want to plot the nth element of each list against the first element of each list. How can I tell Mathematica to automatically produce a set of lists to plot like shown below

k = {0.0, 0.1, 0.2, 0.3}; band1 = {1, 4, 7, 10}; band2 = {2, 5, 8, 11}; band3 = {3, 6, 9, 12}; Show[ListLinePlot[k, band1], ListLinePlot[k, band2], ListLinePlot[k, band3]] 

Doing it manually one band at a time is possible but a waste of time when I have n=36+ bands. Any help would be much appreciated!

Does the heap property in the definition of binary heaps apply recursively?

The definition of binary heaps says that it should be a complete binary tree and it should follow the heap property where according to the heap property, the key stored in each node is either greater than or equal to or less than or equal to the keys in the node’s children.

Binary tree

In the above tree, the node with value 70 is greater than its parent 10 breaking the heap property. However, 70 is also greater than 40 and lies in the subtree of 40. Will we say that the heap property is also breaking at 40, even though 40 is greater than its two children 10 and 2?

Union of a decidable language with complement of a recursively enumerable language

So the question wants to prove or disprove that ‘a Union of a decidable/recursive(i understand them to be the same) language and the complement of a recursively enumerable language is a recursive/decidable language.’

I think that it is false and the union is recursively enumerable. Since if such a Turing Machine exists that accepts the union, then it must be powerful enough to accept words of the union from the RE language, which would then make it automatically powerful enough to accept the words from the recursive / decidable language.

Is this reasoning right, or am I making a logical mistake somewhere?

Turing machine and Recursively Enumerable Language

Whether a TM accepts Recursively enumerable language. Decidable or not?

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


According to my understanding the first one should be decidable right, as it is $ TRIVIAL$ property of TM to accept $ REL$

and the second one should be partially decidable right? as $ Membership$ problem for recursively enumerable language is undecidable, so can we conclude from it that our question whether a turing machine accepts $ a$ RE language is also undecidable?

Using undecidability of the halting problem to show that the function also calls recursively in $2i$ if $i$ halts

Let $ \{P_i|i = 1, 2, . . .\}$ be list of all computable functions. For example, $ P_i$ might be the $ i$ th program and $ P_i(x)$ would be the output given by that program on input $ x$ .

Suppose that there is an algorithm to decide whether or not a given procedure calls itself.

Consider the procedure $ FUNC(x)$ :

PROCEDURE FUNC (INTEGER X);       BEGIN INTEGER 1, J;       I ← X DIV 2;       J ← X MOD 2;       IF J = 0 AND Pi(i) halts THEN FUNC (X + l); END 

How do I use Undecidability to show that $ FUNC(2 ∗ i)$ calls $ FUNC$ recursively if and only if $ P_i(i)$ halts?

Proof that $(L_{all})^C$ is not recursively enumerable

The problem:

We have the language $ L_{all} = \{\operatorname{Kod}(M) | M \text{ is a turing machine and } L(M) = \Sigma ^*\}$

Hence, $ L_{all}$ is the set of all encoded Turing machines (the $ \operatorname{Kod}()$ is the encoding function) which accept all words as input.

One needs to show that $ (L_{all})^C$ , the complement of $ L_{all}$ is not in $ \mathcal{L}_{RE}$ , that means it is not recursively enumerable.

By definition, in $ (L_{all})^C$ we have all strings which do not represent correctly encoded Turing machines as well as encoded Turing machines which reject at least one word from the alphabet.

What have I tried so far:

  • One idea was to use the diagonalization argument that can be used to prove that $ L_{diag}$ , the diagonal language is not recursively enumerable. This however doesn’t seem to work.
  • I tried to prove that the statement is wrong (i.e. $ (L_{all})^C)$ is recursively enumerable: The proof would more or less go like this (not very formal): Let $ A$ be a Turing machine deciding if $ x \in (L_{all})^C$ . We first check if $ A$ ‘s input is a correctly encoded Turing machine ($ x = \operatorname{Kod}(M)$ ), if not we reject. If it is, we associate every word from $ \Sigma^*$ with a prime $ p$ and then use this to simulate all words on $ M$ at once, (in the $ p^i$ th step of $ A$ we simulate the $ i$ th step of $ M$ on the $ p$ th word). This is where my counter proof fails. Since there are uncountably infinitely many words in $ \Sigma^*$ and only countably infinitely many primes. However I do not see a way how I can use this fact to prove the original statement.

Any suggestion or hints would be greatly appreciated since I am genuinely interested how one approaches such a proof.

Full disclosure This was a bonus question on an old exam (not connected to homework) and I am curious how one can prove this, especially since it seems to be somewhat counter intuitive.