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 :
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
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.
18.520469
73.856621
Vipul A M 