cancel
Showing results for
Did you mean:

## a programming definition for Stupidity Level 8

in case you have a AI that has to factor in human stupidity, here is the logic for it.

its written in a style i could word it in over about an hour and i decided to share it here.

/////////////////

OR AND OR

OR switches polarity making something good = bad or bad = good, like NOT

AND does not switch polarity for that which OR switches polarity, AND switches polarity for that which OR does not switch polarity.
making evil remain evil and adding in good to stand beside evil.

then OR switches AND good to false to fit in OR size, and then AND switches AND good good to true which cannot fit  in OR. so the AND has good and evil.

to make this work for computer programming the logic for computer programming is
size of memory is this variable name = some value of the type and size that fits

the first value is OR, and AND fits into OR

the second value is AND, and AND fits into AND by including good.

so the first AND has no good so it has one value this is why OR can hold AND.
THEN AND adds in another value to fit in the AND memory size and type so AND is both good and bad.

The third value is OR, and AND fits into OR by zeroing out the larger AND to the size of OR.

then OR is fit back into AND as AND has a much larger size available which removes OR.

1 ACCEPTED SOLUTION

Accepted Solutions Level 8

the next question is, if you can define stupidity then the inverse of stupidity is intelligence. that makes sense but i had to think about it for a while to detail it better.

when you start a movement then are stopped that is a semi movement. this is stupidity.

to correct this you not only complete the semi movement but you also repeat the movement until it ends its loop condition.

the previous code is here:

the first value is OR, and AND fits into OR
32 bits = (EAX, or EBX, or ECX, or EDX) = 0
16 bits = (AX, or BX, or CX, or DX) = 0
8 bits = (AH, or BH, or CH, or DH) = 0
8 bits = (AL, or BL, or CL, or DL) = 1

the second value is AND, and AND fits into AND by including good.
32 bits = (EAX, or EBX, or ECX, or EDX) = 0
16 bits = (AX, or BX, or CX, or DX) = 0
8 bits = (AH, or BH, or CH, or DH) = 1
8 bits = (AL, or BL, or CL, or DL) = 1

so the first AND has no good so it has one value this is why OR can hold AND.
32 bits = (EAX, or EBX, or ECX, or EDX) = 0
16 bits = (AX, or BX, or CX, or DX) = 0
8 bits = (AH, or BH, or CH, or DH) = 0
8 bits = (AL, or BL, or CL, or DL) = 1
THEN AND adds in another value to fit in the AND memory size and type so AND is both good (AH, or BH, or CH, or DH), and bad (AL, or BL, or CL, or DL).
32 bits = (EAX, or EBX, or ECX, or EDX) = 0
16 bits = (AX, or BX, or CX, or DX) = 0
8 bits = (AH, or BH, or CH, or DH) = 1
8 bits = (AL, or BL, or CL, or DL) = 1

The third value is OR, and AND fits into OR by zeroing out the larger AND to the size of OR.
32 bits = (EAX, or EBX, or ECX, or EDX) = 0
16 bits = (AX, or BX, or CX, or DX) = 0
8 bits = (AH, or BH, or CH, or DH) = 0
8 bits = (AL, or BL, or CL, or DL) = 1

then OR is fit back into AND as AND has a much larger size available which removes OR.
32 bits = (EAX, or EBX, or ECX, or EDX) = 0
16 bits = (AX, or BX, or CX, or DX) = 0
8 bits = (AH, or BH, or CH, or DH) = 1
8 bits = (AL, or BL, or CL, or DL) = 1

// this is the semi movement.

the new code is below

is OR, and AND fits into OR by zeroing out the larger AND to the size of OR, looping until the condition is completed..
32 bits = (EAX, or EBX, or ECX, or EDX) = 0
16 bits = (AX, or BX, or CX, or DX) = 0
8 bits = (AH, or BH, or CH, or DH) = 0
8 bits = (AL, or BL, or CL, or DL) = 1

2 REPLIES 2 Level 8

using x86 assembly language:

to make this work for computer programming the logic for computer programming is
size of memory is this variable name = some value of the type and size that fits

the first value is OR, and AND fits into OR
32 bits = (EAX, or EBX, or ECX, or EDX) = 0
16 bits = (AX, or BX, or CX, or DX) = 0
8 bits = (AH, or BH, or CH, or DH) = 0
8 bits = (AL, or BL, or CL, or DL) = 1

