## algorithms – How to get a piece of the Pie? Theoretical Plate Stacking Problem

This is just a theoretical problem that I found in the wild and want to know your solution.

A stack of plates is made between you a cousin and a few others.

Every (4 to 7) many random hours the plate on the top of the stack is given a slice of pie yet at this point you can instantly replace the pie with a new empty plate the goal of the exercise is having your plate on top the longest to get the most pie.

Cousin 1: Watches when you have placed your plate on top of the pile and then after a random interval of time about long enough to avoid being called out for being unfair lets say 45min-1h places his plate on top of yours.

Cousin 2: Watches when Cousin 1s plate is on top of his and then waits the same interval to avoid being unfair.

myIdea:
The goal of the problem is to get more pie the most pie. And the only way that I see it as possible is to cheat more then your cousins.

IF you put down a plate then wait the minimum random interval after cousin 2 has placed his plate then you are likely only getting an equal share of time and probability of getting pie.

Cheating method: You do the same thing as both cousins but you time the the average time between cousins 1 and 2 placing their plates. Using this average of time you take half the time and the same standard deviation. I then post after cousin 2 in this time period which gives me an equal amount of pie as cousin 1 but more then cousin 2.

Is there any way to get more pie then both cousins?

## c++ – Theoretical Analysis of Fibonacci series

Hello i am starting to learn c++. I am having trouble with time and complexity analysis. I have done fibonacci series in a recursive way. I think it is O(n^2). Can you find out the time analysis ? If possible, could you elaborate it?

``````#include<iostream>
using namespace std;

void fibonacci(int n,int n1,int n2)
{
if(n==0)
{
cout<<endl<<n1;
return;
}
else if(n==1)
{
cout<<endl<<n2;
return;
}
fibonacci(n-1,n2,n1+n2);
return;
}

int main()
{
int n;
cout<<"Enter the number:"<<endl;
cin>>n;
fibonacci(n,0,1);
return 0;
}
``````

## computability – What is the theoretical result of flattening a list containing only itself?

Consider the following python code

``````X = (None)
X(0) = X
``````

This has many fun properties such as

``````X(0) == X
``````

and

``````X(0)(0)(0)(0)(0)(0)(0)(0) == X
``````

I understand how this works from a practical standpoint, as it’s all just the same pointer.

Now, when flattening a list, we tend to convert things from

``````((1, 2, 3), ((4, 5), (6, 7)), 8, 9)
``````

to

``````(1, 2, 3, 4, 5, 6, 7, 8, 9)
``````

In this case, I am considering flattening to be reducing a multi-dimensional list down to a single list of only non-list elements.

In practice, flattening this list would be impossible, as it would create an infinite loop.

This may be more mathematical in nature, but I’m unsure how to put it in mathematical terms. Suppose we could flatten this list, would the result simply be the empty list?

For context, I initially got this idea by considering the list

``````X = ((), ())
X(0) = X
``````

It is clear to see that at each pass of flattening, the empty list that is the second element simply disappears. This lead me to think that the overall result, may be the empty list.

Could it be possible that flattening this list would theoretically produce an infinitely long list of the list itself, as in

``````X == (X, X, X, X, X, X, ..., X)
``````

This is purely a fun thought exercise. Any insight and discussion on this would be appreciated.

P.S. Although I’m looking for an answer in plain terms, if anyone is more mathematically inclined, I would be interested to see how this problem could be formulated in some sort of set notation. Please feel free to point me to a relevant math exchange thread as well.

P.P.S. I would also be interested in a solid proof (not formal) to go along with the answer.

## Forgot the name of the tool for theoretical measurement of shape interactions

A few years ago I used a tool that could theoretically measure the time to fill out a form. The way it works is that you e.g. a screenshot and mark what a label, what an input field, an expected input, etc. is. The tool then calculates the time required for eye movements (reading the label, identification field, etc.), the time to move the hand from the mouse to the keyboard, the time for typing, etc.

I can't find the tool anywhere and I don't remember what it was called.

Does anyone know the tool? Any help would be appreciated.

## Statistics – Are there known results in the literature on empirical and theoretical minima for probability estimates?

