Algorithms – Find a sequence of calculable functions whose computational time in the WC will somehow become infinite

Define $ T: mathbb {N} times mathbb {N} rightarrow mathbb {N} $ by:

$ T (k, n) = 2 ^ {T (k-1, n)} $

$ T (0, n) = 1 $

$ T (1, n) = 2 ^ n $

$ T (2, n) = 2 ^ {2 ^ n} $

And indicate the toilet time of calculating $ f (n) $ as $ WC (f (n)) $

Can we find calculable functions? $ f_i: mathbb {N} rightarrow mathbb {N} $ count on t $ f_i (n) $ takes $ Omega (T (i, n)) $ WC and so on every other calculable function $ f equiv f_i $ $ lim_ {n rightarrow infty} frac {WC (f_i (n))} {WC (f (n))} neq 0 $?

In a way, I'm trying to find a concrete example of functions that take at least X time to calculate where X (asymptotically) can be as big as we want.

I thought maybe $ f_i (n) = $ the $ T (i, n) $& # 39; th digit from $ pi $

but not quite sure if this meets the second condition

Computational Geometry – Divide the regular n polygon into k parts

I just came across the following problem:

$ L: $ For positive integers $ n geq 3, k geq1 $, decide if it is possible one $ n $Polygon in $ k $ equally shaped and equal pieces, each piece should be connected in itself.

For some $ n $ it is trivial, e.g. $ forall k: (4, k) in L $, $ forall k | 2n: (n, k) in L. $ But for some others, it seems hard to decide.

By the promise, each input is either off $ L $ Or you can divide by a finite number of straight lines (segments). If these lines all run through a rational coefficient pair of points in the plane, you can check the solution in poly time. But personally, I find this assumption unconvincing and have no other idea.

Is there an algorithmic strategy to decide $ L $or should it be too hard to solve?

—to edit—

Most lines can not be parameterized into rational parameters by selection $ alpha_1, alpha_2, alpha_3, alpha_4 $, $ forall i neq j: mathbb {Q} ( alpha_i) not subseteq mathbb {Q} ( alpha_j) $ and assign the continuous line $ ( alpha_1, alpha_2), ( alpha_3, alpha_4) $It will not go through a rational point.

Computational Geometry – Number of mesh cells for Voronoi mesh too low

I tried to solve that question out of interest, and thought I might create a Voronoi mesh, cut it into a circle, and color the mesh cells. But if I ask VoronoiMesh Create cells for too many points MeshCellCount[mesh, 2] (or equivalent Length @ MeshCells[mesh]) returns a number less than the number of points initially specified.

I tried to use different functions to generate the points around which the cells should be built, using both exact and real numbers and checking out the documentation VoronoiMesh and MeshRegionbut I'm still not sure what causes that. Are my points just too close together? VoronoiMesh uniquely determine a cell for some of them?

The simplest code that reproduces this is:

MeshCellCount[
  VoronoiMesh[
    Flatten[Quiet[Thread[CirclePoints[Range[100], 360]]], 1]],
2]

This should return 36,000, as there are 100 radial points and 360 azimuthal points, instead 35,985. For this code it seems to start when there are about 32,000 elements. When the radial point points inwards offer set to 87, I get the expected result. If the radial points are set to 88 (with the same 360 ​​azimuthal points), I get an unexpected result. For all smaller numbers, it seems to work as expected.

If I use the following code to determine the number of cells, for some reason, this discrepancy will be displayed even with a smaller number of cells.

to generate[i_] : =
table[
   {r Sin[[Theta]], r Cos[[Theta]]},
{[Theta]0, 359 [Pi]/ 180, [Pi]/ 180}
{r, 1/2, (i - 1) + 1/2}
]66 * 360 - MeshCellCount[VoronoiMesh[Flatten[generate[66], 1]], 2]

The result of this code is 2, assuming it is zero for all passed values to generate,

Does anyone know what I am doing wrong or is there a workaround? Or I just ask too much VoronoiMesh?

Cryptography – What is the current computational speed when performing elliptic curve multiplication?

Hello, I was just looking for some information on how long it would take to crack a private key with a brute force approach in Bitcoin, and I could not find a very good answer on how long it takes to check Whether a particular key (or every single key) is key would work.

Basically, so I'm wondering how long the elliptic curve multiplication process would take to check if a single private key works for a particular public key (on average), thanks 🙂

Computational models – RAM and Turing machines: temporal complexity of the simulation

My RAM machine is very simple:

  • it has $ k $ Tapes, an input tape and a special one control tape

  • it has an infinite memory (called Array) $ A $) which can be accessed at random

  • the control tape is read when the machine enters the promotion $ q_ {control} $ State

  • The control strip always contains the symbol $ R $ or $ W $ Specify the memory operation (read or write) and a binary number that represents the address of the cell in $ A $

  • in case of $ W $ The machine must also have a symbol of the alphabet on the keyboard control tape stored in the selected cell $ A $

  • in case of $ R $ The machine puts the read on the control tape once again

  • Otherwise, it is very similar to a Turing machine ($ k $ Labor bands, states)

