List for Step IV

<p>
***********************************
 working example: latest finds (24-9-2020)

'Experiment3.hs'

besides all graphics and illustrations that all  
 make use of the 'ptc' functions another concept
 revealed itself as a by-product. The following
 four functions only depend on similarity values
 which is the starting point of the ptc functions
 as well.

the result is ONLY dealing with strings that must 
 contain:
      - numbers otherwise leads to an error
      - sufficient numbers in overall li input
      - an equal sign '='
      - letters
=>  e.g "A3=sd4A"  -- will work
        "A=sdA"    -- wont
	"AsdA"     -- wont
	"AAA=sd1A"   -- with one side 
	 of the '=' length>3 will
	 always work.

I.    
 -- Experiment3 randomly guessing solutions
-- B in A via
-- e.g
-- *Experiment3> (inActie ["0xy0z=3"] ["x0y0z=6"] ["0x0yz=2"] ["xyz=11"] li5)
-- *Experiment3> let li6 = ["1b*00=3","AAA=3BAABAB","A4A=5BAB","A5=7AA","AA5=A7BBBAA","B2BBAA"] 
 => will work in the 'inActie' main function of 'Experiment3.hs'

-- whereas li7 below wont because the last atom 
-- is missing a number digit
-- *> let li7 = ["1b*00=3","AAA=3BAABAB","A4A=5BAB","A5=7AA","AA5=A7BBBAA","BBBAA"]

II.
-- also generate "infinetly"  many solutions
-- *Experiment3> poolBandNotB li4 1111111
--  [61,121,120,61,121,120,61,121,120,61,121,120,61,121,120,61,121,120]
--
--  *Experiment3> map chr (poolBandNotB li4 1111111)
-- "=yx=yx=yx=yx=yx=yx
"
III./IV.
-- li4                                    with zeros                without zeros
-- compare to bonelist to solution 1   expressAinA li5 pi 1    expressAsinA li5 pi 1
--                     to solution 2   expressAinA li5 pi 2    expressAsinA li5 pi 2

--  *Experiment3> expressAsinA li4 pi 2
-- [48.51138353765324,48.78048780487805,48.421052631578945,43.67816091954023]

--  *Experiment3> expressAinA li4 pi 1
-- [90.54290718038528,90.59233449477351,90.52631578947368,89.65517241379311]
--
=> change from comparing a row of a li list with its own atoms 
   let pi = Punkt "intern" Nothing Nothing Nothing Nothing Nothing

OR 
   compare with guess 
   let pi = Punkt "extern" Nothing Nothing Nothing Nothing Nothing

---------------------------------------------------------------------------------------------------
-- Three streams in and out of cells -----------------------------------------------------------
-- --------------------------------------------------------------------------------------------
-- --------------------------------------------------------------------------------------------
-- SOLUTIONS B, not b, A ,astigmatic -----------------------------------------------------
-- ---------------------------------------------------------------------------------------
--  1   in ----> the solution -----> B -----> out
--  cellStream1: 
cellStream1 expanS solu t =  (oglleLocateSolu expanS (map ord (head(ausw t solu))) 421)
poolB foli4 a = map ord (ausw a (concat foli4 ))  -- add solution here!!!
poolnotB foli4 a n =  (ausw a (cellStream3 foli4 n))  -- add solution here!!!

allLi4 foli4 expanS = map (cellStream1 expanS foli4) [1..6] -- length of a [pv] == 6
goldTray foli4 expanS s = map (poolB foli4) (concat$concat$concat$ausw s (allLi4 foli4 expanS))
poolBandNotB foli4 expanS=  concat$ concat(map (goldTray foli4 expanS) [1..(length foli4)])
tbeMapped foli4 t = map chr (poolBandNotB foli4 t)
--  2      ----> the Zero space ---> [[0]] -----> out
--               indicate the position of all solutions 
--               OF THIS B in A
-- 1 -> 10 , 2 -> 100 n>2 needs 1000 aso. otherwise error 
-- e.g*> rek2 2 
-- *> "zz6zz6zz6zz6zz6zz6"
bAndNotB foli4 n = filter(/='0') (head (ausw n (nub$ map (tbeMapped foli4) [1..100])))
likelyhood foli4 n = let step1 =  ((bAndNotB foli4 n))
                     in let step2 = nub$reverse$sort step1
                     in if (length step2) == 1 then take 1 step1 
                        else show ( cellInt (nub$reverse$(sort (bAndNotB foli4 n)))-1)

