## Functional analysis: how to prove that the nucleus \$ (x ^ b + y ^ b) ^ a – (x + y) ^ {ab} \$ is definitively positive?

Exercise 2.12 of the book (Berg, C., Christensen, J. P. R. and Ressel, P. (1984). Harmonic Analysis of Semigroups: Theory of Defined and Related Positive Functions) states that the nucleus $$(x ^ b + y ^ b) ^ a – (x + y) ^ {ab}$$ is positive defined in $$mathbb {R} _ {+} times mathbb {R} _ {+}$$ for $$a, b in (0,1)$$ Y $$(| x | ^ b + | y ​​| ^ b) ^ a – | x-y | ^$$ is positive defined in $$mathbb {R} times mathbb {R}$$ for $$a in (0,1)$$ Y $$b in (0.2)$$.

How can we verify this? Why do we need conditions like $$a, b in (0,1)$$ Y $$a in (0,1)$$ Y $$b in (0.2)$$?

# include

// Declaração de variáveis
int Nx = 383;
int Nz = 121;
int Na = 100;
int ntotal = 6000;
int cut = 30;
float Dt = 0.0006;
int h = 10;
int pos_fonte_X = 192;
int pos_fonte_Z = 4;
int jobs = 5;
int num_rec = 383;
int vel_max = 5500;
int vel_min = 1500;
char model_name (100) = "marmousi_vp_383x121.bin";

// Declaration of methods
void bin_model_write (char extended_model_name (50), floating * extended_model, int Nxx, int Nzz);
int bin_read (char * model_name, int Nx, int Nz, float model);
empty modeling (int Nxx, int Nzz, int Nf, int pos_fonte_X, int pos_fonte_Z, float
P2, float * P3, float * coef_bd, float * coef_be, float * coef_bi, float * coef_bs, float * fonte, float * extended_model, float * C, float * A, FILE * snapshot, float * sis);
null bordas_Reynolds (floating * P2, floating * P3, floating * A, int Nxx, int Nzz);
empty bordas_Cerjan (float * P2, float * P3, int Nxx, int Nzz, float * coef_be, float * coef_bd, float * coef_bi, float * coef_bs);
null coef_absorcao (int Nxx, int Nzz, float * coef_bi, float * coef_bs, float * coef_be, float * coef_bd);
void generate_fonte (int Nf, int fcorte, float * fonte);
void add_bordas (floating model *, floating model * extended, int Nxx, int Nzz);

// Start two methods
void loop_principal () {

``````int Nxx, Nzz;
int Nf, k, i;
char extended_model_name(50);

Nxx = 2 * Na + Nx;
Nzz = 2 * Na + Nz;

// Criação de matrizes
float * model = (float*) calloc(Nx * Nz, sizeof(float));
float * extended_model = (float*) calloc(Nx * Nz, sizeof(float));
float * P2 = (float*) calloc(Nxx * Nzz, sizeof(float));
float * P3 = (float*) calloc(Nxx * Nzz, sizeof(float));
float * sis = (float*) calloc(num_rec * ntotal, sizeof(float));
float * C = (float*) calloc(Nxx * Nzz, sizeof(float));
float * A = (float*) calloc(Nxx * Nzz, sizeof(float));
float * fonte = (float*) calloc (Nf, sizeof(float));

// Coeficientes das bordas absortivas
float * coef_bs = (float*) calloc (Nxx * Nzz, sizeof(float));
float * coef_bi = (float*) calloc (Nxx * Nzz, sizeof(float));
float * coef_be = (float*) calloc (Nxx * Nzz, sizeof(float));
float * coef_bd = (float*) calloc (Nxx * Nzz, sizeof(float));

generate_fonte(Nf, fcorte, fonte);

for (k = 0; k < Nxx; k++) {
for (i = 0; i < Nzz; i++) {
A(Nzz * k + i) = (extended_model(Nzz * k + i) * Dt) / h;
C(Nzz * k + i) = -(pow(A(Nzz * k + i), 2)) / 12;
}
}

sprintf(extended_model_name, "extended_model_%dx%d.bin", Nxx, Nzz);

bin_model_write(extended_model_name, extended_model, Nxx, Nzz);

FILE *snapshot  = NULL;
snapshot = fopen ("snapshot.bin","wb");

modelagem(Nxx, Nzz, Nf, pos_fonte_X, pos_fonte_Z, P2, P3, coef_bd, coef_be, coef_bi, coef_bs, fonte, extended_model, C, A, snapshot, sis);

FILE * file_sis = NULL;
file_sis = fopen ("sismograma.bin","wb");

fwrite (sis, sizeof(float), num_rec * ntotal, file_sis);

P2=NULL;
P3=NULL;
model=NULL;
extended_model=NULL;
A=NULL;
C=NULL;
sis=NULL;
coef_bs=NULL;
coef_be=NULL;
coef_bd=NULL;
coef_bi=NULL;
fonte=NULL;

free(P2);
free(P3);
free(model);
free(extended_model);
free(A);
free(C);
free(sis);
free(coef_be);
free(coef_bd);
free(coef_bi);
free(fonte);

fclose(snapshot);
fclose(file_sis);
``````

}

