Verificatio formalis est probatio unius programmatis vel algorithmi alterius utendi.
Haec una ex potissimis methodis permittit ut omnes vulnerabilitates in programmatis invenias vel probas quod non sunt.
Accuratior descriptio formalis verificationis videri potest in exemplo solvendae quaestionis in praecedente articulo.
In hoc articulo moveo a formali verificatione problematum ad programmata et quomodo describam
quomodo possunt in regulas formales automatice converti.
Ad quod faciendum, mea scripsi analoga virtualis machinae, principiis symbolicis utens.
Codicis programmatis partem inducit et eam in aequationum systema (SMT), quae iam programmatice solvi potest.
Cum informationes de calculis symbolicis in Interreti potius fragmentarily exhibeantur;
quid sit breviter dicam.
Computatio symbolica est via ut simul programmata in amplis notitiarum rebus exsequatur et instrumentum principale est ad verificationem formalem programmatis.
Exempli gratia, condiciones ponere possumus in quibus prima ratio quaslibet valores positivos, secundo negativos, tertium nullas accipere potest, et argumentatio output, exempli gratia, XLII.
Symbolae calculi in uno cursu nobis respondeant, an possibile nobis sit optatum exitum et exemplum propositi parametri talium obtinere. Nulla ut neque id lorem laoreet condimentum.
Insuper argumenta inputare omnibus possibilibus possumus, et tantum outputa eligere, verbi gratia, tesseram administratoris.
In hoc casu omnes vulnerabilitates progressionis reperiemus vel probationem adhibebimus tesseram administratoris tutam esse.
Animadverti potest classicam institutionis exsecutionem cum certis input tionibus datam esse specialem casum exsecutionis symbolicae.
Ergo, mea indoles VM in emulatione moduli virtualis apparatus operari potest.
In commentationibus ad priorem articulum reperire potest aequis reprehensio formalis verificationis cum disceptatione de infirmitatibus eius.
Praecipuae quaestiones sunt:
- CREPITUS combinatorius, cum formalis verificationis ultimo descendit ad P=NP
- Processus vocat ad systema fasciculi, retiacula et alia ad repositionem externam difficilius verificando
- Cimes in specificatione, cum emptor vel programmator aliquid intendit, sed accurate in technica specificatione non satis expressit.
Quam ob rem ratio verificabitur et specificationi obtemperabit, sed aliquid omnino aliud faciet quam quod ab ea exspectantur creatores.
Cum in hoc articulo maxime considero usum verificationis formalis in praxi, caput meum nunc non movebo contra parietem, et rationem eligam ubi algorithmica complexitas et numerus vocatorum externarum minimus est.
Cum captiosus contractus optime conveniat his requisitis, electio incidit in contractibus vehi ex undarum suggestu: non sunt Turing integra, et eorum maxima multiplicitas artificiose limitata est.
Sed ea solummodo ex parte technica considerabimus.
Praeter omnia, formalis verificationis imprimis erit in exigendis pro quibusvis contractibus: fieri solet impossibile est errorem contractum corrigere postquam emissus est.
Et sumptus talium errorum altissimus esse potest, cum satis magnae pecuniae copia saepe in contractibus callidorum reconduntur.
Mea machina virtualis symbolica in PHP et Pythone scripta est, et utitur Z3Prover ex Investigatione Microsoft ad solvendas formulas resultantes SMT.
In suo nucleo efficax est quaestionis multi-transactionalis, quam
sino vos solutiones vel vulnerabilitates invenire, etiamsi plures operationes requirat.
etiam una ex potentissimis compagibus symbolicis ad vulnerabilitatem Ethereum inveniendis, tantum hanc facultatem paucis abhinc mensibus addidit.
Sed memorabile est quod contractus aetheris magis complexi sunt et Turingus perfecti.
PHP fontem codicem EQUITATIO captiosae contractus in pythonem script, in quo programma exhibetur ut Z3 SMT-compatible systema contractuum status et condiciones pro suis transitus exhibetur;
Nunc quid intus agatur planius describam.
Sed primum pauca verba de ride callidi linguae contractae.
Est utilitatis et elocutionis subnixa programmandi lingua iners consilio.
EQUITO separatim intra claustrum decurrit et notitias ex repositione coniungi cum pera usoris recuperare et scribere potest.
Adnectere potes pactionem vehi cum singulis pera, et effectus executionis erit tantum VERA vel FALSA.
VERA significat quod dolor contractus permittit transactionem, et falsum significat quod prohibet.
Simplex exemplum: scriptum translationem prohibere potest, si crumena minor quam 100 est.
Exemplum, Lupus, Capra et Brassica idem sumam, sed iam in forma contractus acri.
Usor pecuniam a pera retrahere non poterit in quo contractus explicatur donec omnes in alteram partem emiserit.
#Извлекаем положение всех объектов из блокчейна
let contract = tx.sender
let human= extract(getInteger(contract,"human"))
let wolf= extract(getInteger(contract,"wolf"))
let goat= extract(getInteger(contract,"goat"))
let cabbage= extract(getInteger(contract,"cabbage"))
#Это так называемая дата-транзакция, в которой пользователь присылает новые 4 переменные.
#Контракт разрешит её только в случае если все объекты останутся в сохранности.
match tx {
case t:DataTransaction =>
#Извлекаем будущее положение всех объектов из транзакции
let newHuman= extract(getInteger(t.data,"human"))
let newWolf= extract(getInteger(t.data,"wolf"))
let newGoat= extract(getInteger(t.data,"goat"))
let newCabbage= extract(getInteger(t.data,"cabbage"))
#0 обозначает, что объект на левом берегу, а 1 что на правом
let humanSide= human == 0 || human == 1
let wolfSide= wolf == 0 || wolf == 1
let goatSide= goat == 0 || goat == 1
let cabbageSide= cabbage == 0 || cabbage == 1
let side= humanSide && wolfSide && goatSide && cabbageSide
#Будут разрешены только те транзакции, где с козой никого нет в отсутствии фермера.
let safeAlone= newGoat != newWolf && newGoat != newCabbage
let safe= safeAlone || newGoat == newHuman
let humanTravel= human != newHuman
#Способы путешествия фермера туда и обратно, с кем-то либо в одиночку.
let t1= humanTravel && newWolf == wolf + 1 && newGoat == goat && newCabbage == cabbage
let t2= humanTravel && newWolf == wolf && newGoat == goat + 1 && newCabbage == cabbage
let t3= humanTravel && newWolf == wolf && newGoat == goat && newCabbage == cabbage + 1
let t4= humanTravel && newWolf == wolf - 1 && newGoat == goat && newCabbage == cabbage
let t5= humanTravel && newWolf == wolf && newGoat == goat - 1 && newCabbage == cabbage
let t6= humanTravel && newWolf == wolf && newGoat == goat && newCabbage == cabbage - 1
let t7= humanTravel && newWolf == wolf && newGoat == goat && newCabbage == cabbage
let objectTravel = t1 || t2 || t3 || t4 || t5 || t6 || t7
#Последняя строка в разделе транзакции описывает разрешающее транзакцию условие.
#Переменные транзакции должны иметь значения 1 или 0, все объекты должны
#быть в безопасности, а фермер должен переплывать реку в одиночку
#или с кем-то на каждом шагу
side && safe && humanTravel && objectTravel
case s:TransferTransaction =>
#Транзакция вывода средств разрешена только в случае если все переплыли на другой берег
human == 1 && wolf == 1 && goat == 1 && cabbage == 1
#Все прочие типы транзакций запрещены
case _ => false
}
PHP primum omnes variabiles e contrahendo acri in forma clavium earum extrahit et variabilis expressionis Boolean correspondens.
cabbage: extract ( getInteger ( contract , "cabbage" ) )
goat: extract ( getInteger ( contract , "goat" ) )
human: extract ( getInteger ( contract , "human" ) )
wolf: extract ( getInteger ( contract , "wolf" ) )
fState: human== 1 && wolf== 1 && goat== 1 && cabbage== 1
fState:
wolf:
goat:
cabbage:
cabbageSide: cabbage== 0 || cabbage== 1
human: extract ( getInteger ( contract , "human" ) )
newGoat: extract ( getInteger ( t.data , "goat" ) )
newHuman: extract ( getInteger ( t.data , "human" ) )
goatSide: goat== 0 || goat== 1
humanSide: human== 0 || human== 1
t7: humanTravel && newWolf== wolf && newGoat== goat && newCabbage== cabbage
t3: humanTravel && newWolf== wolf && newGoat== goat && newCabbage== cabbage + 1
t6: humanTravel && newWolf== wolf && newGoat== goat && newCabbage== cabbage - 1
t2: humanTravel && newWolf== wolf && newGoat== goat + 1 && newCabbage== cabbage
t5: humanTravel && newWolf== wolf && newGoat== goat - 1 && newCabbage== cabbage
t1: humanTravel && newWolf== wolf + 1 && newGoat== goat && newCabbage== cabbage
t4: humanTravel && newWolf== wolf - 1 && newGoat== goat && newCabbage== cabbage
safeAlone: newGoat != newWolf && newGoat != newCabbage
wolfSide: wolf== 0 || wolf== 1
humanTravel: human != newHuman
side: humanSide && wolfSide && goatSide && cabbageSide
safe: safeAlone || newGoat== newHuman
objectTravel: t1 || t2 || t3 || t4 || t5 || t6 || t7
PHP deinde in Z3Prover descriptionem systematis SMT compatibilis Pythonis convertit.
Notitia ansa involvitur, ubi variabilium tabularum indicem i, transactiones variabilium index i+1, et variabiles expressiones cum expressionibus regulas transitus a statu priore ad proximum pone.
Hoc ipsum cor machinae virtualis nostrae est, quae multam machinam inquisitionis transactionalis praebet.
fState: And( And( And( human[Steps] == 1 , wolf[Steps] == 1 ) , goat[Steps] == 1 ) , cabbage[Steps] == 1 )
final: fState[Steps]
fState:
wolf:
goat:
cabbage:
cabbageSide: Or( cabbage[i] == 0 , cabbage[i] == 1 )
goatSide: Or( goat[i] == 0 , goat[i] == 1 )
humanSide: Or( human[i] == 0 , human[i] == 1 )
t7: And( And( And( humanTravel[i] , wolf == wolf[i] ) , goat[i+1] == goat[i] ) , cabbage == cabbage[i] )
t3: And( And( And( humanTravel[i] , wolf == wolf[i] ) , goat[i+1] == goat[i] ) , cabbage == cabbage[i] + 1 )
t6: And( And( And( humanTravel[i] , wolf == wolf[i] ) , goat[i+1] == goat[i] ) , cabbage == cabbage[i] - 1 )
t2: And( And( And( humanTravel[i] , wolf == wolf[i] ) , goat[i+1] == goat[i] + 1 ) , cabbage == cabbage[i] )
t5: And( And( And( humanTravel[i] , wolf == wolf[i] ) , goat[i+1] == goat[i] - 1 ) , cabbage == cabbage[i] )
t1: And( And( And( humanTravel[i] , wolf == wolf[i] + 1 ) , goat[i+1] == goat[i] ) , cabbage == cabbage[i] )
t4: And( And( And( humanTravel[i] , wolf == wolf[i] - 1 ) , goat[i+1] == goat[i] ) , cabbage == cabbage[i] )
safeAlone: And( goat[i+1] != wolf , goat[i+1] != cabbage )
wolfSide: Or( wolf[i] == 0 , wolf[i] == 1 )
humanTravel: human[i] != human[i+1]
side: And( And( And( humanSide[i] , wolfSide[i] ) , goatSide[i] ) , cabbageSide[i] )
safe: Or( safeAlone[i] , goat[i+1] == human[i+1] )
objectTravel: Or( Or( Or( Or( Or( Or( t1[i] , t2[i] ) , t3[i] ) , t4[i] ) , t5[i] ) , t6[i] ) , t7[i] )
data: And( And( And( side[i] , safe[i] ) , humanTravel[i] ) , objectTravel[i] )
Condiciones ordinantur et inseruntur in template scriptionem destinatam ad describendam systema SMT in Pythone.
blank template
import json
from z3 import *
s = Solver()
Steps=7
Num= Steps+1
$code$
#template, only start rest
s.add(data + start)
#template
s.add(final)
ind = 0
f = open("/var/www/html/all/bin/python/log.txt", "a")
while s.check() == sat:
ind = ind +1
print ind
m = s.model()
print m
print "traversing model..."
#for d in m.decls():
#print "%s = %s" % (d.name(), m[d])
f.write(str(m))
f.write("nn")
exit()
#s.add(Or(goat[0] != s.model()[data[0]] )) # prevent next model from using the same assignment as a previous model
print "Total solution number: "
print ind
f.close()
Ad ultimum statum in tota catena, regulae quae in sectione transactionis translationis specificatae sunt, applicantur.
Hoc significat quod Z3Prover exspectabit prorsus tales condiciones condiciones quae tandem permittit pecunias a contractu deduci.
Quam ob rem statim exemplum contractus SMT plene utilitatis accipimus.
Videre potes simillimum esse exemplaris ex antecedenti articulo, quem manually posui.
Completed template
import json
from z3 import *
s = Solver()
Steps=7
Num= Steps+1
human = [ Int('human_%i' % (i + 1)) for i in range(Num) ]
wolf = [ Int('wolf_%i' % (i + 1)) for i in range(Num) ]
goat = [ Int('goat_%i' % (i + 1)) for i in range(Num) ]
cabbage = [ Int('cabbage_%i' % (i + 1)) for i in range(Num) ]
nothing= [ And( human[i] == human[i+1], wolf[i] == wolf[i+1], goat[i] == goat[i+1], cabbage[i] == cabbage[i+1] ) for i in range(Num-1) ]
start= [ human[0] == 1, wolf[0] == 0, goat[0] == 1, cabbage[0] == 0 ]
safeAlone= [ And( goat[i+1] != wolf[i+1] , goat[i+1] != cabbage[i+1] ) for i in range(Num-1) ]
safe= [ Or( safeAlone[i] , goat[i+1] == human[i+1] ) for i in range(Num-1) ]
humanTravel= [ human[i] != human[i+1] for i in range(Num-1) ]
cabbageSide= [ Or( cabbage[i] == 0 , cabbage[i] == 1 ) for i in range(Num-1) ]
goatSide= [ Or( goat[i] == 0 , goat[i] == 1 ) for i in range(Num-1) ]
humanSide= [ Or( human[i] == 0 , human[i] == 1 ) for i in range(Num-1) ]
t7= [ And( And( And( humanTravel[i] , wolf[i+1] == wolf[i] ) , goat[i+1] == goat[i] ) , cabbage[i+1] == cabbage[i] ) for i in range(Num-1) ]
t3= [ And( And( And( humanTravel[i] , wolf[i+1] == wolf[i] ) , goat[i+1] == goat[i] ) , cabbage[i+1] == cabbage[i] + 1 ) for i in range(Num-1) ]
t6= [ And( And( And( humanTravel[i] , wolf[i+1] == wolf[i] ) , goat[i+1] == goat[i] ) , cabbage[i+1] == cabbage[i] - 1 ) for i in range(Num-1) ]
t2= [ And( And( And( humanTravel[i] , wolf[i+1] == wolf[i] ) , goat[i+1] == goat[i] + 1 ) , cabbage[i+1] == cabbage[i] ) for i in range(Num-1) ]
t5= [ And( And( And( humanTravel[i] , wolf[i+1] == wolf[i] ) , goat[i+1] == goat[i] - 1 ) , cabbage[i+1] == cabbage[i] ) for i in range(Num-1) ]
t1= [ And( And( And( humanTravel[i] , wolf[i+1] == wolf[i] + 1 ) , goat[i+1] == goat[i] ) , cabbage[i+1] == cabbage[i] ) for i in range(Num-1) ]
t4= [ And( And( And( humanTravel[i] , wolf[i+1] == wolf[i] - 1 ) , goat[i+1] == goat[i] ) , cabbage[i+1] == cabbage[i] ) for i in range(Num-1) ]
wolfSide= [ Or( wolf[i] == 0 , wolf[i] == 1 ) for i in range(Num-1) ]
side= [ And( And( And( humanSide[i] , wolfSide[i] ) , goatSide[i] ) , cabbageSide[i] ) for i in range(Num-1) ]
objectTravel= [ Or( Or( Or( Or( Or( Or( t1[i] , t2[i] ) , t3[i] ) , t4[i] ) , t5[i] ) , t6[i] ) , t7[i] ) for i in range(Num-1) ]
data= [ Or( And( And( And( side[i] , safe[i] ) , humanTravel[i] ) , objectTravel[i] ) , nothing[i]) for i in range(Num-1) ]
fState= And( And( And( human[Steps] == 1 , wolf[Steps] == 1 ) , goat[Steps] == 1 ) , cabbage[Steps] == 1 )
final= fState
#template, only start rest
s.add(data + start)
#template
s.add(final)
ind = 0
f = open("/var/www/html/all/bin/python/log.txt", "a")
while s.check() == sat:
ind = ind +1
print ind
m = s.model()
print m
print "traversing model..."
#for d in m.decls():
#print "%s = %s" % (d.name(), m[d])
f.write(str(m))
f.write("nn")
exit()
#s.add(Or(goat[0] != s.model()[data[0]] )) # prevent next model from using the same assignment as a previous model
print "Total solution number: "
print ind
f.close()
Post launch, Z3Prover dolor contractum solvit et catenam negotiorum nobis praebet, quae pecunias recedere nos sinit;
Winning transaction chain found:
Data transaction: human= 0, wolf= 0, goat= 1, cabbage= 0
Data transaction: human= 1, wolf= 0, goat= 1, cabbage= 1
Data transaction: human= 0, wolf= 0, goat= 0, cabbage= 1
Data transaction: human= 1, wolf= 1, goat= 0, cabbage= 1
Data transaction: human= 0, wolf= 1, goat= 0, cabbage= 1
Data transaction: human= 1, wolf= 1, goat= 1, cabbage= 1
Data transaction: human= 1, wolf= 1, goat= 1, cabbage= 1
Transfer transaction
Praeter porttitor contractus, cum tuis contractibus experiri potes vel hoc exemplum simplex experiri, quod in 2 transactionibus solvitur.
let contract = tx.sender
let a= extract(getInteger(contract,"a"))
let b= extract(getInteger(contract,"b"))
let c= extract(getInteger(contract,"c"))
let d= extract(getInteger(contract,"d"))
match tx {
case t:DataTransaction =>
let na= extract(getInteger(t.data,"a"))
let nb= extract(getInteger(t.data,"b"))
let nc= extract(getInteger(t.data,"c"))
let nd= extract(getInteger(t.data,"d"))
nd == 0 || a == 100 - 5
case s:TransferTransaction =>
( a + b - c ) * d == 12
case _ => true
}
Cum haec ipsa prima versio est, syntaxin valde contracta est et cimices esse possunt.
In sequentibus articulis, ulteriorem progressionem VM operire cogito, et monstrare quomodo possis contractus captiosos formaliter verificari cum eius auxilio, et non modo solvere.
Mores virtualis apparatus est available at
Codicis symbolici VM posito fonte in ordine et commentarios ibi addendo, GitHub gratis accessum apponere cogito.
Source: www.habr.com