Cara menangani array selama bukti ketepatan gaya Hoare

11

Dalam diskusi seputar pertanyaan ini , Gilles menyebutkan dengan benar bahwa bukti kebenaran suatu algoritma yang menggunakan array harus membuktikan bahwa tidak ada akses array di luar batas; tergantung pada model runtime, ini akan menyebabkan kesalahan runtime atau akses ke elemen non-array.

Salah satu teknik umum untuk melakukan pembuktian kebenaran tersebut (setidaknya dalam studi sarjana dan mungkin dalam verifikasi otomatis) adalah dengan menggunakan logika Hoare . Saya tidak menyadari bahwa seperangkat aturan standar berisi apa pun yang berkaitan dengan array; mereka tampaknya terbatas pada variabel monadik.

Saya bisa membayangkan menambahkan aksioma bentuk

$\qquad \displaystyle \frac{}{\{0 \leq i \lt A.\mathrm{length} \land {P[A[i]/E]} \}\ A[i] := E;\ \{P\}}$

Namun, tidak jelas bagi saya bagaimana Anda akan berurusan dengan akses array pada sisi kanan, yaitu jika itu adalah bagian dari ekspresi kompleks dalam beberapa pernyataan . $E$ $x := E$

Bagaimana akses array dapat dimodelkan dalam logika Hoare sehingga tidak adanya akses yang tidak valid dapat dan harus dibuktikan untuk kebenaran program?

Jawaban dapat berasumsi bahwa kami melarang elemen array untuk digunakan dalam pernyataan selain atau sebagai bagian dari beberapa dalam karena ini tidak membatasi ekspresif; kita selalu dapat menetapkan variabel sementara nilai yang diinginkan, yaitu menulis daripada . $A[i] := E$ $E$ $x := E$ $t := A[i];\ \mathtt{if} ( t > 0 ) \dots$ $\mathtt{if} ( A[i] > 0 )\dots$

— Raphael
sumber

8