void bin_model_write (char extended_model_name (50), float * extended_model, int Nxx, int Nzz) {

``````FILE * file_borda;
file_borda = fopen (extended_model_name,"wb");

if (Nz != 0) {
fwrite (extended_model, sizeof(float), Nxx * Nzz, file_borda);
}
if (Nz == 0) {
fwrite (extended_model, sizeof(float), Nxx, file_borda);
}

fclose(file_borda);
``````

}

void modelagem (int Nxx, int Nzz, int Nf, int pos_fonte_X, int pos_fonte_Z, float * P2, float * P3, float * coef_bd, float * coef_be, float * coef_bi, float * coef_bs, float * fonte, float * extended_model, floating * C, floating * A, FILE * snapshot, floating * sis) {

``````int k, i, n;
float P1;

pos_fonte_X += Na;
pos_fonte_Z += Na;

coef_absorcao(Nxx, Nzz, coef_bi, coef_bs, coef_be, coef_bd);

for(n = 0; n = ntotal; n++){

if (n < Nf){

P2(Nzz * pos_fonte_X + pos_fonte_X) = P2(Nzz * pos_fonte_X + pos_fonte_Z) + fonte(n) * pow((Dt / h), 2) * pow(extended_model(Nzz * pos_fonte_X + pos_fonte_Z), 2);
}

for (k = 2; k < Nxx - 2; k++){
for (i = 2; i < Nzz - 2; i++){

P3(Nzz * k + i) = C(Nzz * k + i) * (P2(Nzz * (k - 2) + i) + P2(Nzz * (k + 2) + i) + P2(Nzz * k + (i + 2)) + P2(Nzz * k + (i - 2)) - 16 * (P2(Nzz * (k - 1) + i) + P2(Nzz * (k + 1) + i) + P2(Nzz * k + (i - 1)) + P2(Nzz * k + (i + 1))) + 60 * P2(Nzz * k + i)) + 2 * P2(Nzz * k + i) - P3(Nzz * k + i);
}
}

bordas_Cerjan(P2, P3, Nxx, Nzz, coef_be, coef_bd, coef_bi, coef_bs);
bordas_Reynolds(P2, P3, A, Nxx, Nzz);

for (k = 0; k < Nxx; k++)
{

for (i = 0; i < Nzz; i++)
{
P1 = P2(Nzz * k + i);
P2(Nzz * k + i) = P3(Nzz * k + i);
P3(Nzz * k + i) = P1;
}
}

if (n % 100 == 0){
fwrite(&P2(0), sizeof(float), Nxx * Nzz, snapshot);
}

sis(ntotal * k + n)   =  P2(Nzz * k + jobs);

}
``````

}

