For the KdV equation there is a method of correction terms. Bourgain reinterpreted it in an article as a special case of the "normal forms method". I am writing this question to find a simple example (of any equation) of an application of this method in normal ways. My general understanding is that this normal forms method improves the order of nonlinearity in the given equation.

# Tag: normal

## Do I get the normal download link to download Ubuntu in the folder, not an ISO file

How to get Ubuntu download in non iso folder format

## permutations: normal subgroups of k-transitive groups.

I don't understand a test in Cameron's permutation groups.

Theorem 4.1. let G be k-transitive, but not $ S_k $, with k> 1. So, a non-trivial normal subgroup N of G is (k-1) -transitive, except possibly when k = 3, when N can be an elemental abelian group of 2 groups.

The proof given in the book is by induction in k. The base case of k = 2 is clear: transitive groups 2 are primitive and the normal subgroups of primitive groups are transitive.

Now we assume that the result is valid for k-1 and try to prove it for k.

Choose some $ alpha in Omega $ (where $ Omega $ is the set in which G acts). So the stabilizer $ N_ alpha $ from $ alpha $ in N it is a normal subgroup of the transitive stabilizer (k-1) $ G_ alpha $ from $ alpha $ in G (per second isom. thm.).

Now what I struggle with:

By the induction hypothesis, one of three possibilities occurs:

one) $ N_ alpha $= 1. Then N is regular, so N is an elemental abelian group of 2 groups, and G is not 4 transitive.

I will not list the other two possibilities, because I just want an explanation of why G is not 4-transitive. An earlier theorem showed that if G is k-transitive for $ k ge 3 $ then a normal normal subgroup is an elemental abelian group of 2 groups. But that theorem says nothing about G not being 4-transitive, and the proof of the theorem in question implies that the above theorem shows this.

Why is G not 4-transitive?

## Suppose $ G $ is a group and $ N $ a normal subgroup of $ G $. True or false

Yes $ G / N $ it is finite and $ N $ is finite then $ G $ Is finite? True or false.

Yes $ G / N $ it is finite then $ N $ is finite or $ G $ is finite True or false.

## Convert a binary string, with each character separated by spaces, into a normal C string and print

This code is a purely fun project and comes from this challenge at freeCodeCamp. This is simply an algorithm challenge that is generally meant for JavaScript, but I decided to do it in C. It will not be used for any production reason. Leave any comments that you consider appropriate, with special attention to loops and data types. By the way, I used pointer arithmetic, while, and for loops to explore different approaches to problems. I also left the printf on the number of tokens there if you want to play with it without commenting. Also note that I have provided 2 sample binary strings, but currently only one is used by default.

`#include `
#include
#include
#include
#include
char* binary_agent(char *bin_str);
char bit_string_decode(char *const str);
bool bit_string_is_valid(char *bit_string);
int main(void)
{
char str() = "01000001 01110010 01100101 01101110 00100111 01110100 00100000 "
"01100010 01101111 01101110 01100110 01101001 01110010 01100101 "
"01110011 00100000 01100110 01110101 01101110 00100001 00111111";
char str2() = "01001001 00100000 01101100 01101111 01110110 01100101 00100000 01000110 01110010 01100101 01100101 01000011 01101111 "
"01100100 01100101 01000011 01100001 01101101 01110000 00100001";
char *result = binary_agent(str);
printf("%sn", result);
free(result);
result = NULL;
return 0;
}
// Purpose: Return an English translated sentence of the passed binary string
// "Chars" must be space-separated
// E.G. binary_agent("01000001 01110010 01100101");
char* binary_agent(char *bin_str)
{
assert(bin_str);
size_t count;
char *token = NULL;
char *delim = " ";
count = 0;
char *ptr = bin_str;
while((ptr = strchr(ptr, ' ')) != NULL)
{
count++;
ptr++;
}
ptr = NULL;
//printf("Total number of tokens %lun", count);
char *output_buffer = malloc(sizeof(char)*(count+1));
assert(output_buffer);
token = strtok(bin_str,delim); // token is null-terminated
if(!token) return NULL;
output_buffer(0) = bit_string_decode(token);
size_t i;
for(i = 1; token != NULL; ++i) //convert to for loop
{
token = strtok(NULL, delim);
if(!token) break;
output_buffer(i) = bit_string_decode(token);
}
return output_buffer;
}
//Parses groups of 8 1s or 0s into a char
char bit_string_decode(char *const str)
{
assert(str && bit_string_is_valid(str));
char output = 0;
size_t i;
//String needs to be valid for sure here
for(i = 0; i < 8; ++i)
{
switch(str(i))
{
case '1':
output |= 1 << 7-i;
break;
case '0':
break;
}
}
return output;
}
bool bit_string_is_valid(char *bit_string)
{
assert(bit_string && (strlen(bit_string) == 8));
while(bit_string && *bit_string != '')
{
if((*bit_string != '0') && (*bit_string != '1')) return false;
bit_string++;
}
return true;
}

