cancel
Showing results for 
Search instead for 
Did you mean: 

a programming definition for Stupidity

hoppingbunny123
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

hoppingbunny123
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

View solution in original post

2 REPLIES 2

hoppingbunny123
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

hoppingbunny123
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

View solution in original post