null bordas_Reynolds (floating * P2, floating * P3, floating * A, int Nxx, int Nzz) {

``````int k, i;

for (k = 2; k < Nxx - 2; k++){

// Interface superior
for (i = 0; i < 2; i++) {
P3(Nzz * k + i) = P2(Nzz * k + i) + A(Nzz * k  + i) * (P2(Nzz * k + (i + 1)) - P2(Nzz * k + i));
}

// Interface inferior
for (i = Nzz - 2; i < Nzz; i++) {
P3(Nzz * k + i) = P2(Nzz * k + i) - A(Nzz * k + i) * (P2(Nzz * k + i) - P2(Nzz * k + (i - 1)));
}
}

for (i = 2; i < Nzz - 2; i++) {

// Interface esquerda
for (k = 0; k < 2; k++) {
P3(Nzz * k + i) = P2(Nzz * k + i) + A(Nzz * k + i) * (P2(Nzz * (k + 1) + i) - P2(Nzz * k + i));
}

// Interface direita
for (k = Nxx - 2; k < Nxx; k++) {
P3(Nzz * k + i) = P2(Nzz * k + i) - A(Nzz * k + i) * (P2(Nzz * k + i) - P2(Nzz * (k - 1) + i));
}
}
``````

}

empty bordas_Cerjan (float * P2, float * P3, int Nxx, int Nzz, float * coef_be, float * coef_bd, float * coef_bi, float * coef_bs) {

``````int k, i;
const float fat = 0.0025;

for (k = 2; i < Nxx - 2; k++) {

// Borda superior
if (Na != 0){
for (i = 0; i < Na; i++){
P2(Nzz * k + i) = coef_bs(Nzz * k + i) * P2(Nzz * k + i);
P3(Nzz * k + i) = coef_bs(Nzz * k + i) * P3(Nzz * k + i);
}
}

// Borda inferior
if (Na != 0){
for (i =  Nzz - Na; i < Nzz; i++) {
P2(Nzz * k + i) = coef_bi(Nzz * k + i) * P2(Nzz * k + i);
P3(Nzz * k + i) = coef_bi(Nzz * k + i) * P3(Nzz * k + i);
}
}
}

if (Na!= 0){

// Borda lateral esquerda
for (k = 0; k < Na; k++) {
for (i = 2; i < Nzz - 2; i++) {
P2(Nzz * k + i) = coef_be(Nzz * k + i) * P2(Nzz * k + i);
P3(Nzz * k + i) = coef_be(Nzz * k + i) * P3(Nzz * k + i);
}
}

// Borda lateral direita
for (k = Nxx - Na; k < Nxx; k++) {
for (i = 2; i < Nzz - 2; i++) {
P2(Nzz * k + i) = coef_bd(Nzz * k + i) * P2(Nzz * k + i);
P3(Nzz * k + i) = coef_bd(Nzz * k + i) * P3(Nzz * k + i);
}
}
}
``````

}

null coef_absorcao (int Nxx, int Nzz, float * coef_bi, float * coef_bs, float * coef_be, float * coef_bd) {

``````int k, i;
const float fat = 0.0010;

for (k = 0; k < Nxx; k++)
{
// Borda superior
if (Na != 0)
{
for (i = 0; i < Na; i++)
{
coef_bs(Nzz * k + i) = exp(-pow(fat * (Na - i), 2));
}
}

// Borda inferior
if (Na != 0)
{
for (i = Nzz - Na; i < Nzz; i++)
{
coef_bi(Nzz * k + i) = exp(-pow(fat * (Nzz - Na - i), 2));
}
}
}

if (Na != 0)
{
// Borda lateral esquerda
for (k = 0; i < Na + 1; k++)
{
for (k = 0; k < Nzz; k++)
{
coef_be(Nzz * k + i) = exp(-pow(fat * (Na - k), 2));
}
}
// Borda lateral direita
for (k = Nxx - Na; k < Nxx; k++)
{
for (i = 0; i < Nzz; i++)
{
coef_bd(Nzz * k + i) = exp(-pow(fat * (Nxx - Na - k), 2));
}
}
}
``````

}

