Synopsis -Blunt

 

Relevant mathematics associated with the Project:

1. Let S be a system defined for the overview of git-torrent system

S={GR,GR’,T,D,C,E,Files | Фs }

where,

GR = Git Repository

GR’= Changed Final Git Repository

T=Torrent

D= Diff Architecture

C=Choice Architecture

Files is a set of Files in any directory structure

E= Exceptions

Фs= Rules

Is= GR’ ={Ф}, δ(GR) {Changes over GR}

T{ф} , s∩T≠ {ф}

Fs= GR’ C GR , GR’ C δ(GR) , p=s

Where

δ= changes done

p= peer

s= seed

f(GR,D,T,C | G ε T) ->f(GR, δ(GR)) -> GR’

t(GR) => diff(GR)
lim GR → CO
CM

dif(files) → GR w.r.t. CO
U=GR' 

j+1gi,gj

g Є GR

i

, g' Є GR' 

j.

|GR' 

j+1

|=MAX(|GR

i

|,|GR

j

|) GR' 

j+1

=> Files

 

 

Input = {GR,GR’,T,D,C}

Output = {GR’,T’}

 

2. Let GR be a System defined for Git Repository

GR = {CO,REV, REF,t,A,L,Files,Ws | t εTREE}

where,

CO= Commit Object

REV= Revision

REF= Reference

A=Authorization

L=Logistics

Ws= window size for break up

m(t,CO,A)-> t’

trans(t, REF, REV)->(REF’->t’)

size(Files) > Ws

{Refs} subset of CO
dif(files), lim files -> CO -> Ws

Output :
wsCO =files , dif(GR,GR')=CO'
1
GR=U CO

i

CO

i

Є CO

 

 

3. Let T be a system over Torrent

T={P,S,TRAC,OM,PWP,THP,CON,gi,d ,t | d ε D , gi ε GI,t ε Tree}

where,

P=Peer

S=Seed

TRAC= Tracker

CON= Connectivity

GI= Git Interface

P≠{ф} 
S∩P≠{ф} 
S is proper subset of P
Trac≠{ф}
Con=f(P) 
t≠{ф}
|s| lim→|co| 
          s
f(P,t) → S
f(Pc',t) → P'
Pc'=(P ^ δ(P')) OR δ(P') => (GR')
f(Pc',GR') => Gr

c

'

dif(con') , where con' is subset of S
for lim S → Pcon(S)=GR'
f(tree,P) → Pl'=S

4. Let D be the diff architecture,

D={CO, CO’,CM,LOG,gi | gi ε GI}

where,

CO=Commit Object

CO’= Changes over CO

CM=Context Mapping

f(CO,CM,gi)->CO’,gi

dif(CO) → CO’ for lim CO‘ ->0

CO’={cod,0| cod is proper subset of CO}

 

5. C define the Choice architecture used to determine, which of the seeds to use in a swarm.

C={Sc, GR’, d, Sc’,TRAC |d ε D}

Sc=Set of choose Seeds

f(Sc,GR’,d)->Sc’

f(TRAC)->Sc


 

6. Let CO be a system for Commit Object Management

CO={Delta,State,HASH,Data,d,a,log | a ε A, log ε LOG, d ε D}

f(CO,Delta,State)->CO’

f(CO,HASH)->ID

CO=Data+State+a+log

data is subset of files
state={staged,committed}
Is-> state = committed a≠{ф}
delta:d {onto, one-to-one , one-to-many relation} 
dif(data)=delta for lim delta → 0
f(CO') → log *changed CO → for delta

 

7. Let REF be the reference model,

REF={sw,t,Tspec, Tsw, Tsw’ , Sw’,spec | t ε T, Tsw’ is subset of tree}

where,

sw= Switch

Spec= Specification

f(sw ,sw’,Tsw)->Tsw’

f(sw’ ,Tspec)->Tsw’(TSPEC)

f(Spec,sw )->sw’

Tsw= Current Tree

Tsw’= Switched Tree


8. Let REV be for Revisioning

REV={sn,t,n | t ε Tree, sn ε SN}

where,

sn=Snapshot of project

f(sn,t)->R(n)

Free(sn,t)->Tsn

Tsn=Snapshot Tree

generating of RC and releases 
N=a≠{ф}
added a here
Exception condition here - > R(Sn

i

) → n

i

=n

i-1

Same versionsnapshotting, Ignore this to let n

i-1

be as it is.

 

9. Let A be used for Authentication

A={SSH, gr, At, User | SSH(user), gr ε GR}

f(gr, SSH)->gr’

 

At={Auth,UnAuth,ND}
ND for invalid user of A

 

10. LOG={u,gr,co,l ,GR’ ,l’| u ε user, gr ε GR,co ε CO, l ε LOG}

f(u,gr,co)->l

x
 l = ∑ l

i i=0

l'=f() U l, f and l increase monotonically

 

10. Let P be a set for Peer Functionality

P={L,S,CO,u}

where,

L=Leech

S=Seed

u=update

and S≠{ф}

f(L,S)->L’

Fs = L’ -> S


11.THP define the Tracker HTTP Protocol working

THP={TRAC,m,pl,ml,u }

where,

u=update

m=Message

pl=Peer List

ml= Mask List

and pl≠{ф}

f(u,pl)->pl’

f(TRAC,m)->u->pl

f(pl,ml)->pl’

 

 

12. Peer Wire Protocol is given by

PWP={gr,pl,ll,sl,m | gr ε GR,}

where,

sl=Seed List

ll=Leech List

f(gr,ll,sl)->m

f(ll,m)->gr’

sl={ф} 
sl is proper subset of pl
PWP →∫ m = u

Problem statement feasibility assessment using satisfiability analysis and NP Hard, NP Complete or P type using modern algebra:

We will be considering Section 6, to prove our problem to be NP-Complete.
1. The Problem is NP- 
This one states we have an NP problem, verification of required data from Se' is possible in O(n

k

) {k=constant} time. 
Derivation of Se' cannot be done as such in O(n

k

).
As such the Problem in in NP

2.We know that the Vertex- Cover{VC} Problem is NP-HARD
Using vertex – cover anology here,
we need to find Se'(cover) from Se(Graph G) that gives reachability (GR').
Thus, V-C is sub module call for this function {∏}.

 Thus we can say,> V-C Problem

but V-C is NP-HARD.

Thus ∏ , being harder than it, also falls into NP-HARD.for Se' is Turing complete, and Turing computable .
This can be verified in O(n)
Thus, as ∏ is in NP and NP-HARD, it is a NP complete problem .

Now , ∏ is a submodule call from the main S system.
Thus
S >

Thus our system can be stated to be NP-complete

Verification of this is linear , but derivation is not.
Advertisements

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s