cv.complex variables – A question about the Riemann zeta function

Yesterday, a very talented and passionate young student from South Africa asked me the following question about Riemann's zeta function. $ zeta (s) $. He says he "thinks" he knows the answer, but he just wants to hear my views. However, I am not a number theorist, therefore I was unable to answer you. So below is the question:

Consider the Riemann zeta function $ zeta (s) $, and let $ alpha $ be the supremum of the real parts of your zeros. Leave $ mu $ denotes the Möbius function. Define $ S (x) = sum_ {n leq x} frac { mu (n) log n} {n} $.

Note that

$$ Big ( frac {1} { zeta (s + 1)} Big) & # 39; = -s int_ {1} ^ { infty} S (x) x ^ {- s-1 } mathrm {d} x $$ for $ Re (s)> alpha-1 $, where the cousin denotes differentiation. It's known that $ S (x) = – 1 + or (1) $, therefore, the previous integral converges if and only if $ Re (s)> 0 $. What does this tell us, in any case, about the value of $ alpha $ ?

P.S: I could not verify the previous identity, nor could I verify the "known" result that $ S (x) = -1 + or (1) $.

macos: How to disable long caps lock function on mac?

There is a function on the Mac keyboard, when the caps lock is pressed for a long time (1 second), the light turns on and changes the input method behavior, what I want is to disable this function totally, even press the lock capitalized for a long time, the light does not turn on and does not change other behavior, how to do this?

Is this arithmetic function strictly positive and without limits?

As requested by Mathphile, since efforts have been made but complete solutions have not been found for some questions that arose when this question was asked in MSE, and since we believe that here the question is more likely to be fully resolved, I reproduce it here in a different version. style.

The function $$ r (b) = sum_ {k = 1} ^ { lfloor frac {b-1} {2} rfloor} (b bmod {k}) $$ It is well known for elementary number theory and has some well known properties.

Mathphile considered the function $$ z (m) = sum_ {n = 1} ^ {m} (- 1) ^ {r (n)} $$ and raised some questions, which are still not fully answered.

To get an idea of ​​how this function actually "behaves", here is the graph over a relatively large range, created by Vepir:

enter the image description here

So the function really looks like almost sinusoidal like a fractal Appearance and seems to grow without limits, although very very slowly.

The question is:

Although this question does not have any direct application, or at least I am not aware of it, it is nevertheless an interesting question waiting for a solution, and we would like to see some complete solutions of this question.

Also, it is worth mentioning, is that we always had $ z (m)> 0 $ and it seems that generally $ z $ It is really strictly positive.

This was also a question posed by Mathphile, namely the question:

  • It is $ z (m)> 0 $ for each $ m in mathbb N $?

So these two questions are what we would like to know $ z $.

Here is the question about MSE, along with some incomplete answers, but very skillful and detailed answers.

To evaluate the first values, we take that $ (- 1) ^ 0 = 1 $Although this is not true, but this is only for the purposes of this question.

visual studio c ++ error C2084. The function already has a body

These three files are the project of a course that I am following.
I was able to write the code and compile the project in earlier stages to, for example, load the reference engine.

Now adding some lines to the code should open the reference engine and load a primitive (square) but it produces an error when compiling.

I tried to add header guards and remove the keys from the empty function. What did not fix the error.

When trying to compile Visual studio it only throws 1 error and one message. That I indicate in the code that I attach.

game.cpp




#include "game.h"

TestGame::TestGame() {

}

TestGame::~TestGame() {

}
bool TestGame::OnInit() { * en esta linea indica el error c2084*/
    return true;
}

void TestGame::OnFrame() {

    if (KeyDown(DIK_ESCAPE)) PostQuitMessage(0);

}


bool TestGame::OnShutdown() {
    return true;
}

In this file is the problem.

game.h


#pragma once



#include "zakengine/zak.h"

using namespace zak;

class TestGame : public Game {

public:

    void OnFrame();
    bool OnShutdown();
    bool OnInit();

    void OnDraw();

    TestGame();
    ~TestGame();


private:

    Shape _shape;

};


void TestGame::OnDraw() {
    _shape.Draw();

}


bool TestGame::OnInit() { /* en esta parte indica un mensage que ya está definido*/

    _shape.SetShape(ZAK_SHAPE_QUAD);
    _shape.SetDim(100, 50);
    _shape.SetPos(0, 0);
    _shape.SetColor(0xFF00FF00);


}

main.cpp



#include "game.h"

#ifdef _DEBUG
#pragma comment(lib, "zakengined.lib")
#else
#pragma comment(lib, "zakengine.lib")
#endif

int main() {
    TestGame game;

    if (game.StartUp()) {
        game.Loop();
    }

    if (!game.Shutdown())
        return 1;

    return 0;
}

The code to load the primitive produces the new error.

How can you implement infinite lexicon sorting as a Python key function?