void add_bordas (floating model *, floating model * extended, int Nxx, int Nzz) {

``````int k, i;

for (k = Na; k < Nx + Na; k++) {
for (i = Na; i < Nz + Na; i++) {
extended_model(Nzz * k + i) = model(Nz * (k - Na) + (i - Na));
}
}

// Borda superior
for (k = Na; k < Nx + Na; k++) {
for (i = 0; i < Na; i++) {
extended_model(Nzz * k + i) = extended_model(Nzz * k + Na + 1);
}
}

// Borda inferior
for (k = Na; k < Nx + Na; k++) {
for (i = Nz + Na; i < Nzz; i++) {
extended_model(Nzz * k + i) = extended_model(Nzz * k + Na + Nz - 1);
}
}

// Borda lateral esquerda
for (k = 0; k < Na; k++) {
for (i = Na; i < Nz + Na ; i++) {
extended_model(Nzz * k + i) = extended_model(Nzz * (Na + 1) + i);
}
}
``````

// Direct side edge
for (k = Na + Nx; k <Nxx; k ++) {
for (i = Na; i <Nz + Na; i ++) {
Extended_model (Nzz * k + i) = Extended_model (Nzz * (Nx + Na - 1) + i);
}
}

``````// Borda quina superior esquerda
for (k = 0; k < Na; k++) {
for (i = 0; i < Na; i++) {
extended_model(Nzz * k + i) = extended_model(Nzz * (Na + 1) + Na + 1);
}
}

// Borda quina superior direita
for (k = Na + Nx; k < Nxx; k++) {
for (i = 0; i < Na; i++) {
extended_model(Nzz * k + i) = extended_model(Nzz * (Nx + Na - 1) + Na);
}
}

// Borda quina inferior esquerda
for (k = 0; k < Na; k++) {
for (i = Nz + Na; i < Nzz; i++) {
extended_model(Nzz * k + i) = extended_model(Nzz * (Na + 1) + Nz + Na - 1);
}
}

// Borda quina inferior direita
for (k = Nx + Na; k < Nxx; k++) {
for (i = Nz + Na; i < Nzz; i++) {
extended_model(Nzz * k + i) = extended_model(Nzz * (Nx + Na) + Nz + Na - 1);
}
}
``````

}

int bin_read (char * model_name, int Nx, int Nz, float * model) {

``````struct stat buf;

errno = 0;

if(stat(model_name, &buf) != 0 && errno == ENOENT){
fprintf(stderr, "O arquivo: %s não foi encontrado.n", model_name);
exit(EXIT_FAILURE);
}

FILE * file;
file = fopen (model_name, "rb");
fread(model, sizeof(float), Nx * Nz, file);
fclose(file);

return(EXIT_FAILURE);
``````

}

void generate_fonte (int Nf, int fcorte, float * fonte) {

``````float fc, t, tf;
int n;

fc = fcorte / (3 * sqrt(M_PI));
tf = 2 * sqrt(M_PI) / fcorte;

for(n = 0; n < Nf; n++){
t = (n * Dt) - tf;
fonte(n) = exp(-M_PI * pow((M_PI * fc * t), 2)) * (1. - (2.* M_PI * pow(M_PI * fc * t, 2)));
}
``````

}

int main () {

``````loop_principal();
return 0;
``````

}

Or degub shows that in "add_borda" tem algum erro de memória. Or err:
The program received the SIGSEGV signal, segmentation failure.
0x00005555555555b4 in loop_principal () in sis.cpp: 69
69 Extended_model (Nzz * k + i) = model (Nz * (k - Na) + (i - Na));

## Functional analysis: what function of the nucleus produces functions of the power law

Suppose I have a kernel function $$K (x, y)$$. Then I can define an integral transformation as follows:

$$K (f) = int_0 ^ infty K (x, y) f (x) dx$$.

Is there any core function where the proper functions $$f (x) = O (x ^ – lambda})$$ for different lambda values?

## derivatives: determine how the change in the new data affects the hyperparameters in the Gaussian process with the square exponential nucleus

