13 11 13 Лекция 9 Предикатное программирование 7

13. 11. 13 Лекция 9 Предикатное программирование 7. Технология предикатного программирования (прод) 7. 5. Система автоматизации доказательства PVS Язык спецификаций PVS Описания типов, констант, переменных, формул, утверждений, рекурсивные определения Проверка типов (typechecking) Выражения, декларации, теории Библиотеки теорий PVS Блок доказательства (Prover) Основные принципы. Дерево доказательства Команды доказательства. Пример Система правил вывода – команд prover’a

7. Технология предикатного программирования 7. 5. Система автоматизации доказательства PVS

Система PVS Платформа: SUN 4(Spark) + Solaris, PC + Redhat Linux Реаизована: на Common Lisp, Lisp Allegro Окружение: редактор Emacs. Интерфейс с PVS реализован с помощью команд Emacs. Спецификация для PVS: набор файлов с расширением “pvs”, каждый файл содержит набор теорий Ассоциированные файлы: доказательство с раширением “prf”, бинарное представление с расширением “bin”, контекст Схема работы PVS - ввод спецификации в редакторе Emacs - parsing - typechecking - proving, набор команд для интерактивного доказательства, стратегии и тактики.

Описания типы, переменные, константы, формулы, утверждения (judgements), приведения Описания типов • неинтерпретированные: T: TYPE T 1, T 2, T 3: TYPE - типы разные; для использования в аксиомах • // … // подтипа: S: TYPE FROM T s: TYPE FROM t s_pred: [t -> bool] s: TYPE = (s_pred) • интерпретированные: T: TYPE = intfun: TYPE = [int -> int] subrange(m, n: int): TYPE = { i: int | m <= i AND i <= n } параметры • тип перечисления: T: TYPE = { r, g, b }

• пустота – непустота типов NONEMPTY TYPE+ CONTAINING константы проверка непустоты типа Описания переменных x: VAR bool f: FORMULA (FORALL (x: int): (EXISTS (x: nat): p(x)) AND q(x)) области локализации переменной x Описания констант интерпретированные, неинтерпретированные n: int c: int = 3 f: [int -> int] = (lambda (x: int): x + 1) g(x: int): int = x + 1 эквивалентная форма

f: [int -> [int, nat -> [int -> int]]] = (LAMBDA (x: int): (LAMBDA (y: int), (z: nat): (LAMBDA (w: int): x * (y + w) - z))) эквивалентно f(x: int)(y: int, z: nat)(w: int): int = x * (y + w) - z Другая форма: x, y, w: VAR int z: VAR nat f(x)(y, z)(w): int = x * (y + w) – z смешанные формы

f(x: {x: int | p(x)}): int = x + 1 эквивалентно f(x: (p)): int = x + 1 эквивалентно f((x: int | p(x))): int = x + 1 odd: [nat -> bool] = (LAMBDA (n: nat): EXISTS (m: nat): n = 2 * m + 1) эквивалентная теоретико-множественная форма odd: [nat -> bool] = {n: nat | EXISTS (m: nat): n = 2 * m + 1}

Рекурсивные определения TCC – type consistency condition – условие совместимости типов Определяемая функция должна быть тотальной well-founded TCC – условие правильной организации функции factorial(x: nat): RECURSIVE nat = IF x = 0 THEN 1 ELSE x * factorial(x - 1) ENDIF MEASURE (LAMBDA (x: nat): x) termination. TCC мера (MEASURE) определяет функцию m(x) и порядок < Условие m(y) < m(x) выступает как обобщение механизма доказательства по индукции y=x-1 factorial_TCC 2: OBLIGATION FORALL (x: nat): NOT x = 0 IMPLIES x - 1 < x MEASURE x - более компактное определение меры MEASURE s BY << -- мера с заданием функции порядка

Макросы N: MACRO nat = 100 реализуется безусловная подстановка тела макроса на место любых его вхождений

