One side of data sets

new -> [environment with destiny] -> {switches conditions}.(variables){return record}

data sets:

<when><where><who><what><how><how much many><imagion><why><ind>

;<when>

def time = clock(catch){estimated point};

.log file:

[catch:time]

def permit = entrance(name){time stamp switched in/out};

.entrance file:

[name:[in time, out time]]

def wasted = time(start, target);

.work file:

[start:[wasted time]]

def events = [condition1,condition2,condition3];

.event file:

[[condition1,condition2,condition3]:events]

do

player(action){if(action=conditions)then event};

<where>

def cross address=input(lat,long){algorithm};

.address file:

[[a1,a2,a3],[o1,o2,o3]:cross address]

def path record=walk(start,goal){way minimum selectivly};

.path record file:

[[start,to1,to2,to3,...,goal];path length]

def page = dictionary(term){mean sentences};

.dictionary file:

[[term, mean]:page]

[{term,(mean key words)}:page]

[(first class, second class, third class):page]

def room = gentle(in/out){apply id};

.room file:

[(attend id,leave id):numbers of people both attend+1 and leave-1]

def shooting=map(enemy1,enemy2,...){set enemies in the map};

.map file:

[stage:set map]

with {player}.shoot(liful){fire and fire}

def music =record(title,artist,(genreA,genreA-sub,genresub-list));

.music file:

[([genre list-sub-A],title,artist):music]

<who>

def personal information=[date, address, name, action];

.personalomation file:

[(date,address,name,action):link to]

def events = player(card){action} in game rule;

.battle file:

[[turn, player, card]:event[my life, enemy life, referal judge]]

def count = seeker(animal){place};

.catch file:

[place:[animal,count]]

def paticipants = {challenger}.(skills){skill1,skill2,skill3,....};

.paticipants file:

[challenger:skill(order)[skill1,skill2,...]]

{coliseum}.call(atacker,defender)

def player=time(skill){condition};

stage file:

[stage:player sellect(skills){change map within limited time}story]

<what>

def result = calculate(a,b){a+b};

.log file:

[[a],[b]:[result]]

def construction = combinate(any p){order procedure};

.construction file:

[{p},{p},{p}... : construction]

def containation = analyse(product){how to cut};

.product file:

[[product]:{p},{p},{p},...,]

def effect = {struct}.(finger1){moving};

                                           .(finger2){moving};

                                           .(finger3){moving};

.effect file:

[(finger1),(finger2),(finger3):effect]

def document=templete(form1,form2,...form n){input data to templetion return query code};

.article file:

[[query code]:[formed document]]

<how>

def aimed result=function(aim){any};

.phenomenon file:

[aim:result]

def tester = try(test){check either correct or incorrect};

.mark file:

[[tester]:[Q1,Q2,Q3,...,essay point(truthluity,crimility,imaginity,faulty)]=>value]

def  procedure = manufacture(parts1,parts2,parts3,process1,process2,process3);

.procedure file:

[product:([parts1,parts2,parts3],[process1,process2,process3])

<how much many>

def cost = [barcode:cost]

.cost file:

[barcode:cost]

def product cost = [(name, productor, import, barcode) : cost]

.product cost file:

[(name, productor, import, barcode) : cost]

def record = [[date, account, {shoppinged}, payment]]

.benefit file:

[([date],[account,payment]):{shoppinged list}]

<imagion>

def assumption = [when, where, who, what, how, why];

.assumption file:

[input assumption : (when, where, who, what, how, why)]

[(when, where, who, what, how, why):output assumption]

<why>

def concept = (things, things, things);

.concept file:

[concept:[things, things, things]]

[concept:{things multi sum}]

def answer={hint1,hint2,...}

.quiz file:

[{hint1,hint2,...}:answer]

def thoughts = {hint1, hint2,....};

.ai file:

[{hint1, hint2,...}:thoughts(condition hints)]

def article={a lot of key words};

.article file:

[{list each article key words}:address of the article]

def word list = {word1,word2,...,word n}

.log file:

[{selected a lot of words}:placement]

\<ind>

translation:

document -> (compile) -> [printer] -> print out.

picture -> (compile)-> [display] -> view.

sound -> (complile) -> [audio device] -> music.

message -> (send) -> [massage+IP] -> sent

transmission:

[message(encriptor) -> [network] -> [decriptor].message. 

 message[decriptor]<-  [network]  <-encript.message  ]

[           test(access)   -> [network] -> {return common key}

           (encript)           <- [network] <-

encripted message->[network] -> [decriptor].message.     ]

[   test(access)                                      ->[gate : commission : gate]  ->  [return common key]

  (encript with secret key)             <- [gate : commission : gate] <- 

    secretally encripted message ->[gate : commission : gate] ->[decriptor caused of secret].message

allowalance:

[deviceID:permittedID] ->                                                                        agency[deviceID:permittedID:validation]

                [validation]             <-

message{validation(encript)} -> (decript){message}

                                                                          call(deviceID:validation) -> agency[validation : deviceID : allow or not]

                                                                          'allow' message valid        <-

back:https://sites.google.com/view/1mcalculation/