Basically, I want to determine how the inclusion of new data affects the hyperparameters of the Gaussian Process core. For reference, assuming square exponential nuclei as provided here:
$$K (x, x & # 39;) = sigma ^ 2 exp left ( frac {- (x-x & # 39;) ^ T (xx & # 39;)} {2l ^ 2} right)$$
Then, the derivative with respect to the length scale determines what the effect is for the nucleus when the length scale changes as follows:
$$frac { partial K} { partial l} = sigma ^ 2 exp big ( frac {- (xx & # 39;) ^ T (x-x & # 39;)} {2l ^ 2 } big) frac {(xx & # 39;) ^ T (x-x & # 39;)} {l ^ 3}$$

However, I would like to determine what is the change or effect of a single new data point to the length scale. What should be the symbolic expression from which I need to evaluate the derivative?

It is $$frac { partial mu} { partial l}$$ of the GP? where $$mu$$ It is the predictive mean of the GP as follows:

$$mu (x ^ *) = K (x ^ *, X) ^ top (K (X, X) + sigma_n ^ 2 mathbf {I}) ^ {- 1} mathbf {y_n}$$
If so, how can the derived expression be formulated? (Initial expression at least, you should be able to exercise derived from there)

## nucleus – [19.04]Should I be happy with mtrr_spare_reg_nr = 0?

I recently noticed that my kernel shows the following error messages related to MTRR:

• `mtrr_cleanup: can not find optimal value`Y
• ```pmd_set_huge: Cannot satisfy (mem 0xf8000000-0xf8200000) with a huge-page mapping due to MTRR override.```

After reading some documents on the subject, about all this, and the core documents here and here that mention the gradual elimination of MTRRS in favor of PAT, I ended up thinking that I could be happy to put `mtrr_spare_reg_nr=0` in the kernel command line. And in fact, the error messages disappeared and I didn't see any noticeable effect for now.

It seems that in the past, some X server drivers needed to reserve one or more MTRRs for their own use, but today it seems to be not the case. However, I still didn't use my Nvidia dGPU (maybe I should have done it before coming here, hahaha).

I'm here? below is the `dmesg` exit I had before my "correction" (I removed what I think is irrelevant, for the sake of clarity).

``````(    0.000262) MTRR default type: uncachable
(    0.000262) MTRR fixed ranges enabled:
(    0.000264)   00000-9FFFF write-back
(    0.000264)   A0000-EFFFF uncachable
(    0.000265)   F0000-FFFFF write-protect
(    0.000266) MTRR variable ranges enabled:
(    0.000267)   0 base 0000000000 mask 7C00000000 write-back
(    0.000268)   1 base 0400000000 mask 7FE0000000 write-back
(    0.000269)   2 base 0420000000 mask 7FF0000000 write-back
(    0.000269)   3 base 00E0000000 mask 7FE0000000 uncachable
(    0.000270)   4 base 00D0000000 mask 7FF0000000 uncachable
(    0.000271)   5 base 00CE000000 mask 7FFE000000 uncachable
(    0.000271)   6 base 00CD000000 mask 7FFF000000 uncachable
(    0.000272)   7 base 042FE00000 mask 7FFFE00000 uncachable
(    0.000273)   8 disabled
(    0.000273)   9 disabled
(    0.001130) x86/PAT: Configuration (0-7): WB  WC  UC- UC  WB  WP  UC- WT
(    0.001275) total RAM covered: 16334M
(    0.001518)  gran_size: 64K  chunk_size: 64K     num_reg: 10     lose cover RAM: 62M
(    0.001520)  gran_size: 64K  chunk_size: 128K    num_reg: 10     lose cover RAM: 62M
(    0.001521)  gran_size: 64K  chunk_size: 256K    num_reg: 10     lose cover RAM: 62M
(    0.001521)  gran_size: 64K  chunk_size: 512K    num_reg: 10     lose cover RAM: 62M
(    0.001522)  gran_size: 64K  chunk_size: 1M  num_reg: 10     lose cover RAM: 62M
(    0.001523)  gran_size: 64K  chunk_size: 2M  num_reg: 10     lose cover RAM: 62M
(    0.001524)  gran_size: 64K  chunk_size: 4M  num_reg: 10     lose cover RAM: 0G
(    0.001525)  gran_size: 64K  chunk_size: 8M  num_reg: 10     lose cover RAM: 0G
(    0.001526)  gran_size: 64K  chunk_size: 16M     num_reg: 10     lose cover RAM: 0G
(    0.001527) *BAD*gran_size: 64K  chunk_size: 32M     num_reg: 10     lose cover RAM: -2M

(    0.001632) mtrr_cleanup: can not find optimal value
Leave $$E$$ be a vector space on the field $$K$$, where $$K$$ is a numeric field (finite extension of $$mathbb {Q}$$) To consider $$Fix_K ( phi)$$ as the fixed field of automorphism $$phi$$. Is it possible to calculate the core of the vector space? $$E$$ using $$Fix_K$$ or is there any relation of $$Fix_K$$ to the $$Ker (E)$$?