LINUX.ORG.RU
Форум — Talks  

Расстроен ли я? Что вы, я нет! Ну слегка...

 , , ,


0

4

Была такая проблема - LLM писали (и пишут) код не слишком надёжно. Их глючит, почти как людей. И нельзя быть уверенным что написанный LLM код - надёжен. Были нужны программисты, чтобы делать ревью, чтобы нести отвественность за код. Было у этой проблемы решение, называется «формальная верификация». Но оно было жутко дорогое и медленное. И лишь немногие могли себе это удовольствие позволить. Но и этот момент прошёл. Программисты больше не нужны. +- года-двух дело по моему мнению.

https://deepmind.google/blog/introducing-alphaproof-code/

Ребята, не ходите учиться на программиста. Это всё. Полностью. Ещё вероятно нужны будут некоторое время инженеры по формальной верификации, чтобы проверять спеки, но программисты - всё. Даже не могу оценить сколько останется.

По инженерам, буквально вчера узнал что гугл активно тренирует геминея на написание спек (из первых рук практически). Думаю , остальные крупные игроки делают то же. В целом, если вам сейчас не 65 и вы не на пенсии уже, и вы программист или даже инженер по ФВ - вам есть о чём подумать. Они просто верифицируют всё. А не они, так ещё кто нибудь. Это уже совершенно очевидно и дело времени, причём ближайших месяцев (выход технологии в массы я имею ввиду).

// для тех кто не понял, тема топика - цитата из «гадкого Я»

★★★★★

Последнее исправление: AndreyKl (всего исправлений: 7)
Ответ на: комментарий от anc

Тогда понятно, больше вопросов нет, спасибо.

AndreyKl ★★★★★
() автор топика
Ответ на: комментарий от AndreyKl

Было начал расписывать на Rocq да увидел, что ФВ же ещё разделяет свойства программы на синтаксические и семантические? Как минимум функциональный язык для программы захотелось выбрать, ну или может сразу Лисп.

А вот у верификаторов есть же ещё доверенное ядро. Его в принципе можно формально верифицировать, или с этим связаны какие-то фундаментальные ограничения?

ratvier ★★
()
Ответ на: комментарий от CrX

здоровая конкуренция

Конкуренция здоровой не бывает. Это всегда куча негатива, выливаемого друг на друга. Уж сколько пытаются хотябы спорт от этих эффектов избавить. И даже это не получается.

watchcat382 ★★
()
Ответ на: комментарий от ratvier

Гм-гм. Ну, синтаксические нас, скорее, не интересуют. Это больше разработчики компиляторов на это заостряют внимание.

Нас интересуют семантические (т.е. смысловые) свойства - зависает/не зависает. Делает то что нужно/не делает то что нужно.

Первая верифицированная программа на rocq вероятно может выглядеть как то так:

Fixpoint myplus(a, b : Nat) : Nat :=
  match a, b with
  | O, x | x, O => x
  | S a, S b => S (S (myplus a b))
  end.

Theorem myplus_correct : forall a b, myplus a b = a + b.
Proof. Admitted.



Т.е. мы доказываем что определённая нами функция myplus работает так же как стандартный плюс. Ну и вместо адмиттед - соотвественно доказательство. (За чистоту синтаксиса не ручаюсь, если не компилируется, можно спросить у Гемини/Дипсик, ну или в тред).

Реальные языки сильно сложнее. Но это какие то общие начала в любом случае.

А в целом хороший учебник тут https://softwarefoundations.cis.upenn.edu/ ,

AndreyKl ★★★★★
() автор топика
Последнее исправление: AndreyKl (всего исправлений: 2)
Ответ на: комментарий от monk

Роман, как обычно, ты поднимаешь много важных и интересных тем, причём в одном топике :). С тобой по другому просто не припомню дискуссий - всегда очень глубокие. Хотелось бы пообщаться чуть подробнее чем поверхностно, но сейчас времени в обрез, постараюсь на выходных ответить.

