Skip to main content
hoppingbunny123
Inspiring
November 20, 2021
Solved

a programming definition for Stupidity

  • November 20, 2021
  • 2 replies
  • 2133 views

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.

 

 

    Best answer by hoppingbunny123

    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

    hoppingbunny123Author
    Inspiring
    November 21, 2021

    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

    hoppingbunny123AuthorAnswer
    Inspiring
    November 24, 2021

    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

    Terms & ConditionsAccessibility statement