numerics – How to use parallel computation in mathematica for numerical Integration

I have a multi dimensional integral and I need to integrate it numerically and than plot it over an extra variable for zeta = 0.5.

g(kx_, ky_, k1x_, k1y_, qx_, qy_, zeta_, zz_) := (1/((1 + Exp(-Sqrt(k1x^2 + k1y^2) + zeta*k1x*Cos(zz) + 
         zeta*k1y*Sin(zz)))*(1 + 
       Exp(-Sqrt(kx^2 + ky^2) + zeta*kx*Cos(zz) + 
         zeta*ky*Sin(zz)))*(1 + 
       Exp(Sqrt((kx + qx)^2 + (ky + qy)^2) + zeta*(kx + qx)*Cos(zz) + 
          zeta*(ky + qy)*Sin(zz))*(1 + 
          Exp(Sqrt((k1x - qx)^2 + (k1y - qy)^2) + 
            zeta*(k1x - qx)*Cos(zz) + zeta*(k1y - qy)*Sin(zz))))));
  PolarPlot(NIntegrate(g(kx, ky, k1x, k1y, qx, qy, 0.5, zz), {kx, -1, 1}, {ky, -1, 
     1}, {k1x, -1, 1}, {k1y, -1, 1}, {qx, -1, 1}, {qy, -1, 1}), {zz, 
    0, 2 Pi})

my problem is that, it take many hours (more than 10 hours) without answer. my solution was to calculate the integral for some discrete set of angles, and than plot it, but I am searching for more better way.
based on searching in site,

Parallelizing Numerical Integration in Mathematica

it may be possible to use parallel computation to plot it. my knowledge in Mathematica is limited and I couldn’t understand what the role of index “i” is in that link.
Would someone please tell me how can I use all cores to decrease the time of calculation.

thanks

differential equations – GreenFunction Computation for perturbed Laplacian

I am happy computing the Green function for the Laplacian

Gsol := GreenFunction[{-Laplacian[u[x, y], {x, y}]}, u[x, y], {x, y} [Element] FullRegion[2], {m, n}]

it gives an analytical solution – which is great.

However, if I slightly perturb my operator

Gsol := GreenFunction[{D[u[x, y], {x, 2}] + 2 D[u[x, y], {y, 2}]}, u[x, y], {x, y} [Element] FullRegion[2], {m, n}]

where I have simply put a 2 infront of the second derivative.

Mathematica is no longer able to provide an analytical or even a numerical approximation to the Green function for this operator. If GreenFunction is not able to handle such an operator, is there another method I can use to do this?

Thanks!!

Computation expenses of syncing / getting a full node up and running, hardware considerations

Since a full node needs to process the entire block chain from the beginning and it keeps getting bigger this requires more computing resources over time. Does it seem more likely in the near future that this will continue to be processed on a general purpose CPU or will the computation be hardware accelerated through specialized hardware ? Will the computational complexity outpace CPU improvements ? Is hardware acceleration possible for this task?

finite automata – Theory of Computation

While converting each of the final states of F to non-final states of F to final states =, FA thus obtained will reject every string belonging to Land will accept every string, defined over sigma, not belonging to L is called
A] Trnsition Graph of L
B] Regular expression of L
C]Complement of L
D] Finite Automata of L

I think option C is correct.
Please someone correct me if I am wrong.

encryption – Multi-party computation: how to avoid a single point of weakness?

I’m trying to understand how to eliminate a single point of weakness given the problems MPC claims to solve.

Take a simple example where some secret is split between servers B and C. If either B or C are breached the whole key cannot be known nor derived.

However, server A makes a request to B and C. They liaise together in order for server A to end up with the complete secret.

Surely all an attacker needs to do is breach server A to initiate the process from there to retrieve the secret, regardless of whether the computation happened in other places. Or is there some step I’m missing?

context free – CYK algorithm in theory of computation

For any context free grammar, there is a parser that takes atmost n^3 time to parse a string of length n.

Doubt: I marked it false in a national level exam.I think it should be any null-free context free grammar and not any cfg because we first have to convert cfg to cnf but only null free cfg can be converted to cnf.

Is this statement correct?

differential equations – Overflow during computation

The following code display the Predictor-Corrector approach to solve the four dimensional Fractional-Order Delay Differential system,

The below code works fine for some values of $tau$ but it gives an overflow error message for other values of $tau$ for example, when $tau=0.10$ and n=4500(smax=300 in the code) I get error message which says that an overflow occurred during computation.