## What does normal focal length really mean?

First off, I want to say that I have a photography / videography qualification, and of course I know the principles of normal focal length, how angle of view relates to focal length, and sensor / film size. There is this general rule that a focal length that is equal to or close to the diagonal of the sensor / film dimensions provides a natural field of view or "as seen by the human eye." From the first time I heard this, I had a skeptical voice inside, but I didn't pay much attention until recently.

I took my full-frame Sony and the 28-70mm kit lens and rotated the zoom until what my eye saw and what I saw through the viewfinder was identical to my perception. The result was somewhere around 68mm. That gives me a diagonal viewing angle of ~ 35 degrees, as opposed to ~ 53 degrees for a normal focal length.

Do I have strange eyes or a misconception about the normal focal length?

## How to use normal entity functions in new ExternalIdentifier objects (eg Wikidata)?

Is there a way to use the built-in? `EntityXXX`

in `ExternalIdentifier`

objects? Maybe I'm just being lazy, but it's more intuitive and easier to do this:

```
EntityProperties[ExternalIdentifier["WikidataID",
"Q180736", <|"Label" -> "Les Misérables",
"Description" -> "1862 Victor Hugo novel"|>]]
```

instead of this:

```
WikidataData[
ExternalIdentifier["WikidataID",
"Q180736", <|"Label" -> "Les Misérables",
"Description" ->
"1862 Victor Hugo novel"|>], "NonIdentifierProperties"]
```

## dnd 5e: Can undead characters use healing spells as normal to heal other characters?

*To heal wounds* state:

A creature you touch recovers a hit point count equal to 1d8 +

your spell casting ability modifier.This spell has no effect on the undead.

or constructions.

*Healing word* state:

A creature of your choice that you can see within range recovers the hit.

points equal to 1d4 + your spell casting ability modifier.This spellor constructions.

has no effect on the undead

**Unless I have missed something** of the homebrew race you shared, you are actually undead and can cast your bard spells normally.

Being undead doesn't change the way spells work, but of course it changes their effect on you, since you're dead.

I was surprised to see that **Inflict spells do not heal the undead in 5e**.

On how to heal yourself as an undead creature, the question How can I heal undead creatures? I can help.

## Soon:

Yes, your bard spells will heal your comrades alive, but you will have to find other ways to heal yourself since they don't heal you.

## linear algebra – Difficulties with Jordan's normal form

I am studying in German and due to the coronavirus we only had a video conference, so unfortunately I have not understood how to deal in cases where I do not have the womb. If I did, I think I got the steps. But now I only have this table and it should determine Jordan's number of blocks. If I had the matrix, it would also be fairly easy to calculate the characteristic and the minimum polynomial.

enter the image description here

I don't want the complete solution, but just a hint on how to determine the matrix.

## dnd 5e: Can the undead heal other players with normal healing spells?

So I've been trying to create a character (a Skeleton Bard using this homebrew race option) and I know there are some spells that can't heal the undead. But what happens backwards?

As a skeleton, could I use Cure Wounds or Healing Words on my other (live) teammates?

I like the idea of not being able to be healed by certain spells because it would be interesting to play with them. But I feel like it would be quite difficult as a healer if I can't use one of the most vital spells in my kit.