Typechecking -- анализ семантической согласованности объектов спецификации Теория типов PVS алгоритмически неразрешима. Согласованость типов реализуется доказательством теорем, называемых TCCs - type-correctness conditions Теоремы TCCs прикрепляются к внутреннему представлению спецификации в bin-файле Статус теории: changed, parsed, typechecked, proved fac(n: nat): RECURSIVE nat = IF n = 0 THEN 1 ELSE n * fac(n - 1) ENDIF MEASURE n Function fac is well-typed if n /= 0 => n – 1 >= 0 (the argument is a nat) n /= 0 => n – 1 < n (termination). The type checker (M-x tc) generates type correctness conditions (TCCs)

Описания формул Виды формул: аксиомы (axioms), допущения (assumptions), теоремы (theorems) и утвержденияоблигации (obligations) Команда lemma работает со всеми видами формул AXIOM, POSTULATE – аксиомы CHALLENGE, CLAIM, CONJECTURE, COROLLARY, FACT, FORMULA, LAW, LEMMA, PROPOSITION, SUBLEMMA, THEOREM - теоремы ASSUMPTION – допущения Свободные переменные – под квантором FORALL

Типы языка спецификаций PVS сильная типизация структурная эквивалентность Базисные типы: bool, number (real, rat, int, nat) - в стандартной библиотеке • Subtypes: A: TYPE = {x: B | p(x)} • Function types: [number -> number] • Record types: [# flag: boolean, value: number #] • Tuple types: [boolean, number] • Enumeration types: {red, green, blue}

Подтипы A: TYPE = {x: B | p(x)} A: TYPE = (p) nat: TYPE = { n: int | n >=0 } subrange(n, m: int): TYPE = { i: int | n <= i & i <= m } параметрические типы FORALL (i: int): (i >= 0 IMPLIES (EXISTS (j: int): j >= 0 AND j > i)) можно записать короче FORALL (i: nat): (EXISTS (j: nat): j > i)) где определен в prelude. pvs следующим образом: naturalnumber: NONEMPTY TYPE = {i: integer | i >= 0} CONTAINING 0 nat: NONEMPTY TYPE = naturalnumber

existence TCC при наличии константы f: [ int -> {x: int | p(x)} ] с: f порождает existence TCC f_TCC 1: OBLIGATION (EXISTS (x: int): p(x)) Чтобы гарантировать непустоту типа, применяется t: TYPE = {x: int | 0 < x AND x < 10} CONTAINING 1 Для леммы div_form: FORMULA (FORALL (x, y: int): x /= y IMPLIES (x - y)/(y - x) = -1) генерируется subtype TCC: div_form_TCC 1: OBLIGATION (FORALL (x, y: int): x /= y IMPLIES (y - x) /= 0)

Типы функций Три эквивалентных формы: [t 1, . . . , tn -> t] FUNCTION[t 1, . . . , tn -> t] ARRAY[t 1, . . . , tn -> t] Тип предиката pred[t] и тип множества setof[t] есть тип [t -> bool]. Тип функции [t 1, . . . , tn -> t] есть подтип типа [s 1, . . . , sm -> s] t – подтип s, n = m и si = ti для i =1, . . . , n. Генерируются TCC, называемые domain mismatch TCCs p, q: pred[int] f: [{x: int | p(x)} -> int] g: [{x: int | q(x)} -> int] h: [int -> int] eq 1: FORMULA f = g eq 2: FORMULA f = h

p, q: pred[int] f: [{x: int | p(x)} -> int] g: [{x: int | q(x)} -> int] h: [int -> int] eq 1: FORMULA f = g eq 2: FORMULA f = h Генерируются TCC: eq 1_TCC 1: OBLIGATION (FORALL (x 1: {x : int | q(x)}, y 1 : {x : int | p(x)}) : q(y 1) AND p(x 1)) eq 2_TCC 1: OBLIGATION (FORALL (x 1: int, y 1 : {x : int | p(x)}) : TRUE AND p(x 1))