a1 = 2.1; b1 = 0.01;
c1 = 2.6;
Subscript(m, 1) = 8.4;
Subscript(m, 2) = 6.4;
Subscript(m, 3) = 2.2;
f(t_, x_, y_, z_, w_) := x*(y - a1) + (Subscript(m, 1)* w) + z;
g(t_, x_, y_, z_, w_) := -(b1*y) + (Subscript(m, 2)* w) - x^2 + 1;
d(t_, x_, y_, z_, w_) := -(c1*z) + (Subscript(m, 3)* w) - x;
q(t_, x_, y_, z_, w_) := -x*y*z;
(Alpha) = 0.93;
h = 0.01;
t(0) = 0;
x0 = 2;
y0 = 0;
z0 = -0.2;
w0 = 0.4;
tau = 0.10; nn = Round(tau/h); smax = 300; n = nn*smax;
Do(x(i) = x0; y(i) = y0; z(i) = z0; w(i) = w0;, {i, -nn, 0});
For(k = 1, k <= n, k++, b(k) = k^(Alpha) - (k - 1)^(Alpha); 
  a(k) = -(2*k^((Alpha) + 1)) + (k - 1)^((Alpha) + 1) + (k + 
       1)^((Alpha) + 1););
Do(Do(x1(i) = x(i - nn); y1(i) = y(i - nn);, {i, 0, s*nn}); 
 For(j = (s - 1)*nn + 1, j <= s*nn, j++, t(j) = j*h; 
  p(j) = (h^(Alpha)*
       Sum(b(j - A)*f(A*h, x(A), y1(A), z(A), w(A)), {A, 0, j - 1}))/
     Gamma((Alpha) + 1) + x(0);
  l(j) = (h^(Alpha)*
       Sum(b(j - B)*g(B*h, x1(B), y(B), z(B), w(B)), {B, 0, j - 1}))/
     Gamma((Alpha) + 1) + y(0); 
  r(j) = (h^(Alpha)*
       Sum(b(j - C)*d(C*h, x1(C), y(C), z(C), w(C)), {C, 0, j - 1}))/
     Gamma((Alpha) + 1) + z(0);
  o(j) = (h^(Alpha)*
       Sum(b(j - H)*q(H*h, x(H), y(H), z(H), w(H)), {H, 0, j - 1}))/
     Gamma((Alpha) + 1) + w(0);
  x(j) = (h^(Alpha)*(Sum(
          a(j - K)*f(h*K, x(K), y1(K), z(K), w(K)), {K, 1, j - 1}) + 
         f(h*j, p(j), l(j), r(j), 
          o(j)) + ((j - 1)^((Alpha) + 1) - (-(Alpha) + j - 1)*
             j^(Alpha))*f(0, x(0), y(0), z(0), w(0))))/
     Gamma((Alpha) + 2) + x(0);
  y(j) = (h^(Alpha)*(Sum(
          a(j - F)*g(F*h, x1(F), y(F), z(F), w(F)), {F, 1, j - 1}) + 
         g(h*j, p(j), l(j), r(j), 
          o(j)) + ((j - 1)^((Alpha) + 1) - (-(Alpha) + j - 1)*
             j^(Alpha))*g(0, x(0), y(0), z(0), w(0))))/
     Gamma((Alpha) + 2) + y(0);
  z(j) = (h^(Alpha)*(Sum(
          a(j - G)*d(G*h, x1(G), y(G), z(G), w(G)), {G, 1, j - 1}) + 
         d(h*j, p(j), l(j), r(j), 
          
          o(j)) + ((j - 1)^((Alpha) + 1) - (-(Alpha) + j - 1)*
             j^(Alpha))*d(0, x(0), y(0), z(0), w(0))))/
     Gamma((Alpha) + 2) + z(0);
  w(j) = (h^(Alpha)*(Sum(
          a(j - R)*q(R*h, x1(R), y(R), z(R), w(R)), {R, 1, j - 1}) + 
         q(h*j, p(j), l(j), r(j), 
          o(j)) + ((j - 1)^((Alpha) + 1) - (-(Alpha) + j - 1)*
             j^(Alpha))*q(0, x(0), y(0), z(0), w(0))))/
     Gamma((Alpha) + 2) + w(0););, {s, 1, smax})
lst = Table({t(i), x(i)}, {i, n});
lst1 = Table({x(i), y(i), z(i)}, {i, n});
ListLinePlot(lst, PlotRange -> Full, 
  Frame -> True, PlotLabel -> "(Alpha)=0.93,(Tau)=0.10", 
 FrameStyle -> Black, 
  FrameLabel -> {t, x}, LabelStyle -> Directive(Blue, Bold), 
  PlotStyle -> Purple)
 ListPointPlot3D(lst1, PlotRange -> Full, 
  AxesLabel -> {x, y, z}, PlotLabel -> "(Alpha)=0.93,(Tau)=0.10", 
  LabelStyle -> Directive(Black, Bold, FontFamily -> "Helvetica"), 
  TicksStyle -> Black, PlotStyle -> Purple)

Could anyone please solve this issue.

graphs – “Equality” problem in distributed computation

I recently started learning about distributed computation on graphs (not to be confused with parallel computation with threads).

I have seen as a side note in a few lower bound proofs, a reference that says the proof could be shorter using the “linear lower bound theorem for the Equality problem”, but I couldn’t find the statement or proof of this theorem.

I would like to know a few things:

  • What exactly is this “Equality” problem? (how is it formulated?)
  • Where can I find a proof for its lower bound? (or if the proof is short enough, I would be glad if you could add it here)

Thanks!