the second value is AND, and AND fits into AND by including good.
32 bits = (EAX, or EBX, or ECX, or EDX) = 0
16 bits = (AX, or BX, or CX, or DX) = 0
8 bits = (AH, or BH, or CH, or DH) = 1
8 bits = (AL, or BL, or CL, or DL) = 1

so the first AND has no good so it has one value this is why OR can hold AND.
32 bits = (EAX, or EBX, or ECX, or EDX) = 0
16 bits = (AX, or BX, or CX, or DX) = 0
8 bits = (AH, or BH, or CH, or DH) = 0
8 bits = (AL, or BL, or CL, or DL) = 1
THEN AND adds in another value to fit in the AND memory size and type so AND is both good (AH, or BH, or CH, or DH), and bad (AL, or BL, or CL, or DL).
32 bits = (EAX, or EBX, or ECX, or EDX) = 0
16 bits = (AX, or BX, or CX, or DX) = 0
8 bits = (AH, or BH, or CH, or DH) = 1
8 bits = (AL, or BL, or CL, or DL) = 1

The third value is OR, and AND fits into OR by zeroing out the larger AND to the size of OR.
32 bits = (EAX, or EBX, or ECX, or EDX) = 0
16 bits = (AX, or BX, or CX, or DX) = 0
8 bits = (AH, or BH, or CH, or DH) = 0
8 bits = (AL, or BL, or CL, or DL) = 1

then OR is fit back into AND as AND has a much larger size available which removes OR.
32 bits = (EAX, or EBX, or ECX, or EDX) = 0
16 bits = (AX, or BX, or CX, or DX) = 0
8 bits = (AH, or BH, or CH, or DH) = 1
8 bits = (AL, or BL, or CL, or DL) = 1 Level 8

the next question is, if you can define stupidity then the inverse of stupidity is intelligence. that makes sense but i had to think about it for a while to detail it better.

when you start a movement then are stopped that is a semi movement. this is stupidity.

to correct this you not only complete the semi movement but you also repeat the movement until it ends its loop condition.

the previous code is here:

the first value is OR, and AND fits into OR
32 bits = (EAX, or EBX, or ECX, or EDX) = 0
16 bits = (AX, or BX, or CX, or DX) = 0
8 bits = (AH, or BH, or CH, or DH) = 0
8 bits = (AL, or BL, or CL, or DL) = 1

the second value is AND, and AND fits into AND by including good.
32 bits = (EAX, or EBX, or ECX, or EDX) = 0
16 bits = (AX, or BX, or CX, or DX) = 0
8 bits = (AH, or BH, or CH, or DH) = 1
8 bits = (AL, or BL, or CL, or DL) = 1

so the first AND has no good so it has one value this is why OR can hold AND.
32 bits = (EAX, or EBX, or ECX, or EDX) = 0
16 bits = (AX, or BX, or CX, or DX) = 0
8 bits = (AH, or BH, or CH, or DH) = 0
8 bits = (AL, or BL, or CL, or DL) = 1
THEN AND adds in another value to fit in the AND memory size and type so AND is both good (AH, or BH, or CH, or DH), and bad (AL, or BL, or CL, or DL).
32 bits = (EAX, or EBX, or ECX, or EDX) = 0
16 bits = (AX, or BX, or CX, or DX) = 0
8 bits = (AH, or BH, or CH, or DH) = 1
8 bits = (AL, or BL, or CL, or DL) = 1

The third value is OR, and AND fits into OR by zeroing out the larger AND to the size of OR.
32 bits = (EAX, or EBX, or ECX, or EDX) = 0
16 bits = (AX, or BX, or CX, or DX) = 0
8 bits = (AH, or BH, or CH, or DH) = 0
8 bits = (AL, or BL, or CL, or DL) = 1

then OR is fit back into AND as AND has a much larger size available which removes OR.
32 bits = (EAX, or EBX, or ECX, or EDX) = 0
16 bits = (AX, or BX, or CX, or DX) = 0
8 bits = (AH, or BH, or CH, or DH) = 1
8 bits = (AL, or BL, or CL, or DL) = 1

// this is the semi movement.

the new code is below

is OR, and AND fits into OR by zeroing out the larger AND to the size of OR, looping until the condition is completed..
32 bits = (EAX, or EBX, or ECX, or EDX) = 0
16 bits = (AX, or BX, or CX, or DX) = 0
8 bits = (AH, or BH, or CH, or DH) = 0
8 bits = (AL, or BL, or CL, or DL) = 1 