**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+1}^{g}_{i}^{,g}_{j}^{‘}

*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 :*
*ws*
∫ *CO =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 → P*
∫*con(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

T_{sn}=Snapshot Tree

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

_{i}

*) → n*

_{i }

*=n*

_{i-1 }

*Same version**snapshotting, 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.*

18.520469
73.856621