I am implementing an algorithm that forces me to order infinitely repeating words. In the regular lexicographic order, "prohibition" comes before "banana", but in infinite lexicographic order it is the other way around, since "bananabananabanana …" has an "a" as its fourth character, while "banbanbanban … "has a b.

Writing a comparison function to compare words in this way is not that difficult. However, Python 3 doesn't take comparison functions in its sort function, instead it takes an indexing function, which is supposed to save the calculation since it is only called once per item.

The standard library provides a workaround at functools.cmp_to_key. I have tried this and it works, but it seems to be very slow.

Is there a clever way to implement infinite lexorder sorting as an index function?

nt.number theory – A definite integral of the Gamma function in terms of Pi and Catalan constant

The Gamma function $ Gamma (z) $, where $ z $ is a general complex number $ pi $ and the Catalan constant (C) are very famous in the field of mathematics. Definite integrals involving these constants and functions are always of interest.

Test the following definite integral

$$
int_0 ^ infty x left | Gamma left ( frac {1} {2} + ix right) right | ^ 2dx = frac {2C} { pi}.
$$

where C is the constant of Catalan

Can two java classes be extended in one function?

I have a question, I am new to java and I needed my data to be extended by two data instead of one. Could it be done?

public class AlumnoDto extends UserDto (aqui meter TutorDto) implements Serializable {
}

Thank you!.

magento2: magento 2 "Header Already Sent" problem when there is big data in array and json_encode function used in ajax driver

I am developing the functionality in the Magento 2.3 version and calling the controller function by using Ajax. Controller function returns product data and everything works fine when The client is not connected.

Whereas when we try to login and return product data it throws error

"Exception: Warning: Unable to modify header information – headers
already sent by (departure started at
app / code / Magento2 / CustomProduct / Controller / Index / Index.php: 74) en
vendor / magento / framework / Stdlib / Cookie / PhpCookieManager.php online
148 in vendor / magento / framework / App / ErrorHandler.php: 61 "

Below is the array and json_encode

echo json_encode (array (& # 39; html_data & # 39; => $ html, & # 39; pro & # 39; => $ count));

Help anyone, this is the strange problem.

php: WHERE function in the database

I am trying to get a specific row in table user_meta, I just want the row that has the same ID as the author and the key meta is "reffer". The first part of the code works fine, I can get all the data from the user ID, but when I try to add an additional WHERE, I am having trouble:

AND WHERE meta_key = "reffer"; (Thats the part with the problem, the whole code is below)



post_author;
    $table_name = "mydb_usermeta";
    $sql = "SELECT * FROM ".$table_name." WHERE user_id = ".intval($user_id) AND WHERE meta_key = "reffer";
    $result = $wpdb->get_results($sql);  

     if(!empty($result))                      
    {    
        foreach($result as $row){  

            echo "ID: ". $row->meta_value;
        }

    } ?>

analytic number theory: contour integration involving the Zeta function

I am trying to calculate the contour integral
$$ frac {1} {2 pi i} int_ {c – i infty} ^ {c + i infty} zeta ^ 2 ( omega) frac {8 ^ omega} { omega} d omega $$
where $ c> 1 $, $ zeta (s) $ is the Riemann zeta function.

Using Perron's formula and defining $ D (x) = sum_ {k leq x} sigma_0 (n) $, where $ sigma_0 $ is the usual divisor counting function, it can be shown that
$$ D (x) = frac {1} {2 pi i} int_ {c – i infty} ^ {c + i infty} zeta ^ 2 ( omega) frac {x ^ omega } { omega} d omega. $$
So for that purpose one can only calculate $ D (8) $ and call it a day. However, for my own purposes, I want to redefine $ D (x) $ by the above integral instead. So why do I expose the problem for a specific case? $ x = $ 8, for example.

I have made some progress.

When considering a modified Bromwich contour that prevents branch cutting and $ z = 0 $let's call it $ mathcal {B} $, we can apply the Cauchy residual theorem:
$$ oint _ { mathcal {B}} zeta ^ 2 ( omega) frac {8 ^ omega} { omega} d omega = 2 pi i operatorname * {Res} ( zeta ^ 2 ( omega) frac {8 ^ { omega}} { omega}; 1) = 8 (-1 + 2 gamma + ln 8) $$
where $ gamma $ is the Euler-Mascheroni constant. I got this by expanding $ zeta ^ 2 ( omega) frac {8 ^ omega} { omega} $ in his Laurent series. To obtain the desired integral, then we should subtract from this value the portions of the contour that are not the vertical line $ c – iR $ to $ c + iR $, subtract these values ​​from the obtained residue and then take the limit as $ R to infty $ Y $ r a 0 $ where $ C_r $ is the radius circle $ r $ where he $ mathcal {B} $ dodge the origin.

Feel free to modify this contour in any shape or form, or consider a positive integer value different from $ x $.