I am working on a problem in my research where I want to estimate a parameter $$theta$$ from samples $$x_i, z_i, , {1 leq i leq n }$$, For each $$x_i$$we also observe the probability $$z_i$$, Actually, $$l$$ is the probability function, so $$l (x_i, theta)$$ gives us the true probability of seeing $$x_i$$ if our model as $$theta$$ as the underlying parameter.

To let $$has { theta} _n = arg min _ { theta} sum_ {i = 1} ^ n (l (x_i, theta) -z_i) ^ 2$$, our estimate of $$theta$$ from our quadratic error samples (we could use another error if necessary).

Are there any results in the literature that set limits? $$left | hat { theta} _n- theta right |$$? Or better yet, some results on the behavior of $$has { theta} _n$$? This is not an M-Estimator, so it's not as easy a problem as I originally thought …

## Extension of series – number theoretical notation in Wolfram Cloud for iOS

I use Wolfram Cloud Mathematica and I want to write an equation with the mathematical symbols for `Sum` (like a grand sigma but not a Greek letter) and `Product` (Like capital letters, but not the Greek letter), whereby the index is written only under the symbol and not above the symbol in the number-theoretical style.

For example,

$$prod _ {a leq n} f (a)$$

The next thing I can achieve in the Wolfram Cloud with the super limited virtual keyboard from IOS13 is

``````Product(f(a),{a<=n,n})//TraditionalForm
``````

But that's not exactly what I want because: (1) I don't want it `n` about `Product` Symbol; (2) I want the result in standard Wolfram Language form, not in italics `TraditionalForm` This cannot be edited in the cloud app.

If I had a physical keyboard, I would type Esc-prod-Esc, then Ctrl-4 to write the index under the symbol, and then Ctrl-Space to write the main expression.

This is not possible with the iOS virtual keyboard. The & # 39; select & # 39; function that I could theoretically use to remove that `n` above the product icon just doesn't work in Wolfram Cloud for IOS: not only is this one item selected, and even if it is, nothing can be deleted.

Any suggestions?

## Research – Why is it difficult for theoretical computer scientists to find funding?

Of Fund a revolution: Government support for computer research.

Funding for theoretical computer science has decreased as a percentage of the NSF's computer research budget (it was 7 percent of the 1996 budget, down from 20 percent in 1973).

I have heard quite a few times that theoretical computer scientists are short of money. I do not understand why such research is not prioritized when the theoretical CS includes work that is relevant to all computer disciplines. Aren't the effects of TCS research clear or immediate enough to attract investment?

## Career – career of a theoretical mathematician?

I am currently studying mathematics (Bachelor).
I have reached a point where I can choose which parts of the math I want to continue learning. It currently looks like I'm mainly going to do theoretical things like topology, algebra, or differential geometry.
Apart from the typical university career, what options would I have if I had completed my master’s degree, provided that I continue to do theoretical mathematics?
Greetings from Germany 🙂

## CRC (theoretical) – did not understand the highlighted part given below

Original: -http: //www.cs.jhu.edu/~scheideler/courses/600.344_S02/CRC.html

…….. Well, at least it would be nice to make sure the CRC did that and added a single parity bit. That is, we want to avoid using G (x), which does not guarantee that all error cases that change an odd number of bits will be detected.

-> If a received message T # (x) contains an odd number of inverted bits, then E (x)
must contain an odd number of terms with coefficients equal to 1.
-> Consequently, E (1) must be equal to 1 (since x = 1 xi = 1 for all i).
-> If G (x) is a factor of E (x) then G (1) should also be 1.
-> So if we make sure that G (1) = 0, we can conclude that G (x) does not divide
any E (x) corresponding to an odd number of error bits. In this case, a CRC
G (x) is used to detect an odd number of errors.
-> As long as G (x) has a factor of the form xi + 1, G (1) equals 0. So, it
It's not hard to find such a polynomial. ……….

## Is there a theoretical validation or explanation as to why KDTree slows down as the dimensionality gets higher?

This article and article indicate that KDTree slows as dimensionality becomes higher.

Is there a theoretical validation or explanation as to why KDTree slows down as the dimensionality gets higher?