DafnyBench: Melhorando a Verificação de Software com Aprendizado de Máquina
DafnyBench avalia ferramentas de verificação de software, abrindo caminho para uma programação confiável.
― 6 min ler
Índice
- A Necessidade de Software Confiável
- O Que É Verificação Formal?
- Desafios na Verificação Formal
- O Papel do Machine Learning
- A Importância dos Benchmarks
- Apresentando o DafnyBench
- Obtendo Programas pro DafnyBench
- Como o DafnyBench Funciona?
- Testando os Modelos
- O Efeito do Feedback
- Resultados do DafnyBench
- Olhando pra Frente
- O Futuro da Verificação de Software
- Conclusão
- Fonte original
- Ligações de referência
DafnyBench é um novo benchmark criado pra testar e melhorar ferramentas de verificação de software usando sistemas de machine learning. Essa ferramenta foca na Verificação Formal, que é um jeito de garantir que o software funcione exatamente como esperado, usando provas matemáticas.
A Necessidade de Software Confiável
Software tá em todo lugar na nossa vida. Desde aplicativos simples até sistemas complexos que controlam aviões ou dispositivos médicos, a gente depende que o software funcione direitinho. Mas, mesmo software bem escrito pode ter bugs que levam a falhas. Já rolou incidentes sérios, tipo a explosão do foguete Ariane-V, que foi causada por erros de software. Esses problemas mostram como é importante garantir que o software funcione certo.
O Que É Verificação Formal?
Verificação formal é um método que prova se o software atende a certos critérios e se comporta como esperado. Ele usa lógica e matemática pra criar provas que mostram a correção do design do software. Embora esse processo possa garantir software confiável, geralmente é caro e consome muito tempo.
Desafios na Verificação Formal
Apesar do seu potencial, a verificação formal não é tão comum. Um dos principais motivos é que pode exigir muito mais esforço do que simplesmente escrever o código. As ferramentas disponíveis pra verificação geralmente têm uma curva de aprendizado bem íngreme, o que significa que muita gente não tem o treinamento necessário pra usá-las de forma eficaz. Com isso, o número de pessoas capazes de fazer verificação formal é limitado.
O Papel do Machine Learning
Avanços em machine learning, especialmente em modelos de linguagem grandes (LLMs), têm o potencial de facilitar muito a verificação formal. Automatizando algumas das tarefas complexas envolvidas na verificação, esses modelos podem reduzir custos e incentivar o uso mais amplo de métodos formais. Os pesquisadores sonham com um futuro onde a verificação formal se torne um passo fácil no desenvolvimento de software, como compilar código.
A Importância dos Benchmarks
Pra melhorar o desempenho das ferramentas de verificação, é fundamental ter benchmarks que possam testar com precisão suas capacidades. Benchmarks permitem comparações justas entre diferentes ferramentas e ajudam a medir o progresso ao longo do tempo. Atualmente, os benchmarks existentes para verificação formal são bem pequenos em comparação com os usados em áreas relacionadas, como provas de teoremas matemáticos.
Apresentando o DafnyBench
O DafnyBench quer preencher essa lacuna fornecendo um benchmark grande e variado pra verificação de software. No total, ele contém 782 Programas verificados escritos em Dafny, uma linguagem projetada especificamente pra verificação formal. Esses programas têm o objetivo de ajudar modelos de machine learning a aprender como produzir software confiável.
Obtendo Programas pro DafnyBench
Os programas no DafnyBench vêm de várias fontes. Os pesquisadores coletaram programas verificados em Dafny do GitHub, onde muitos desenvolvedores compartilham seu código. Esse processo envolveu a coleta de arquivos públicos de Dafny, garantindo que os dados usados pra testes fossem legítimos e acessíveis. Depois de filtrar os arquivos e verificar se estavam em conformidade com os padrões necessários, os pesquisadores montaram um conjunto de dados com uma ampla gama de complexidade em programas de software.
Como o DafnyBench Funciona?
O DafnyBench funciona apresentando modelos de machine learning programas que não têm certas anotações, que são cruciais pra verificação. Os modelos têm a tarefa de preencher essas lacunas pra que os programas possam ser verificados com sucesso usando o verificador Dafny. Essa configuração fornece informações valiosas sobre como cada modelo se sai e onde melhorias são necessárias.
Testando os Modelos
No processo de avaliação, os pesquisadores testaram vários modelos de linguagem grandes populares, incluindo GPT-4 e Claude 3. Eles mediram quão eficazmente esses modelos conseguiam gerar as anotações necessárias pros programas. Alguns modelos se saíram melhor que outros, com o Claude 3 mostrando uma taxa de sucesso maior que muitos de seus concorrentes.
O Efeito do Feedback
Os pesquisadores também investigaram como mensagens de erro do verificador Dafny impactaram o desempenho dos modelos. Eles descobriram que, depois de receber feedback sobre erros de validação, os modelos conseguiam melhorar suas taxas de sucesso significativamente. Mas, conforme a dificuldade dos programas aumentava-seja por complexidade ou pelas anotações necessárias-o desempenho dos modelos muitas vezes deixava a desejar.
Resultados do DafnyBench
Os resultados dos testes com diferentes modelos no DafnyBench destacaram diferenças significativas nas capacidades deles. Alguns modelos se destacaram em tarefas mais simples mas tiveram dificuldades com programas mais complexos. Essa variabilidade reforça a necessidade de melhoria contínua e refinamento nos modelos de machine learning para verificação de software.
Olhando pra Frente
As descobertas do DafnyBench oferecem um caminho pra futuros avanços na verificação formal. Ao criar benchmarks maiores e mais desafiadores, os pesquisadores podem ajudar a desenvolver melhores ferramentas de verificação. O objetivo é criar modelos que consigam entender e processar efetivamente programas de software complexos, reduzindo a incidência de bugs em software.
O Futuro da Verificação de Software
Conforme o machine learning continua a evoluir, o potencial pra melhorar a verificação formal cresce. A ideia é que, a longo prazo, os LLMs não só ajudem a verificar programas existentes, mas também possam ajudar a gerar novo código que seja intrinsecamente verificável. Ao unir o desenvolvimento de software e a verificação formal, podemos esperar um futuro onde o software é mais confiável e robusto.
Conclusão
O DafnyBench representa um avanço significativo na busca por verificação de software confiável. Ao aproveitar o machine learning, os pesquisadores esperam tornar a verificação formal acessível pra um público mais amplo, melhorando a qualidade do software em várias aplicações. Com esforços contínuos pra expandir benchmarks e refinar modelos, o futuro da verificação de software parece promissor.
Título: DafnyBench: A Benchmark for Formal Software Verification
Resumo: We introduce DafnyBench, the largest benchmark of its kind for training and evaluating machine learning systems for formal software verification. We test the ability of LLMs such as GPT-4 and Claude 3 to auto-generate enough hints for the Dafny formal verification engine to successfully verify over 750 programs with about 53,000 lines of code. The best model and prompting scheme achieved 68% success rate, and we quantify how this rate improves when retrying with error message feedback and how it deteriorates with the amount of required code and hints. We hope that DafnyBench will enable rapid improvements from this baseline as LLMs and verification techniques grow in quality.
Autores: Chloe Loughridge, Qinyi Sun, Seth Ahrenbach, Federico Cassano, Chuyue Sun, Ying Sheng, Anish Mudide, Md Rakib Hossain Misu, Nada Amin, Max Tegmark
Última atualização: 2024-06-12 00:00:00
Idioma: English
Fonte URL: https://arxiv.org/abs/2406.08467
Fonte PDF: https://arxiv.org/pdf/2406.08467
Licença: https://creativecommons.org/licenses/by/4.0/
Alterações: Este resumo foi elaborado com a assistência da AI e pode conter imprecisões. Para obter informações exactas, consulte os documentos originais ligados aqui.
Obrigado ao arxiv pela utilização da sua interoperabilidade de acesso aberto.
Ligações de referência
- https://openreview.net/group?id=NeurIPS.cc/2024/Conference#tab-your-consoles%
- https://openreview.net/group?id=NeurIPS.cc/2024/Datasets_and_Benchmarks_Track#tab-recent-activity%
- https://www.youtube.com/watch?v=qnHn8W1Em6E
- https://esamultimedia.esa.int/docs/esa-x-1819eng.pdf
- https://en.wikipedia.org/wiki/Shellshock_
- https://github.com/sun-wendy/DafnyBench
- https://doc.rust-lang.org/stable/book/
- https://github.com/534014913/dafl
- https://github.com/hath995/Dafny-Grind75
- https://github.com/vitorhugo13/feup-mfes
- https://github.com/Eggy115/Dafny
- https://github.com/wynnliam/nitwit
- https://github.com/byd110/Dafny-experiences
- https://github.com/TVSSSRIPAD/Formal_Verification_With_Dafny
- https://github.com/nathand99/SENG2011
- https://github.com/Lystora/M2
- https://github.com/boaz23/assertive-programming-assignment-1
- https://github.com/notkazz/t1_MF
- https://github.com/secure-foundations/dafny-exercise
- https://github.com/tareqmahmood/dafny-learn
- https://github.com/ruipmfs/software-specification-p1
- https://github.com/Alex-Amarandei/FMSE-2022-2023
- https://github.com/Zyfarok/fv2020-tms
- https://github.com/SantaC0103/type-definition
- https://github.com/hobo0xcc/laboratory
- https://github.com/jorge-jbs/TFG
- https://github.com/benreynwar/SiLemma
- https://github.com/Consensys/dafny-training
- https://github.com/LucasGCardoso/FormalMethods
- https://github.com/longmanxu/dafny_misc
- https://github.com/jonhnet/vmware-verification-2023
- https://github.com/dslogget/CSU55004---Formal-Verification
- https://github.com/GambuzX/MIEIC_mfes
- https://github.com/vladstejeroiu/Dafny-programs
- https://github.com/pemesteves/MFES_2021
- https://github.com/Dav1216/DafnyPrograms
- https://github.com/KristienN/cs357
- https://github.com/IonitaCatalin/formal-methods-in-software-engineering
- https://github.com/Sup31/Dafny_ProgrammingLanguages
- https://github.com/SteveR-Ncl/CSC8204-Dafny
- https://github.com/guimath/BPTree-verif
- https://github.com/usrnatc/tangent-finder
- https://github.com/ArthurSudbrackIbarra/Trab1-Metodos-Formais
- https://github.com/chanheec/verified-using-dafny
- https://github.com/ES-PUCRS/Metodos_Formais
- https://github.com/lemmy/lets-prove-blocking-queue
- https://github.com/FanC096/Dafny_Programs
- https://github.com/Costinteo/dafny-workout
- https://github.com/AoxueDing/Dafny-Projects
- https://github.com/tannerduve/VerifiedMergeSortDafny
- https://github.com/sligocki/dafny_projects
- https://github.com/alexiadorneles/pucrs-metodos-formais-t1
- https://github.com/eligoldweber/specTesting
- https://github.com/julianafmar/QS_BoilerPlate1
- https://github.com/namin/dafny-sandbox
- https://github.com/isobelm/formal-verification
- https://github.com/Afats/dafny-duck
- https://github.com/kheirmirza/FlexWeek
- https://github.com/Aaryan-Patel-2001/703FinalProject
- https://github.com/pedrovponte/MFS
- https://github.com/guilhermeolivsilva/dafny-mini-project
- https://github.com/Yrh7383111/Software-Verification
- https://github.com/soares-eduardo/circular-queue-implemetation
- https://github.com/TerrificXu/Final-Project-Dafny
- https://github.com/joaopascoalfariafeup/DafnyProjects
- https://github.com/minsungc/bbfny
- https://github.com/trabajoJorge/Formal-methods-of-software-development
- https://github.com/BernardoS4/Software-building-and-verification-Projects
- https://github.com/Tripparsugo/software_analysis
- https://github.com/StephRMcIntyre/cs245-verification
- https://github.com/hath995/dafny-aoc-2019
- https://github.com/JoanaSoaresF/ProjectosCVS
- https://github.com/juletx/MFDS
- https://github.com/MarkValman/groupTheory
- https://github.com/just-me-/dafny-language-server
- https://github.com/ayush268/Invoker
- https://github.com/secure-foundations/ironsync-osdi2023
- https://github.com/dijkstracula/verified-isort
- https://github.com/TonyZhangND/paxos_proof
- https://github.com/maddydobbie/se2011
- https://github.com/jasonthewhale/Dafny_Verify
- https://github.com/langacristian/Formal-Methods-Project
- https://github.com/cassidywaldrip/630-dafny
- https://github.com/monadius/dafny_examples
- https://github.com/MicAu/Workshop
- https://github.com/cristirusu-99/Dafny-Practice
- https://github.com/DanielCavalheiro/CVS-handout1
- https://github.com/tegbesemirone/CS494-final-project
- https://github.com/secure-foundations/iron-sync
- https://github.com/benjaminfjones/stunning-palm-tree
- https://github.com/johnterickson/sat_dfy
- https://github.com/GLaDOS-Michigan/verification-class
- https://github.com/noalero/AssertivePrograming
- https://github.com/dafny-lang/Dafny-VMC
- https://github.com/dafny-lang/libraries
- https://github.com/lamula21/cmsc433
- https://github.com/FaizAther/Correctness
- https://github.com/VicentF/CVS-Projto1
- https://github.com/Nangos/dafleet
- https://github.com/SwampertX/dafny-rope
- https://github.com/tchajed/protocol-verification-fa2023
- https://github.com/olrodr03/vfag
- https://github.com/PaddyZz/Dafny_Learning_Experience
- https://github.com/wenhuizhang/summer-school-2020
- https://github.com/namin/llm-verified-with-monte-carlo-tree-search
- https://github.com/Caitlin-Goodger/DafnyExercises
- https://github.com/byu-dafny/test-generation-examples
- https://github.com/dakotawong/HATRA-2022-Paper
- https://github.com/volodeyka/veri-sparse
- https://github.com/Rayyan-Mehmood/Formal-Verification-Project
- https://github.com/j-kanbour/formal_verication_dafny
- https://github.com/priyadudhe/Simulink-To_dafny
- https://github.com/benreynwar/dafny_experiments
- https://github.com/dwebb9/cs686
- https://github.com/kyrolloszakaria/Program-Verification-Dataset
- https://github.com/Flavius88/Dafny-demo
- https://github.com/zhuzilin/dafny-exercises
- https://github.com/tecnicasilegais/MetodosFormais
- https://github.com/tatayu/CS5232_Project
- https://nips.cc/public/guides/CodeSubmissionPolicy
- https://neurips.cc/public/EthicsGuidelines