AndreyKl ★★★★★
() автор топика
Последнее исправление: AndreyKl (всего исправлений: 1)
Ответ на: комментарий от AndreyKl

Сложение находится в классе P, в нём по определению можно требовать от реализации оставку. Я же имеюю ввиду, что-то такое помещается в спецификацию, но если дописывать в foo что-то ещё, то это уже упорощать цикл до рекурсии и всё такое?

(*
void foo(bool x) {
    for(;;) {
        if (x) {
          return;
        }
    }
}
*)

CoInductive foo_diverges : bool -> Prop :=
| FooLoopAgain : foo_diverges false -> foo_diverges false.

CoFixpoint foo_false_diverges : foo_diverges false :=
  FooLoopAgain foo_false_diverges.

ratvier ★★
()
Ответ на: комментарий от ratvier

Есть подход «упрощать цикл до рекурсии», так делает например hax. Другой подход - использовать развитую семантику, здесь можно посмотреть Choice Trees и как они используются в vellvm для примера (https://github.com/vellvm/ctrees).

Но это (верификация реальной программы) может быть немного замороченнее чем выглядит на первый взгляд.

Если верифицировать что то хоть чуть чуть близкое к реальности, лучше взять существующие решения, rocq-of-rust, aneas.

https://github.com/AeneasVerif/aeneas

https://github.com/formal-land/rocq-of-rust

Конкретно в вашем случае для примера я бы использовал choice trees.

Иначе (без построения семантики) вам просто будет трудно вписать эффекты в чисто функциональный язык.

AndreyKl ★★★★★
() автор топика
Последнее исправление: AndreyKl (всего исправлений: 2)
Ответ на: комментарий от ratvier

как строить семантику, кстати, есть пример в книке Члипалы «Certified Programming with Dependent Types - Adam Chlipala» ( https://watermark02.silverchair.com/book_9780262317870.pdf )

в конце главы 5 «Infinite data and proofs» (как раз то что Вам интересно на сколько я понял), есть подраздел «Simple Modeling of Nonterminating Programs». И там даётся пример семантики для простой незавершающейся программы.

AndreyKl ★★★★★
() автор топика
Ответ на: комментарий от ratvier

Для Вашего конкретно случая привести незамысловатую семантику я затрудняюсь. Сложности возникают из-за «неструктурированного» выхода из цикла. В целом это делается, но машинерии нужно больше. Я бы привёл такую простую семантику (по образцу из Члипалы)

Definition var := nat.

Inductive exp : Set := Bool : var -> exp.

Inductive cmd : Set :=
| ForWithReturn : cmd -> exp -> cmd.

Тут немного ограниченно, трактовка такая - код может идти только до if _ return. Сам return не может ничего возвращать, только выходит из цикла. Т.е. это у меня на самом деле «repeat с until e», нежели чем представленная у Вас форма фора. Но это не слишком важные детали для примера.

Ну и отношение evalCmd соотвествующее
CoInductive evalCmd : vars -> cmd -> vars -> Prop :=
| EvalForTrue : ∀ vs vs2 e c, 
  evalExp vs e <> 0
  -> evalCmd vs c vs2
  -> evalCmd vs (ForWithReturn c e) vs2
| EvalForFalse : ∀ vs1 vs2 vs3 e c, 
  evalExp vs1 e = 0
  -> evalCmd vs1 c vs2
  -> evalCmd vs2 (ForWithReturn c e) vs3
  -> evalCmd vs1 (ForWithReturn c e) vs3.

Остальные определения (в первую очередь evalExp) надо сделать по образцу у Члипалы (в целом его по-моему подойдут).
Не воспринимайте за истину в последней инстанции - код не проверялся + я могу ошибаться в чём-то.
Если что то не сходится и нужно задать вопрос - задавайте.

AndreyKl ★★★★★
() автор топика
Последнее исправление: AndreyKl (всего исправлений: 2)
Вы не можете добавлять комментарии в эту тему: только для зарегистрированных, score>=50.