11-20-2021 11:44 AM - edited 11-21-2021 11:44 AM
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.
Solved! Go to Solution.
11-24-2021 01:49 AM
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
11-21-2021 11:39 AM - edited 11-21-2021 11:40 AM
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
11-24-2021 01:49 AM
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