Типы произведения (tuples), n-ки [t 1, . . . , tn] , где ti – изображение типа (типовое выражение). Нульмерные тупли запрещены. (1, TRUE, (LAMBDA (x: int): x + 1)) – выражение типа [int, bool, [int -> int]]. Функции проекции: `1, `2, . . . , (или proj 1, proj 2, . . . ) i-ая проекция имеет тип [[t 1, . . . , tn] -> ti]. Тип тупля пустой, если тип одной из компонент пустой [t 1, . . . , tn -> t] и [[t 1, . . . , tn] -> t] эквивалентны;

Тип записи [# a 1: t 1, . . . , an: tn #] ai – поле ti – тип поля (изображение типа). x ’ ai – операция взятия поля Тип записи пуст, если тип одной из компонент пуст Порядок указания полей несущественен

Зависимые (dependent) типы Функции, тупли и записи могут быть зависимыми – одна из компонент может зависеть от предыдущих rem: [nat, d: {n: nat | n /= 0} -> {r: nat | r < d}] pfn: [d: pred[dom], [(d) -> ran]] stack: [# size: nat, elements: [{n: nat | n < size} -> t] #] subp(i: int, (j: int | i >= j)): RECURSIVE int = (IF (i=j) THEN 0 ELSE (subp(i, j+1)+1) ENDIF) MEASURE i - j

Виды выражений Logic: TRUE, FALSE, AND, OR, NOT, IMPLIES, FORALL, EXISTS, = Arithmetic: +, -, *, /, <, <=, >, >=, 0; 1; 2; : : : Function application, abstraction ( -expression), and update Coercions - приведение Record construction, selection, and update Tuple construction, projection, and update: id WITH [(0): =42, (1): =12] IF-THEN-ELSE, COND: IF c THEN e 1 ELSE e 2 ENDIF CASES: COND c 1 ->e 1, c 2 ->e 2, c 3 ->e 3 ENDCOND Tables, Inductive definitions

IF-THEN-ELSE выражения IF cond THEN expr 1 ELSE expr 2 ENDIF полиморфное выражение АРИФМЕТИЧЕКИЕ выражения (0, 1, 2, . . . ), унарный -, ^, +, -, *, /. Числа имеют тип real. Неявные подтверждения (judgements) для чисел; 0 – является типа real, rat, int и nat; <, <=, >, >=. ПРИМЕНЕНИЯ ФУНКЦИЙ f(x) также, в инфиксной и префиксной нотации f(0)(2, 3)

Операции (применения функций) Таблица приоритетов Операция Ассоциативность FORALL, EXISTS, LAMBDA, IN None | Left |-, |= Right IFF, <=> Right IMPLIES, =>, WHEN Right OR, /, XOR, ORELSE Right AND, &, &&, /, ANDTHEN Right NOT, ~ None =, /=, ==, <, <=, >, >=, <<, >>, <<=, >>=, <|, |> Left WITH Left WHERE Left @, # Left @@, ##, || Left +, -, ++, Left , /, **, // Left None o Left : , : : , HAS TYPE Left [], <> None ^, ^^ Left ` Left

Связывающие (binding) выражения FORALL, EXISTS, LAMBDA Ламбда-выражения – безымянные функции (LAMBDA (x: int): x + 3) Подкванторные переменные могут быть зависимыми FORALL (x: int), (y: {z: int | x < z}): p(x, y)

LET и WHERE выражения LET x: int = 2, y: int = x * x IN x + y WHERE x: int = 2, y: int = x * x значение = 6 для каждого выражения. транслируются в ламбда-выражения (LAMBDA (x: int) : (LAMBDA (y: int) : x + y)(x * x))(2)

SET выражения Множество есть предикат – функция типа [t -> bool], pred[t], или setof[t], (LAMBDA (x: t): p(x)) или {x: t | p(x)} - эквивалентны Tuple-выражение Выражение типа [t 1, . . . , tn] имеет форму (e 1, . . . , en).

Выражение проекции t: [int, bool, [int -> int]] ft: FORMULA t`2 AND t`1 > t`3(0) ft_deprecated: FORMULA PROJ_2(t) AND PROJ_1(t) > (PROJ_3(t))(0) Выражение-запись Выражение (# a 1 : = e 1, . . . , an : = en #) имеет тип [# a 1: t 1, . . . , an: tn #], где ej имеет тип tj. все компоненты должны присутствовать Для зависимых типов R: TYPE = [# a: int, b: {x: int | x < a} #] r: R = (# a : = 3, b : = 4 #) генерируется недоказуемое TCC: 4 < 3.

Поле записи Переменная r имеет тип записи [# x, y: real #] Доступ к полю x реализуется конструкцией r`x или x(r). Модификация структурного значения Override Expression для функций, записей и туплей identity WITH [(0) : = 1, (1) : = 2] (id WITH [(0) : = 1]) WITH [(1) : = 2] (LAMBDA x: IF x = 1 THEN 2 ELSIF x = 0 THEN 1 ELSE id(x)) R: TYPE = [# a: int, b: [int -> [int, int]] #] r 1: R r 2: R = r 1 WITH [`a : = 0, `b(1)`2 : = 4] f WITH [(-1) |-> 0] с расширением области аргументов

Теории Specication : : = { Theory | Datatype } + Theory : : = Id [ Theory. Formals ] : THEORY [ Exporting ] BEGIN [ Assuming. Part ] [ Theory. Part ] END Id Theory. Formals : : = [ Theory. Formal++', ' ] Theory. Formal : : = [ ( Importing ) ] Theory. Formal. Decl : : = Theory. Formal. Type | Theory. Formal. Const Theory. Formal. Type : : = Ids : { TYPE | NONEMPTY TYPE | TYPE+ } [ FROM Type. Expr ] Theory. Formal. Const : : = Id. Ops : Type. Expr

Пример теории groups [G : TYPE, e : G, o : [G, G->G], inv : [G->G] ] : THEORY BEGIN ASSUMING a, b, c: VAR G associativity : ASSUMPTION a o (b o c) = (a o b) o c unit : ASSUMPTION e o a = a AND a o e = a inverse : ASSUMPTION inv(a) o a = e AND a o inv(a) = e ENDASSUMING left_cancellation: THEOREM a o b = a o c IMPLIES b = c right_cancellation: THEOREM b o a = c o a IMPLIES b = c END groups IMPORTIHG groups[int, 0, +, -]

Алгебраические типы Abstract Datatypes Datatype : : = Id [ Theory. Formals ] : DATATYPE [ WITH SUBTYPES Ids ] BEGIN [ Importing [ ; ] ] [ Assuming. Part ] Datatype. Part END Id Inline. Datatype : : = Id : DATATYPE [ WITH SUBTYPES Ids ] BEGIN [ Importing [ ; ] ] [ Assuming. Part ] Datatype. Part END id Datatype. Part : : = { Constructor : Id. Op [ : Id ] } + Constructor : : = Id. Op [ ( {Id. Ops : Type. Expr }++', ' ) ] datatype -- набор конструкторов с ассоцированными полями и распознавтелями

Алгебраические типы на примере списков list [T: TYPE]: DATATYPE BEGIN null: null? cons(car: T, cdr: list): cons? END list null и cons – конструкторы, null? и cons? – распознаватели, car и cdr – поля выражение CASES: length(s): RECURSIVE nat = CASES s OF null: 0, cons(x, y): length(y) + 1 ENDCASES MEASURE reduce_nat(0, (LAMBDA (x: T), (n: nat): n + 1)) Генерируются 3 теории: list_adt, list_adt_map и list_adt_reduce. Перечисления

Библиотеки теорий PVS Стандартная библиотека prelude. pvs booleans, numbers (real, rational, integer), strings, sets, including definitions and basic properties of finite and infinite sets, functions and relations, equivalences, ordinals, basic definitions and properties of bitvectors, mu calculus, LTL booleans: THEORY BEGIN boolean: NONEMPTY_TYPE bool: NONEMPTY_TYPE = boolean FALSE, TRUE: bool NOT: [bool -> bool] AND, &, OR, IMPLIES, =>, WHEN, IFF, <=>: [bool, bool -> bool] END booleans

NASA Libraries algebra: groups, monoids, rings, etc analysis: real analysis, limits, continuity, derivatives, integrals calculus: axiomatic version of calculus complex: complex numbers co structures: sequences of countable length defined as coalgebra datatypes directed graphs: circuits, maximal subtrees, paths, dags float: floating point numbers and arithmetic graph theory: connectedness, walks, trees, Menger's Theorem ints: integer division, gcd, mod, prime factorization, min, max interval: interval bounds and numerical approximations lnexp: logarithm, exponential and hyperbolic functions lnexp_fnd: foundational definitions of logarithm, exponential and hyperbolic functions

NASA Libraries (cont) orders: abstract orders, lattices, fixedpoints reals: summations, sup, inf, sqrt over the reals, abs lemmas scott: Theories for reasoning about compiler correctness series: power series, comparison test, ratio test, Taylor's theorem sets_aux: powersets, orders, cardinality over finite sets sigma_set: summations over countably finite sets structures: bounded arrays, finite sequences and bags topology: continuity, homeomorphisms, connected and compact spaces, Borel sets/functions trig: trigonometry definitions, identities, approximations trig_fnd: foundational development of trigonometry: proofs of trig axioms vectors: basic properties of vectors while: Semantics for the Programming Language "while"

Prover -- сочетание в PVS языка логики высокого уровня и мощного автоматического prover’a -- комплекс средств поддержки построения доказательств в форме, удобной для восприятия, в целях разработки, отладки, анализа и визуализации доказательств -- реализует значительно бо’льшую степень автоматизации и бо’льшую степень контроля, по сравнению с другими prover’ами Команды доказательства могут быть скомбинированы в стратегии доказательства. Доказательства можно редактировать запускать вновь. Семантический анализ (Type checking) реализуется посредством автоматического доказательства Prover’ом истинности условий, называемых type correctness conditions (TCCs)

Дерево доказательства, вершина цель доказательства, дуга шаг доказательства Каждая цель секвент (sequent) состоит из посылок (antecedents) и следствий (consequents) {-1} A 1 {-2} A 2 [-3] A 3 ………. . --------(A 1 & A 2 & A 3 & …) (B 1 B 2 B 3 …) {1} B 1 [2] B 2 {3} B 3 ………. . A 1, A 2, A 3, …├ B 1, B 2, B 3 , … [-3], [2] формулы из родительского секвента, {-1}, {-2}, {1}, {3} новые формулы Корневая вершина цель вида ├ A, где A теорема, которую нужно доказать. Если доказано, что секвент истинный, то ветвь дерева на нем заканчивается. Есть разные правила. Наиболее простое: если одна из посылок ложная, то секвент истинный. Задача prover’a построить полное дерево доказательства

Пусть имеется секвент A├ B & C Команда split порождает два секвента-потомка: A├ B и A├ C Команда правило (шаг) доказательства Применяемые команды доказательства сохраняются. Команды могут быть введены пользователем или применяться при работе по некоторой стратегии Некоторые команды достаточно гибкие и мощные

Логика PVS -- исчисление секвентов Г, - последовательности формул, A, B – отдельные формулы Структурные правила Пропозиционные правила Правила для равенства Правила для кванторов Правила для IF