Aksioma Anda bukan benar-benar aksioma, ini hipotesis yang hilang. Presentasi sederhana dari logika Hoare memanipulasi rumus bentuk mana dan adalah rumus logis dan adalah sebuah perintah. Anda perlu memastikan bahwa terbentuk dengan baik . Dalam bahasa sederhana seperti yang sering digunakan untuk pengenalan pertama yang Hoare logika, baik-formedness adalah sintaksis: itu biasanya masalah memeriksa bahwa $\{P\} C \{P'\}$ $P$ $P'$ $C$ $C$ $C$ sesuai dengan tata bahasa bebas konteks, dan mungkin bahwa variabel bebas berada dalam set yang diizinkan. Jika bahasa menyertakan konstruk yang memiliki kebenaran semantik, seperti akses ke elemen array, Anda perlu menambahkan hipotesis untuk mengekspresikan kebenaran semantik ini.

Secara formal, Anda dapat menambahkan penilaian untuk mengekspresikan koreksi ekspresi dan perintah. Jika ekspresi tidak memiliki efek samping, mereka tidak memerlukan kondisi akhir, hanya kondisi awal. Misalnya, Anda dapat menulis aturan yang terbentuk dengan baik seperti dan hanya memungkinkan ekspresi yang terbentuk dalam perintah:

\frac{{P} E wf}{{P \land 0 \leq E < l e n g t h (A)} A [E] wf} \frac{{P} E_{1} wf {P} E_{2} wf}{{P} E_{1} + E_{2} wf}

$\dfrac{\{P\} \;\; E \text{ wf}} {\{P \wedge 0 \le E < \mathrm{length}(A)\} \;\; A[E] \text{ wf}} \qquad \dfrac{\{P\} \;\; E_1 \text{ wf} \qquad \{P\} \;\; E_2 \text{ wf}} {\{P\} \;\; E_1 + E_2 \text{ wf}}$

\frac{{P [x \leftarrow E]} E wf}{{P [x \leftarrow E]} x := E {P}}

$\dfrac{\{P[x\leftarrow E]\} \;\; E \text{ wf}} {\{P[x\leftarrow E]\} \;\; x := E \{P\}}$

Pendekatan yang berbeda adalah memperlakukan semua ekspresi sebagai well-formed, tetapi untuk membuat ekspresi apa pun yang melibatkan penghitungan yang salah memiliki nilai khusus . Dalam bahasa dengan pemeriksaan run-time bounds, berarti "program ini menimbulkan pengecualian fatal". Anda kemudian akan melacak apakah suatu program salah melalui predikat logis $\mathbf{error}$ $\mathbf{error}$ $\mathbf{Error}$ $\neg\mathbf{Error}$

\frac{}{{P [x \leftarrow E]} x := E {P \lor E r r o r}} \frac{P [x \leftarrow E] ⟹ E ↛ e r r o r}{{P [x \leftarrow E]} x := E {P}}

$\dfrac{} {\{P[x\leftarrow E]\} \;\; x := E \;\; \{P \vee \mathbf{Error}\}} \qquad \dfrac{P[x\leftarrow E] \implies E \not\rightarrow \mathbf{error}} {\{P[x\leftarrow E]\} \;\; x := E \;\; \{P\}}$

Namun pendekatan lain adalah dengan mempertimbangkan triple Hoare untuk menampung hanya jika program berakhir dengan benar. Ini adalah pendekatan yang biasa untuk program nonterminating: postcondition berlaku ketika perintah berakhir, yang mungkin tidak selalu terjadi. Jika Anda memperlakukan kesalahan run-time sebagai non-terminasi, Anda menyapu semua masalah kebenaran di bawah tenda. Anda masih perlu membuktikan kebenaran program tersebut, tetapi itu tidak perlu dalam logika Hoare jika Anda lebih suka formalisme lain untuk tugas itu.

By the way, perhatikan bahwa mengekspresikan apa yang terjadi ketika variabel majemuk seperti array diubah lebih terlibat daripada apa yang Anda tulis. Misalkan adalah, katakanlah, : substitusi tidak akan mengubah , namun tugas dapat membatalkan . Bahkan jika Anda membatasi sintaksis predikat hanya untuk berbicara tentang atom, pertimbangkan tugas bawah prasyarat : Anda tidak dapat membuat substitusi sederhana untuk mendapatkan postcondition yang benar , Anda perlu mengevaluasi $P$ $\mathrm{IsSorted}(A)$ $A[i]\leftarrow E$ $P$ $A[i] \leftarrow P$ $P$ $A[A[0]-1] := A[0]$ $A[0] = 2 \wedge A[1] = 3$ $A[0] = 1 \wedge A[1] = 1$ $A[0]$ (yang bisa sulit secara umum, karena prasyarat mungkin tidak menentukan nilai tunggal yang mungkin untuk ). Anda perlu melakukan substitusi pada array itu sendiri: . Catatan kuliah Mike Gordon memiliki presentasi logika Hoare yang baik dengan array (tetapi tanpa pengecekan kesalahan). $A[0]$ $A \leftarrow A[i\leftarrow E]$

— Gilles 'SANGAT berhenti menjadi jahat'
sumber

0

Seperti yang disebutkan oleh Gilles, ada aksioma penugasan array (lihat catatan Gordon, Bagian 2.1.10 ): Dalam kata-kata, jika Anda memiliki tugas array, maka ganti array asli dengan array yang memiliki posisi nilai . Perhatikan bahwa jika Anda sudah memiliki pada pos, dan menetapkan , maka Anda harus mendapatkan sebagai pra (ya, dalam urutan ini - pembaruan terbaru dijalankan terlebih dahulu!).

\frac{}{{Q [A \mapsto A . s t o r e (i, e x p r)]} A [i] = e x p r {Q}}

$\dfrac{} {\{Q[A \mapsto A.store(i,expr) ] \} \;\; A[i] = expr \;\;\{ Q \}}$ A.store(i,expr)iexprA.store(i,vi)A[j]=vjA.store(j,vj).store(i,vi)

Selain itu, kita perlu aksioma akses array: A.store(i,v)[i]bisa diganti dengan v( "jika Anda mengakses th elemen yang Anda baru saja diperbarui, kemudian kembali nilai yang diberikan"). $i$

Saya pikir untuk membuktikan program dengan array sudah benar ("tidak ada akses yang tidak terbatas"), aksioma di atas sudah cukup. Mari kita perhatikan programnya:

...
A[i] = 12
...

Kami akan membubuhi keterangan program ini:

...
@ {0<i<A_length}
A[i] = 12
...

di mana A_lengthadalah variabel yang menentukan panjang array. Sekarang coba buktikan anotasi - yaitu, kerjakan mundur (dari bawah ke atas, "seperti biasanya" dalam bukti Hoare). Jika di atas Anda dapatkan {false}, maka akses di luar batas dapat terjadi, jika tidak, ekspresi yang Anda dapatkan adalah prasyarat di mana tidak ada akses di luar batas yang dimungkinkan. (juga, kita perlu memastikan bahwa ketika array dibuat seperti int A=int[10];pada post-condition yang kita miliki {A_length==10}).

— Ayrat
sumber

Aksioma Anda tidak memodelkan akses di luar batas: mereka bahkan tidak menyebutkan panjangnya! Dalam contoh program Anda, bagaimana Anda berhubungan lengthke A?

— Gilles 'SANGAT berhenti menjadi jahat'

Benar, aksioma tidak memodelkan akses yang terikat. Pertama, untuk membuktikan suatu program sudah benar, saya menambahkan anotasi yang mengharuskan akses dalam batas. ( lengthBerganti nama A_length.) Kedua, kita perlu berbagai aksioma "penciptaan" seperti int[] a = int[length] {a_length==length}. Saya pikir ini sudah cukup.

— Ayrat