This is a listing of all goals defined over the current specification. Axioms are marked yellow, proved theorems green and unproved theorems blue. Click on individual names to get more information on the proof.
| Name: | Sequent: | Type: |
|---|---|---|
| node-closed | ⊦ node-closed(nd, ri, fs, ro) ↔ ( nd.dentry? → inodekey(nd.key.ino) ∈ ri ∧ ¬ inodekey(nd.key.ino) ∈ ro ∧ fs[ri[inodekey(nd.key.ino)]].directory ∧ inodekey(nd.ino) ∈ ri ∧ ¬ inodekey(nd.ino) ∈ ro) ∧ (nd.data? → inodekey(nd.key.ino) ∈ ri ∧ ¬ fs[ri[inodekey(nd.key.ino)]].directory ∧ # nd.data = VFS_PAGE_SIZE) | An Axiom |
| node-cons | ⊦ node-cons(key, nd) ↔ (nd.inode? → key.inode? ∧ key.ino ≠ 0) ∧ (nd.dentry? → key.dentry?) ∧ (nd.data? → key.data?) ∧ (nd.trunc? → key.inode?) | An Axiom |
| key-cons | ⊦ key-cons(key, nd) ↔ nd.key = key ∧ (key.inode? → nd.inode? ∧ key.ino ≠ 0) ∧ (key.dentry? → nd.dentry?) ∧ (key.data? → nd.data?) | An Axiom |
| log-cons | ⊦ log-cons(log, fs) ↔ (∀ adr. adr ∈ log → adr ∈ fs ∧ node-cons(fs[adr].key, fs[adr])) | An Axiom |
| inode-set | ⊦ ks.inodes? ↔ (∀ key. key ∈ ks → key.inode?) | An Axiom |
| orphans | ⊦ key ∈ orphans(fs, ri) ↔ key.inode? ∧ key ∈ ri ∧ fs[ri[key]].nlink = 0 ∧ key.ino ≠ ROOT_INO | An Axiom |
| ri-closed | ⊦ ri-closed(ri, fs, ro) ↔ (∀ key. key ∈ ri → ri[key] ∈ fs ∧ node-closed(fs[ri[key]], ri, fs, ro)) | An Axiom |
| ri-cons | ⊦ ri-cons(ri, fs) ↔ (∀ key. key ∈ ri → ri[key] ∈ fs ∧ key-cons(key, fs[ri[key]])) | An Axiom |
| ubifs-cons | ⊦ ubifs-cons(fs, ri, ro, fi, fo, log) ↔ ¬ inodekey(0) ∈ ri ∧ ri-cons(ri, fs) ∧ log-cons(log, fs) ∧ ¬ dups(log) ∧ ri-closed(ri, fs, ro) ∧ ro.inodes? ∧ fo.inodes? ∧ ro ⊆ dom ri ∧ fo ⊆ dom fi | An Axiom |
| ri-inj | ⊦ ri-inj(ri) ↔ (∀ key0, key1. key0 ∈ ri ∧ key1 ∈ ri ∧ ri[key0] = ri[key1] → key0 = key1) | An Axiom |
| file-node-cons | ⊦ file-node-cons(fs, ri) ↔ (∀ ino. inodekey(ino) ∈ ri ∧ ¬ fs[ri[inodekey(ino)]].directory → fs[ri[inodekey(ino)]].nsubdirs = 0) | An Axiom |
| datakey-cons | ⊦ key-cons(datakey(ino, n), nd) ↔ nd.data? ∧ nd.key = datakey(ino, n) | A User Theorem |
| datalkeys-drop-orphans | ⊦ ro.inodes? ∧ ¬ key ∈ ro → datakeys(key, n, ri ⊖ ro) = datakeys(key, n, ri) | A User Theorem |
| datalkeys-drop-orphans-in | ⊦ ro.inodes? ∧ key ∈ ro → datakeys(key, n, ri ⊖ ro) = ∅ | A User Theorem |
| datanode-closed | ⊦ node-closed(datanode(key, buf), ri, fs, ro) ↔ inodekey(key.ino) ∈ ri ∧ ¬ fs[ri[inodekey(key.ino)]].directory ∧ # buf = VFS_PAGE_SIZE | A User Theorem |
| datanode-cons | ⊦ node-cons(key0, datanode(key1, buf)) ↔ key0.data? | A User Theorem |
| datanode-pagesize | ⊦ datakey(m, n) ∈ ri ∧ ubifs-cons(fs, ri, ro, fi, fo, log) → # fs[ri[datakey(m, n)]].data = VFS_PAGE_SIZE | A User Theorem |
| dentrykey-cons | ⊦ key-cons(dentrykey(ino, str), nd) ↔ nd.dentry? ∧ nd.key = dentrykey(ino, str) | A User Theorem |
| dentrynode-closed | ⊦ node-closed(dentrynode(key, ino), ri, fs, ro) ↔ inodekey(key.ino) ∈ ri ∧ ¬ inodekey(key.ino) ∈ ro ∧ fs[ri[inodekey(key.ino)]].directory ∧ inodekey(ino) ∈ ri ∧ ¬ inodekey(ino) ∈ ro | A User Theorem |
| dentrynode-cons | ⊦ node-cons(key0, dentrynode(key1, ino)) ↔ key0.dentry? | A User Theorem |
| empty-inodes | ⊦ ∅.inodes? | A User Theorem |
| file-node-cons-variant1-01 | ⊦ file-node-cons(fs, ri) → ( file-node-cons(fs0, ri0) ↔ (∀ ino. (inodekey(ino) ∈ ri ∧ ¬ fs[ri[inodekey(ino)]].directory → fs[ri[inodekey(ino)]].nsubdirs = 0) → inodekey(ino) ∈ ri0 ∧ ¬ fs0[ri0[inodekey(ino)]].directory → fs0[ri0[inodekey(ino)]].nsubdirs = 0)) | A User Theorem |
| in-ri-update-in-ri | # ax0 = # ax ⊦ ax0.toSet ⊆ range ri ∧ ri-cons(ri, fs) → (key ∈ ri[keys(fs, ax0), ax] ↔ key ∈ ri) | A User Theorem |
| index-update-dom | ⊦ ax0.toSet ⊆ range ri ∧ ri-cons(ri, fs) ∧ # ax0 = # ax1 → dom ri[keys(fs, ax0), ax1] = dom ri | A User Theorem |
| inodekey-cons | ⊦ key-cons(inodekey(ino), nd) ↔ nd.inode? ∧ nd.key = inodekey(ino) ∧ ino ≠ 0 | A User Theorem |
| inodenode-closed | ⊦ node-closed(inodenode(key, md, boolvar, n, n0, m), ri, fs, ro) | A User Theorem |
| inodenode-cons | ⊦ node-cons(key0, inodenode(key1, md, boolvar, n, n0, m)) ↔ key0.inode? ∧ key0.ino ≠ 0 | A User Theorem |
| inodes-del | ⊦ ks.inodes? → (ks -- key).inodes? | A User Theorem |
| inodes-in | ⊦ key ∈ ks ∧ ks.inodes? → key.inode? | A User Theorem |
| inodes-nodata | ⊦ ks.inodes? → ¬ datakey(ino, n) ∈ ks | A User Theorem |
| inodes-nodentry | ⊦ ks.inodes? → ¬ dentrykey(ino, str) ∈ ks | A User Theorem |
| inodes-put | ⊦ ks.inodes? → ((ks ++ key).inodes? ↔ key.inode?) | A User Theorem |
| key-cons-key | ⊦ key-cons(key, nd) → nd.key = key | A User Theorem |
| key-node-cons | ⊦ key-cons(key, nd) → node-cons(key, nd) | A User Theorem |
| log-adr-in | ⊦ log-cons(log, fs) ∧ adr ∈ log → adr ∈ fs | A User Theorem |
| log-cons-app | ⊦ log-cons(log0 + log1, fs) ↔ log-cons(log0, fs) ∧ log-cons(log1, fs) | A User Theorem |
| log-cons-copy-new | # kx = # ax ⊦ kx.toSet ⊆ dom ri ∧ ri-cons(ri, fs) ∧ ¬ dups(kx) ∧ ¬ dups(ax) → log-cons(ax, fs[ax, fs[ri[kx]]]) | A User Theorem |
| log-cons-copy-old | ⊦ new(ax1, fs) ∧ log-cons(log, fs) ∧ # ax1 = # ndx → log-cons(log, fs[ax1, ndx]) | A User Theorem |
| log-cons-drop | ⊦ log-cons(log, fs) ∧ log.toSet ∩ as = ∅ → log-cons(log, fs \ as) | A User Theorem |
| log-cons-emp | ⊦ log-cons([], fs) | A User Theorem |
| log-cons-one | ⊦ log-cons(adr ', fs) ↔ adr ∈ fs ∧ node-cons(fs[adr].key, fs[adr]) | A User Theorem |
| log-cons-variant1-01 | ⊦ log-cons(log, fs) → ( log-cons(log0, fs0) ↔ (∀ adr. (adr ∈ log → adr ∈ fs ∧ node-cons(fs[adr].key, fs[adr])) → adr ∈ log0 → adr ∈ fs0 ∧ node-cons(fs0[adr].key, fs0[adr]))) | A User Theorem |
| log-node-cons | ⊦ log-cons(log, fs) ∧ adr ∈ log → node-cons(fs[adr].key, fs[adr]) | A User Theorem |
| nodups-new-nodups | ⊦ new(ax, fs) ∧ ¬ dups(ax) ∧ ¬ dups(log) ∧ log-cons(log, fs) → (dups(log + ax) ↔ false) | A User Theorem |
| read-get | n < # ax ⊦ fs[ax][n] = fs[ax[n]] | A User Theorem |
| read-lookup-copy | # ax = # kx ⊦ new(ax, fs) ∧ ¬ dups(ax) ∧ ¬ dups(kx) ∧ ri-cons(ri, fs) ∧ kx.toSet ⊆ dom ri ∧ key ∈ ri → fs[ax, fs[ri[kx]]][ri[kx, ax][key]] = fs[ri[key]] | A User Theorem |
| ri-closed-drop | ⊦ range ri ∩ as = ∅ ∧ ri-closed(ri, fs, ro) → ri-closed(ri, fs \ as, ro) | A User Theorem |
| ri-closed-gc-one | ⊦ key ∈ ri ∧ ¬ adr ∈ fs ∧ ri-closed(ri, fs, ro) ∧ ri-cons(ri, fs) → ri-closed(ri[key, adr], fs[adr, fs[ri[key]]], ro) | A User Theorem |
| ri-closed-variant1-01 | ⊦ ri-closed(ri, fs, ro) → ( ri-closed(ri0, fs0, ro0) ↔ (∀ key. (key ∈ ri → ri[key] ∈ fs ∧ node-closed(fs[ri[key]], ri, fs, ro)) → key ∈ ri0 → ri0[key] ∈ fs0 ∧ node-closed(fs0[ri0[key]], ri0, fs0, ro0))) | A User Theorem |
| ri-cons-copy | ⊦ ri-cons(ri, fs) ∧ # ax1 = # ndx ∧ new(ax1, fs) → ri-cons(ri, fs[ax1, ndx]) | A User Theorem |
| ri-cons-copy-new | # ax = # kx ⊦ ri-cons(ri, fs) ∧ kx.toSet ⊆ dom ri ∧ new(ax, fs) ∧ ¬ dups(kx) ∧ ¬ dups(ax) → ri-cons(ri[kx, ax], fs[ax, fs[ri[kx]]]) | A User Theorem |
| ri-cons-del-orphans | ⊦ ri-cons(ri, fs) → ri-cons(ri ⊖ ro, fs) | A User Theorem |
| ri-cons-drop | ⊦ as ∩ range ri = ∅ ∧ ri-cons(ri, fs) → ri-cons(ri, fs \ as) | A User Theorem |
| ri-cons-empty | ⊦ ri-cons(∅, ∅) | A User Theorem |
| ri-cons-empty-2 | ⊦ ri-cons(∅, fs) | A User Theorem |
| ri-cons-gc-one | ⊦ key ∈ ri ∧ ¬ adr ∈ fs ∧ ri-cons(ri, fs) → ri-cons(ri[key, adr], fs[adr, fs[ri[key]]]) | A User Theorem |
| ri-cons-in | ⊦ key ∈ ri ∧ ri-cons(ri, fs) → ri[key] ∈ fs | A User Theorem |
| ri-cons-inj | ⊦ ri-cons(ri, fs) → ri-inj(ri) | A User Theorem |
| ri-cons-key | ⊦ ri-cons(ri, fs) ∧ key ∈ ri → fs[ri[key]].key = key | A User Theorem |
| ri-cons-range-ri | ⊦ ri-cons(ri, fs) → range ri ⊆ dom fs | A User Theorem |
| ri-cons-truncnode | ⊦ key ∈ ri ∧ ri-cons(ri, fs) → fs[ri[key]] ≠ truncnode(key0, m) | A User Theorem |
| ri-cons-variant1-01 | ⊦ ri-cons(ri, fs) → (ri-cons(ri0, fs0) ↔ (∀ key. (key ∈ ri → ri[key] ∈ fs ∧ key-cons(key, fs[ri[key]])) → key ∈ ri0 → ri0[key] ∈ fs0 ∧ key-cons(key, fs0[ri0[key]]))) | A User Theorem |
| ri-inj-del | ⊦ ri-inj(ri) → ri-inj(ri -- key) | A User Theorem |
| ri-inj-empty | ⊦ ri-inj(∅) | A User Theorem |
| ri-inj-rem | ⊦ ri-inj(ri) → ri-inj(ri \ ks) | A User Theorem |
| ri-inj-variant1-01 | ⊦ ri-inj(ri) → ( ri-inj(ri0) ↔ (∀ key0, key1. (key0 ∈ ri ∧ key1 ∈ ri ∧ ri[key0] = ri[key1] → key0 = key1) → key0 ∈ ri0 ∧ key1 ∈ ri0 ∧ ri0[key0] = ri0[key1] → key0 = key1)) | A User Theorem |
| ri-inj-write | ⊦ ri-inj(ri) ∧ ¬ adr ∈ ri → ri-inj(ri[key, adr]) | A User Theorem |
| ri-key-cons | ⊦ key ∈ ri ∧ ri-cons(ri, fs) → key-cons(key, fs[ri[key]]) | A User Theorem |
| truncnode-cons | ⊦ node-cons(key0, truncnode(key1, n)) ↔ key0.inode? | A User Theorem |
| ubifs-adr-in-ri | ⊦ adr ∈ ri ∧ ubifs-cons(fs, ri, ro, fi, fo, log) → adr ∈ fs | A User Theorem |
| ubifs-cons-dom-fi | ⊦ ubifs-cons(fs, ri, ro, fi, fo, log) → fo ⊆ dom fi | A User Theorem |
| ubifs-cons-dom-ri | ⊦ ubifs-cons(fs, ri, ro, fi, fo, log) → ro ⊆ dom ri | A User Theorem |
| ubifs-cons-fo-inodes | ⊦ ubifs-cons(fs, ri, ro, fi, fo, log) → fo.inodes? | A User Theorem |
| ubifs-cons-ino0 | ⊦ ubifs-cons(fs, ri, ro, fi, fo, log) → ¬ inodekey(0) ∈ ri | A User Theorem |
| ubifs-cons-log-cons | ⊦ ubifs-cons(fs, ri, ro, fi, fo, log) → log-cons(log, fs) | A User Theorem |
| ubifs-cons-logadr-in | ⊦ adr ∈ log ∧ ubifs-cons(fs, ri, ro, fi, fo, log) → adr ∈ fs | A User Theorem |
| ubifs-cons-notin-del | ⊦ ¬ adr ∈ fs ∧ ubifs-cons(fs, ri, ro, fi, fo, log) → ¬ adr ∈ ri ⊖ key | A User Theorem |
| ubifs-cons-notin-dels | ⊦ ¬ adr ∈ fs ∧ ubifs-cons(fs, ri, ro, fi, fo, log) → ¬ adr ∈ ri ⊖ ks | A User Theorem |
| ubifs-cons-ri-closed | ⊦ ubifs-cons(fs, ri, ro, fi, fo, log) → ri-closed(ri, fs, ro) | A User Theorem |
| ubifs-cons-ri-inj | ⊦ ubifs-cons(fs, ri, ro, fi, fo, log) → ri-inj(ri) | A User Theorem |
| ubifs-cons-ro-inodes | ⊦ ubifs-cons(fs, ri, ro, fi, fo, log) → ro.inodes? | A User Theorem |
| ubifs-cons-variant1 | ⊦ ubifs-cons(fs, ri, ro, fi, fo, log) → (inodekey(0) ∈ ri ↔ false) | A User Theorem |
| ubifs-cons-variant4 | ⊦ ubifs-cons(fs, ri, ro, fi, fo, log) → (dups(log) ↔ false) | A User Theorem |
| ubifs-dir-data | ⊦ fs[ri[inodekey(ino)]].directory ∧ ri[inodekey(ino)] ∈ ri ∧ ubifs-cons(fs, ri, ro, fi, fo, log) → datakeys(inodekey(ino), ri) = ∅ | A User Theorem |
| ubifs-file-in | ⊦ datakey(ino, n) ∈ ri ∧ ubifs-cons(fs, ri, ro, fi, fo, log) → inodekey(ino) ∈ ri | A User Theorem |
| ubifs-file-notdir | ⊦ datakey(ino, n) ∈ ri ∧ ubifs-cons(fs, ri, ro, fi, fo, log) → ¬ fs[ri[inodekey(ino)]].directory | A User Theorem |
| ubifs-fo-subset | ⊦ ubifs-cons(fs, ri, ro, fi, fo, log) ∧ key ∈ fo → key ∈ fi | A User Theorem |
| ubifs-in-fs | ⊦ key ∈ ri ∧ ubifs-cons(fs, ri, ro, fi, fo, log) → ri[key] ∈ fs | A User Theorem |
| ubifs-log-nodups | ⊦ ubifs-cons(fs, ri, ro, fi, fo, log) → ¬ dups(log) | A User Theorem |
| ubifs-log-nodups-add1 | ⊦ ubifs-cons(fs, ri, ro, fi, fo, log) ∧ ¬ adr0 ∈ fs → ¬ dups(log + adr0 ') | A User Theorem |
| ubifs-log-nodups-add2 | ⊦ ubifs-cons(fs, ri, ro, fi, fo, log) ∧ ¬ adr0 ∈ fs ∧ ¬ adr1 ∈ fs ∧ adr0 ≠ adr1 → ¬ dups(log + adr0 ' + adr1 ') | A User Theorem |
| ubifs-log-nodups-add3 | ⊦ ubifs-cons(fs, ri, ro, fi, fo, log) ∧ ¬ adr0 ∈ fs ∧ ¬ adr1 ∈ fs ∧ ¬ adr2 ∈ fs ∧ adr0 ≠ adr1 ∧ adr0 ≠ adr2 ∧ adr1 ≠ adr2 → ¬ dups(log + adr0 ' + adr1 ' + adr2 ') | A User Theorem |
| ubifs-log-nodups-add4 | ⊦ ubifs-cons(fs, ri, ro, fi, fo, log) ∧ ¬ adr0 ∈ fs ∧ ¬ adr1 ∈ fs ∧ ¬ adr2 ∈ fs ∧ ¬ adr3 ∈ fs ∧ adr0 ≠ adr1 ∧ adr0 ≠ adr2 ∧ adr1 ≠ adr2 ∧ adr0 ≠ adr3 ∧ adr1 ≠ adr3 ∧ adr2 ≠ adr3 → ¬ dups(log + adr0 ' + adr1 ' + adr2 ' + adr3 ') | A User Theorem |
| ubifs-log-nodups-add5 | ⊦ ubifs-cons(fs, ri, ro, fi, fo, log) ∧ ¬ adr0 ∈ fs ∧ ¬ adr1 ∈ fs ∧ ¬ adr2 ∈ fs ∧ ¬ adr3 ∈ fs ∧ ¬ adr4 ∈ fs ∧ adr0 ≠ adr1 ∧ adr0 ≠ adr2 ∧ adr1 ≠ adr2 ∧ adr0 ≠ adr3 ∧ adr1 ≠ adr3 ∧ adr2 ≠ adr3 ∧ adr0 ≠ adr4 ∧ adr1 ≠ adr4 ∧ adr2 ≠ adr4 ∧ adr3 ≠ adr4 → ¬ dups(log + adr0 ' + adr1 ' + adr2 ' + adr3 ' + adr4 ') | A User Theorem |
| ubifs-parent-dir | ⊦ dentrykey(ino, str) ∈ ri ∧ ubifs-cons(fs, ri, ro, fi, fo, log) → fs[ri[inodekey(ino)]].directory | A User Theorem |
| ubifs-parent-in | ⊦ dentrykey(ino, str) ∈ ri ∧ ubifs-cons(fs, ri, ro, fi, fo, log) → inodekey(ino) ∈ ri | A User Theorem |
| ubifs-ri-cons | ⊦ ubifs-cons(fs, ri, ro, fi, fo, log) → ri-cons(ri, fs) | A User Theorem |
| ubifs-ro-data | ⊦ ubifs-cons(fs, ri, ro, fi, fo, log) → ¬ datakey(ino, n) ∈ ro | A User Theorem |
| ubifs-ro-dentry | ⊦ ubifs-cons(fs, ri, ro, fi, fo, log) → ¬ dentrykey(ino, str) ∈ ro | A User Theorem |
| ubifs-ro-subset | ⊦ ubifs-cons(fs, ri, ro, fi, fo, log) ∧ key ∈ ro → key ∈ ri | A User Theorem |