I would like to show that this calculation can be simulated on a Turing machine with a maximum of quadratic effort. (If function $ f $ is calculable on RAM $ T (n) $is it on the Turing machine in $ T (n) ^ 2 $,


My approach is to take advantage of the fact that the RAM machine can be used at most $ T (n) $ Cells in $ A $, I could turn it into a Turing machine tape that would be processed sequentially for each "RAM" call of the RAM engine. This would of course lead to $ T (n) ^ 2 $ temporal complexity.

However, I would also need a tape to map "RAM addresses" to the appropriate addresses (location) on my fake tape. How else would I remember where I stored the symbol that corresponds to the address "11010101" when it needs to be read? But the catch is: the address can be at most $ T (n) $ long, that brings us immediately $ T (n) ^ 3 $ temporal complexity.

How to solve it?

Fulfillment – Please help me with Exercise 6.3.3 by László Lovász Lecture Notes on Computational Complexity

Thank you for providing a response to the Computer Science Stack Exchange!

  • Please be sure answer the question, Provide details and share your research!

But avoid

  • Ask for help, clarification or answers to other answers.
  • Make statements based on opinions; secure them with references or personal experiences.

Use MathJax to format equations. Mathjax reference.

For more information, see our tips for writing great answers.

What are some of the main results of the theory "implicit computational complexity"?

I have just got to know the implicit computational complexity theory. It seems very interesting. I would like to know more about it.

To get an overview of the results of the field, what are the most important results? Or what are the most important papers that I should look at to understand the most important contributions?

Matrices – Computational complexity in finding determinants

What is the computational complexity to find the determinant of a matrix in this form?
begin {bmatrix}
x_ {1,1} & x_ {1,2} & x_ {1,3} & dots & x_ {1, n-1} & x_ {1, n} \
x_ {2,1} & x_ {2,2} & x_ {2,3} & dots & x_ {2, n-1} & x_ {2, n} \
0 & x_ {3,2} & x_ {3,3} & dots & x_ {3, n-1} & x_ {3, n} \
0 & 0 & x_ {4,3} & dots & x_ {4, n-1} & x_ {4, n} \
vdots & vdots & vdots & ddots & vdots \
0 & 0 & 0 & dots & x_ {n, n-1} & x_ {5, n}
end {bmatrix}

This is usually the case in regular matrices $ O (n ^ 3) $ However, I think it would be much easier to use row reduction to get a triangular matrix. To be clear, the matrix looks like an upper triangular matrix, except that it is offset by one diagonal. All entries in the matrix are also positive integers.

Set theory – What is the computational complexity of equivalence up to a critical point in a generator-free self-distributing algebra?

Suppose there is a rank cardinal. Then let $ R $ Let the relationship be on the set of terms in the language of self-distributing algebras (or LD monoids) on a generator we set
$ R (s, t) $ if $ mathrm {critical} (s (j)) leq mathrm {crit.} (t (j)) $, To let $ E $ let the relation be where $ E (r, s, t) $ exactly when $ r (j) equiv. ^ { mathrm {crit} (t (j))} s (j) $, To let $ T $ be the ternary relationship, where $ T (r, s, t) $ if and only if there are elementary embeddings $ j_ {1}, …, j_ {n} $ With $$ r (j) * j_ {1} * … * j_ {n} equiv. ^ {t (j)} s (j) $$
but where
$$ mathrm {crit} (r (j) * j_ {1} * … * j_ {m}) < mathrm {krit} (t (j)) $$
to the $ 0 leq m <n $,

Under the existence of a rank-in-rank cardinal's relationships $ R, E, T $ are all predictable. In addition, the relationships $ R, E, T $ can be defined and calculated in a purely algebraic context in the form of Laver tables, assuming that the inverse boundary of classical Laver tables applies $ varprojlim_ {n} A_ {n} $ contains free subalgebras in a generator, but this assumption has no known proof that does not use strong cardinal assumptions.

  1. Is there a reasonable way to define $ R, E, T $ that does not rely on results proven with great cardinals?

  2. What is the computational complexity of the functions? $ R, E, T $?

  3. Has the algebra $ langle j rangle / equiv ^ {t (j)} $ have a normal form in the following sense? Is there a reasonably efficient family of functions?
    $ P_ {t}: X rightarrow omega $ from where $ t $ ranges beyond the terms in the language of self-distributing algebras (or LD monoids), so that $ P_ {t} (r) = P_ {t} (s) $ then and only if $ r (j) equiv ^ {t (j)} s (j) $?

  4. If the algebra $ langle j rangle / equiv ^ {t (j)} $ has an efficiently calculable normal form (or at least the elements in $ langle j rangle / equiv ^ {t (j)} $ have strong invariants), then the algebra
    $ langle j rangle / equiv ^ {t (j)} $ to be used as a platform for the authentication scheme of Dehornoy or the key exchange of Kalka-Teicher? What about the Baby Ko Lee key exchange?

The Baby Ko Lee key exchange is the next key exchange. Suppose that $ (X, circ) $ is a semigroup and $ x in X $, Alice and Bob create mutually agreed secret information by communicating over a public channel with the following steps:

I. Alice picks $ a in X $ and send $ r = a circ x $ to Bob.

ii. Bob chooses $ b in X $ and send $ s = x circ b $ to Alice

To let $ K = a circ x circ b $,

iii. Alice can count $ K $ since $ K = a circ s $ and Alice knows $ a, s $,

iv. Bob can count $ K $ since $ K = r circ b $,

$ K $ is a common piece of information between Alice and Bob. One could generalize the baby-ko-lee key exchange to a key exchange for LD monoids or LD systems.