-------------------------------------------------------------------------------------------
--NULL SPACE : cellStream2
-- via organelleFind , organelleSearch , oglleLocate
-- runCell -> one of above -> solutions B in A ->  cellStream1
-- to be mapped with n 
runCell wantedList solution n = (head (ausw wantedList solution)) `elemIndices` [runCellRAW n wantedList solution]

-- expanS: Int which pv function to see 1..max (sqrt [(Int range)^2] ) -- must be N > -1 	
-- (Int range -9223372036854775808..9223372036854775807)
-- the null-space is used in 'runCelllRAW','runCell' at the moment.
--  runCell -> organelleFind 
cellStream2 expanS solution t = organelleSearch expanS (map ord (head(ausw t solution)))

---------------------------------------------------------------------------------
--RANDOM LINE : cellStream3 
--  unrestricted search with  
ogR solu n = (runCellRnd 1 solu n)
-- every n generates a new list +100
cellStream3 solu n= map (ogR solu) (runLists n)
{- connect to EXTERNAL via triggerWord' last state domain must be changed .........................  -}   
-- pi: Punkt , if intern switches intern 
--             else extern
--e.g> 
--pi: Punkt "extern" ...; guess String e.g "ddd"
cellStream3EXT foli4 pi guess = nub $ concat$ (runEXP3 foli4 pi guess)  -- => simvals

TRIGGERWORD---------------------------------------------
the triggerword function uses the Punkt data type with
two established words so far:
"intern"
"cell"

if Punkt pi uses intern then compare line of 
a li list with itself -> Fractional

else if it uses cell we receive
               Int -> Fractional 
	 and can retreive the number carried in

else compare each line of a li list with a guess
            externally

*Experiment3> triggerWord "cell" "cell4"
  "4"

triggerWord g domain
Experiment3> :t triggerWord
triggerWord :: String -> [Char] -> String

=> - if we avoid domain="" which we can easiy avoid 
      we always get a computable outcome
   - very distantly connected via a combination with the main function 
     'inActie' maybe can help to avoid
      main flaw of 'inActie' which is described above

ptc3 with cos CMG Lee
grogono

given :

P(B|A) * P(A)
P(A|B) = --------------
	     P(B)

binomial expansions
with Pascals_triangle

???	     
           +
= ( P(A|B)   (PA|B) ) ^2 = 
           -

= ....

P()

Experiment3

outcomes before final results:
What started out to be a sorting algorythm turned 
into a function that filters numbers out of strings.

in contrast to previous examples only works with
numbers in strings
*Experiment3> let li6 = ["1b*00=3","AAA=3BAABAB","A4A=5BAB","A5=7AA","AA5=A7BBBAA","B2BBAA"] 
 => will work in the 'inActie' main function of 'Experiment3.hs'

-- whereas li7 below wont because the last atom 
-- is missing a number digit
*> let li7 = ["1b*00=3","AAA=3BAABAB","A4A=5BAB","A5=7AA","AA5=A7BBBAA","BBBAA"]

-- WITHOUT ptc function r
-- randomly guess and find
-- solutions based on the
-- 'solution' variable (e.g li5)
-- pv variabes (the first 4 ) not being used
-- but ready to be plugged into data types below
*Experiment3> (inActie ["0xy0z=3"] ["x0y0z=6"] ["0x0yz=2"] ["xyz=11"] li5)
 => - ten different suggestions based on 
      'zufallBasic1' a random generator

- one line un-nubbed 
   - ten random solutions positions for each of the six atoms
     of a li list

=> 
older approach need li list length 5  to work
*>let li = ["person","Steve","shy","withdrawn","farmer","book"]
*>let li2 = ["person","Steve","shy","withdrawn","librarian","booky"]

*>let li3 = [[li,li2]]
*>let myTest at = runKBASE 2 ["1","2"] 1 2 at 2 (li3) 1 2 3 4
*> myTest "country"

Experiment 3, without ptc approach
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
if ptc dont work at least we have an iterative process
without the whole framework provided
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

A in | B and notB |
'poolBandNotB'
=> give n many guesses 
e.g *> map chr (poolBandNotB li5 1729)
 *> "AABBBAABBA7B7AABBBB7ABABB".

the propability of the pool of above 
being at which position of one of
four pv functions         pv1         pv2         pv3        pv4

P(goldTray) = (inActie ["0xy0z=3"] ["x0y0z=6"] ["0x0yz=2"] ["xyz=11"] li5)

if pvs and li5 of above match up we have them even ready 
to be turned into Punkt format. which is only used
so far to change functions applied to fill a 'goldtray'

e.g*> let pi = Punkt "extern" Nothing Nothing Nothing Nothing Nothing
-- with "extern" the given propability of
  a solution B in an underlyaing solution space A -> P(B in A)

see catalogue zoo 'quirky example'
*Colored_2_3_5_Counter20> let ert r = tk r (ptc6 250)
*> let xS r = head (ert r)
*> let yS r = last (drop 1 (take 2 (ert r)))
*> let zS r = last (ert r)
*> let maXxS = map xS [1..100]
*> let maXyS r = map yS [1..100]
*> let maXzS r = map zS [1..100]
*> whereTo e r = e `elemIndices` r
	   
-- engage Punkt data type 
-- with the intention to plug in any function f(x)
-- and select any x with m
*> let basis22 foAL m = maybePu (head (ausw m foAL ))
*e.g> basis22 (map show (ptc6 105)) 5
 => ...   --shows line 5 of ptc6
	   
-- store data in String because there are only 5 other spots left
-- when reading a longer list that wont help thus store in Punkt "String"
*> let basisPunkt foAL r = maybePu (show(checkflow [] [((basis22 foAL r))]))

-- plug 'basisPunkt' into this test below best to be mapped via e
*> let fmrTEST3 io e e2 forLine =  checkflow  io [(Punkt  (head(checkflow [] [(basis4 e2 forLine)])) {- ...
	        ... -} (Just (basis2 e 1 )) (Just (basis2 e 3 )) (Just (basis2 e 4 )) {- ...
	        ... -} (Just (basis2 e 5 )) (Just (basis2 e 6))) ]
*e.g>let fmrTEST3 io e e2 forLine =  checkflow  io [(Punkt  (head(checkflow [] [(basisPunkt e2 forLine)]))(Just (basis22 e 1 )) (Just (basis22 e 3 )) (Just (basis22 e 4 ))(Just (basis22 e 5 )) (Just (basis22 e 6))) ]

-- a group of functions that shall a [(Maybe Punkt)]-> that by itself is the definiton of
-- mother :: Punkt -> Maybe Punkt 
-- these functions below shall lead to => a motherTYPE that is depending on the type of simiyritYvalue
	   -- to plug any value into 'Maybe Punkt' we need a 'Maybe String'
	   *>:t foAdecide2 (map show (Co.ptc6 100))
	   *>foAdecide2 (map fshow (Co.ptc6 100)) :: Maybe String
	   
foAdecide2 foA = let boa rt t = (Just (U.maybePu2 rt t)) --let whereBreak = chainDistribute crit bonelist crit (lines "1")
                 in let mapMaybePun k = let ste1 k rt = (boa (head(Co.ausw k rt))) ((Just (U.maybePu (head (Co.ausw k rt)))) ) 
                                        in ste1 k foA -- e.g foA = ["vb","vb2","vb3"]
                 in let preMoa = length foA
                 in let eindelijk = do (map mapMaybePun [1..preMoa]) 
                 in 
                 if foA==[] then Nothing
                 else let chssd i = U.maybePu2 (head(Co.ausw i foA))  (((boa (head(Co.ausw i foA)) (head(Co.ausw i eindelijk)))))  
                      in Just (show[(chssd 1)])

-- the 'Maybe String' is turned to a 'Maybe Punkt' that has an error handler
--> mayerPunkt :: IO(int) String -> Maybe String -> Maybe Punkt -> 
mayerPunkt r foa = if (foa) == [] then maybePu "empty"
                   else maybePu2 (r) (Just(maybePu ((show [(foAdecide2 (foa))]))))