specification and implementation of abstract data types n.
Download
Skip this Video
Loading SlideShow in 5 Seconds..
Specification and Implementation of Abstract Data Types PowerPoint Presentation
Download Presentation
Specification and Implementation of Abstract Data Types

Loading in 2 Seconds...

  share
play fullscreen
1 / 30
dyami

Specification and Implementation of Abstract Data Types - PowerPoint PPT Presentation

113 Views
Download Presentation
Specification and Implementation of Abstract Data Types
An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript

  1. Specification and Implementation of Abstract Data Types Algebraic Techniques LADT

  2. Data Abstraction • Clients • Interestedin WHAT services a module provides, not HOW they are carried out. So, ignore details irrelevant to the overall behavior, for clarity. • Implementors • Reserve the right to change the code, to improve performance. So, ensure that clients do not make unwarranted assumptions. LADT

  3. Abstraction : Equivalence Relations • Computability • Recursive vs Non-recursive • Semantics • Behavioral Equivalence • Resource-independent interchangeability • Performance aspect irrelevant for “correctness” • E.g., Groups, Fields, Sorting, UNIX, etc • Algorithms • Time and Space requirements • Big-Oh (Worst-case Analysis) • NP-hard vs Polynomial-time LADT

  4. Specification of Data Types Type : Values + Operations Specify SyntaxSemantics Signature of Ops Meaning of Ops Model-basedAxiomatic(Algebraic) Description in terms of Give axioms satisfied standard “primitive” data types by the operations LADT

  5. Syntax of LISP S-expr • operations: nil, cons, car, cdr, null • signatures: nil: S-expr cons: S-expr*S-expr-> S-expr car: S-expr-> S-expr cdr: S-expr-> S-expr null: S-expr-> boolean for every atoma: a : S-expr LADT

  6. Signature tells us how to form complex terms from primitive operations. • Legal nil null(cons(nil,nil)) cons(car(nil),nil) • Illegal nil(cons) null(null) cons(nil) LADT

  7. Formal Spec. of ADTs Characteristics of an “Adequate” Specification • Completeness (No undefinedness) • Consistency/Soundness (No conflicting definitions) GOAL: Learn to write sound and complete algebraic(axiomatic) specifications of ADTs LADT

  8. Classification of Operations • Observers (“Queries”) • generate a value outside the type • E.g., null in ADTS-expr • Constructors (“Creators and Commands”) • required for representing values in the type • E.g., nil, cons, atoms a in ADTS-expr • Non-constructors (“Creators and Commands”) • remaining operations • E.g., car, cdr in ADTS-expr LADT

  9. ADT Table (symbol table/directory) empty : Table update : Key x Info x Table ->Table lookUp: Key x Table -> Info lookUp(K,empty) = error (Use of variable) (Alternative : Use of Preconditions) lookUp(K,update(Ki, I, T)) = if K = Ki then I else lookUp(K,T) (“last update overrides the others”) LADT

  10. Implementations • Array-based • LinearList-based • Tree-based • Binary Search Trees, AVL Trees, B-Trees etc • HashTable-based • These exhibit a common Table behavior, but differ in performance aspects. • Correctness of a client program is assured even when the implementation is changed. LADT

  11. A-list in LISP a : A nil : A-list cons : A x A-list -> A-list car : A-list -> A cdr : A-list -> A-list null : A-list -> boolean • Observers : null, car • Constructors : nil, cons • Non-constructors : cdr LADT

  12. Algebraic Spec • Write axioms (equations) that characterize the meaning of all the operations. • Describe the meaning of the observers and the non-constructors on all possible constructor patterns. • Note the use of typed variables to abbreviate the definition. (“Finite Spec.”) LADT

  13. for all S, T in S-expr cdr(nil) = error cdr(cons(S,T)) = T car(nil) = error car(cons(S,T)) = S null(nil) = true null(cons(S,T)) = false (To avoid “error”, use preconditions instead.) • Other atoms “a”are handled in the same way as“nil”. LADT

  14. Natural Numbers zero : N succ : N-> N add : NxN -> N iszero : N->boolean observers : iszero constructors : zero, succ non-constructors : add Each numbers has a unique representation in terms of its constructors. LADT

  15. for all I,J in N add(zero,I) = I add(succ(J), I) = succ(add(J,I)) iszero(zero) = true iszero(succ(n)) = false LADT

  16. A-list Revisted a : A nil : A-list list : A -> A-list append : A-list x A-list -> A-list null : A-list -> boolean • values • nil, list(a), append(nil, list(a)), ... LADT

  17. Algebraic Spec • constructors • nil, list, append • observer isnull(nil) = true isnull(list(a)) = false isnull(append(L1,L2)) = isnull(L1) /\ isnull(L2) LADT

  18. Problem : Same value has multiple representation in terms of constructors. • Solution : Add axioms for constructors. • Identity Rule append(L,nil) = L append(nil,L) = L • Associativity Rule append(append(L1,L2),L3) = append(L1, append(L2,L3)) LADT

  19. Writing ADT Specs • Idea: Specify “sufficient” axioms such that syntactically distinct patterns that denote the same value can be proven so. • Completeness • Define non-constructors and observers on all possible constructor patterns • Consistency • Check for conflicting reductions • Note: A term essentially records the detailed historyofconstruction of the value. LADT

  20. General Strategy for ADT Specs • Syntax • Specify signatures and classify operations. • Constructors • Write axioms to ensure that two constructor terms that represent the same value can be proven so. • E.g., identity, associativity, commutativity rules. LADT

  21. Non-constructors • Provide axioms to collapse a non-constructor term into a term involving only constructors. • Observers • Define the meaning of an observer on all constructor terms, checking for consistency. Implementation of a type An interpretation of the operations of the ADT that satisfies all the axioms. LADT

  22. Model-based vs Algebraic • A model-based specification of a type satisfies the corresponding axiomatic specification. Hence, algebraic spec. is “more abstract” than the model-based spec. • Algebraic spec captures the least common-denominator (behavior) of all possible implementations. LADT

  23. Example car( cons( X, Y) ) = X cdr( cons (X, Y) ) = Y (define (cons x y) (lambda (m) (cond ((eq? m ’first) x) (eq? m ’second) y) ) )) ; “closure” (define (car z) (z ’first)) (define (cdr z) (z ’second)) LADT

  24. Identity Element Associative Op Commutative Op Idempotent Delete element Collapse tree into linear list (parenthesis redundant) Order list elements Remove duplicates Canonical Form for Equality Testing LADT

  25. Ordered Integer Lists null : oil->boolean nil : oil hd : oil->int tl : oil->oil ins : int x oil->oil order : int_list->oil Constructors: nil, ins Non-constructors: tl, order Observers: null, hd LADT

  26. Problem: • syntactically different, but semantically equivalent constructor terms ins(2,ins(5,nil)) = ins(5,ins(2,nil)) ins(2,ins(2,nil)) = ins(2,nil) • hd should return the smallest element. • for all I in int, L in oil, it is not the case that hd(ins(I,L)) = I. • This holds iff I is the minimum in ins(I,L). • Similarly for tl. LADT

  27. Axioms for Constructors • Idempotence • for all ordered integer lists L; for all I in int ins(I, ins(I,L)) = ins(I,L) • Commutativity • for all ordered integer lists L; for all I, J in int ins(I, ins(J,L)) = ins(J, ins(I,L)) Completeness : Any permutation can be generated by exchanging adjacent elements. LADT

  28. Axioms for Non-constructors tl(nil) = error tl(ins(I,L)) = ? tl(ins(I,nil)) = nil tl(ins(I,ins(J,L))) = I < J => ins( J, tl(ins(I,L)) ) I > J => ins( I, tl(ins(J,L)) ) I = J => tl( ins( I,L ) ) (cf. constructor axioms for duplicate elimination) order(nil) = nil order(cons(I,L)) = ins(I,order(L)) LADT

  29. Axioms for Observers hd(nil) = error hd(ins(I,nil)) = I hd(ins(I,ins(J,L))) = I < J => hd( ins(I,L) ) I > J => hd( ins(J,L) ) I = J => hd( ins(I,L) ) null(nil) = true null(cons(I,L)) = false LADT

  30. Object-Oriented Software Construction • Building software systems as structured collections of (possibly partial) abstract data type implementations. • Function categories • Creators ( …x … -> T ) • Queries (…xTx … -> …) • Commands (…xTx … -> T ) LADT