VIDEOS 1 TO 50

#64 Abstract Interpretation: Introduction

Published: 2015/01/10

Channel: SEPL Goethe University Frankfurt

Theories, Solvers and Static Analysis by Abstract Interpretation

Published: 2016/08/17

Channel: Microsoft Research

Completeness and incompleteness in Abstract Interpretation

Published: 2016/07/07

Channel: Microsoft Research

Static Analysis Abstract and Concrete Interpretation

Published: 2014/03/25

Channel: Tech Gig

VINTA: Combining Model Checking and Abstract Interpretation

Published: 2016/07/27

Channel: Microsoft Research

Correctness Kernel of Abstract Interpretations

Published: 2016/06/21

Channel: Microsoft Research

ICFP 2014: session "Abstract Interpretation"

Published: 2014/09/04

Channel: Malcolm Wallace

The Awakening abstract interpretation (annotated version with lyrics)

Published: 2015/06/19

Channel: clovescirrus

The Mirror lied-Abstract, Interpretation{full}

Published: 2015/03/03

Channel: Cristi Nicola

Inferring Class Invariants in object-oriented languages via abstract interpretation

Published: 2016/09/06

Channel: Microsoft Research

Gritty Friction Visual Interpretation 1: Abstract Opera (Nautilus Apocalypse)

Published: 2012/05/05

Channel: Cameron Rogers

The Invention of Morel abstract interpretation

Published: 2009/03/27

Channel: gregruben

Redex, Abstract Machines, and Abstract Interpretation 4 - David Van Horn - OPLSS 2017

Published: 2017/08/01

Channel: OPLSS

Clips of abstract interpretation of the art

Published: 2012/05/03

Channel: SamSoundful

an abstract interpretation of naked lunch.

Published: 2008/03/19

Channel: armills20

Redex, Abstract Machines, and Abstract Interpretation 1 - David Van Horn - OPLSS 2017

Published: 2017/07/01

Channel: OPLSS

Redex, Abstract Machines, and Abstract Interpretation 3 - David Van Horn - OPLSS 2017

Published: 2017/07/31

Channel: OPLSS

Gubauski's abstract interpretation of Music(Gone Sexual)

Published: 2017/01/28

Channel: The Pipers (;

Redex, Abstract Machines, and Abstract Interpretation 2 - David Van Horn - OPLSS 2017

Published: 2017/07/18

Channel: OPLSS

abstract interpretation of model

Published: 2010/11/01

Channel: Adelaide Palum

abstract music interpretation test 2

Published: 2008/02/19

Channel: clairesuckling

#66 Galois Connections

Published: 2015/01/10

Channel: SEPL Goethe University Frankfurt

Abstract interpretation

Published: 2012/05/20

Channel: TheTempleDancers

abstract interpretations

Published: 2012/05/08

Channel: Joseph Morgan

Abstract Interpretation (ft. "Tell Your Friends" by The Weekend)

Published: 2016/01/04

Channel: Jared Cohen

Canada's History: An Abstract Interpretation of It

Published: 2016/06/17

Channel: c239797

St Peter's church public bath - Refreshment- Abstract interpretation of gothic elements

Published: 2013/06/26

Channel: Nathalie Chew

2016 R&D Technical Workshop: An Analysis of x86 Executables Using Abstract Interpretation

Published: 2016/09/15

Channel: DHS Science and Technology Directorate

Wire Woven Peacock Feather Pendant Tutorial

Published: 2017/05/23

Channel: Pat Langfield

Process and Exhibition of Ineractive Abstract Forest

Published: 2016/01/09

Channel: Charlotte Robinson

Abstract Interpretation of still image - University project (Part 2/2)

Published: 2011/04/05

Channel: Brian Alcorn

What is Static Analysis? by Matt Might

Published: 2014/08/02

Channel: Lambda Lounge Utah

Shinji Takeda's Abstract Jazz-Blow Up (Satoshi Tomiie Interpretation)

Published: 2011/06/08

Channel: Davide Buffoni

Abstract and Interpretation

Published: 2011/07/08

Channel: FineArtAcademy

Analyzing the Entire Program: Applying Natural Language Processing to Software Engineering

Published: 2017/01/17

Channel: Microsoft Research

The Old Curiosity Shop - Abstract 3D Interpretation (UDK)

Published: 2014/04/30

Channel: Tony Simmons

Abstract Induction - Patrick Cousot

Published: 2015/10/12

Channel: ETH WSCR

How to Pronounce Abstract Interpretation

Published: 2016/11/21

Channel: Dictionary Voice

Nullness Analysis for Java

Published: 2008/10/06

Channel: GoogleTechTalks

Scalable Language Specification 2013

Published: 2016/08/09

Channel: Microsoft Research

Academic research and writing – Chapter 8 Interpretation – Unit 0 Agenda

Published: 2015/08/21

Channel: Prof. Dr. Christian Decker

The Fall

Published: 2010/05/05

Channel: Top Chrétien

XVII

Published: 2017/05/16

Channel: ComAcad Drake High

FINSENSUS

Published: 2016/05/09

Channel: Vatuloiva Leikkaaja

noise 3

Published: 2017/01/03

Channel: Oskar Tikka

Dan Stevers - The Fall

Published: 2010/05/17

Channel: Dan Stevers

Abstractions in Satisfiability Solvers

Published: 2016/08/17

Channel: Microsoft Research

the birth of the universe

Published: 2017/04/04

Channel: ShrekIsMyBestFriend

Izanami & Izanagi

Published: 2008/07/06

Channel: shikima9

Jérôme In Chrome 'Exegetic Interpretation' - Live for Abstract @ Le Truskel (27-06-2014)

Published: 2014/08/23

Channel: lofiphil

This article includes a list of references, but its sources remain unclear because it has insufficient inline citations. (February 2009) (Learn how and when to remove this template message) |

In computer science, **abstract interpretation** is a theory of sound approximation of the semantics of computer programs, based on monotonic functions over ordered sets, especially lattices. It can be viewed as a partial execution of a computer program which gains information about its semantics (e.g., control-flow, data-flow) without performing all the calculations.

Its main concrete application is formal static analysis, the automatic extraction of information about the possible executions of computer programs; such analyses have two main usages:

- inside compilers, to analyse programs to decide whether certain optimizations or transformations are applicable;
- for debugging or even the certification of programs against classes of bugs.

Abstract interpretation was formalized by the French computer scientists Patrick Cousot and Radhia Cousot in the late 1970s.^{[1]}^{[2]}

This section illustrates abstract interpretation by means of real-world, non-computing examples.

Consider the people in a conference room. Assume a unique identifier for each person in the room, like a social security number in the United States. To prove that someone is not present, all one needs to do is see if their social security number is not on the list. Since two different people cannot have the same number, it is possible to prove or disprove the presence of a participant simply by looking up his or her number.

However it is possible that only the names of attendees were registered. If the name of a person is not found in the list, we may safely conclude that that person was not present; but if it is, we cannot conclude definitely without further inquiries, due to the possibility of homonyms (for example, two people named John Smith). Note that this imprecise information will still be adequate for most purposes, because homonyms are rare in practice. However, in all rigor, we cannot say for sure that somebody was present in the room; all we can say is that he or she was *possibly* here. If the person we are looking up is a criminal, we will issue an *alarm*; but there is of course the possibility of issuing a *false alarm*. Similar phenomena will occur in the analysis of programs.

If we are only interested in some specific information, say, "was there a person of age *n* in the room?", keeping a list of all names and dates of births is unnecessary. We may safely and without loss of precision restrict ourselves to keeping a list of the participants' ages. If this is already too much to handle, we might keep only the age of the youngest, *m* and oldest person, *M*. If the question is about an age strictly lower than *m* or strictly higher than *M*, then we may safely respond that no such participant was present. Otherwise, we may only be able to say that we do not know.

In the case of computing, concrete, precise information is in general not computable within finite time and memory (see Rice's theorem and the halting problem). Abstraction is used to allow for generalized answers to questions (for example, answering "maybe" to a yes/no question, meaning "yes or no", when we (an algorithm of abstract interpretation) cannot compute the precise answer with certainty); this simplifies the problems, making them amenable to automatic solutions. One crucial requirement is to add enough vagueness so as to make problems manageable while still retaining enough precision for answering the important questions (such as "may the program crash?").

Given a programming or specification language, abstract interpretation consists of giving several semantics linked by relations of abstraction. A semantics is a mathematical characterization of a possible behavior of the program. The most precise semantics, describing very closely the actual execution of the program, are called the **concrete semantics**. For instance, the concrete semantics of an imperative programming language may associate to each program the set of execution traces it may produce – an execution trace being a sequence of possible consecutive states of the execution of the program; a state typically consists of the value of the program counter and the memory locations (globals, stack and heap). More abstract semantics are then derived; for instance, one may consider only the set of reachable states in the executions (which amounts to considering the last states in finite traces).

The goal of static analysis is to derive a computable semantic interpretation at some point. For instance, one may choose to represent the state of a program manipulating integer variables by forgetting the actual values of the variables and only keeping their signs (+, − or 0). For some elementary operations, such as multiplication, such an abstraction does not lose any precision: to get the sign of a product, it is sufficient to know the sign of the operands. For some other operations, the abstraction may lose precision: for instance, it is impossible to know the sign of a sum whose operands are respectively positive and negative.

Sometimes a loss of precision is necessary to make the semantics decidable (see Rice's theorem, halting problem). In general, there is a compromise to be made between the precision of the analysis and its decidability (computability), or tractability (complexity).

In practice the abstractions that are defined are tailored to both the program properties one desires to analyze, and to the set of target programs. The first large scale automated analysis of computer programs with abstract interpretation can be attributed to an accident that resulted in the destruction of the first flight of the Ariane 5 rocket in 1996.^{[3]}

Let *L* be an ordered set, called a **concrete set** and let *L*′ be another ordered set, called an **abstract set**. These two sets are related to each other by defining total functions that map elements from one to the other.

A function α is called an **abstraction function** if it maps an element *x* in the concrete set *L* to an element α(*x*) in the abstract set *L*′. That is, element α(*x*) in *L*′ is the **abstraction** of *x* in *L*.

A function γ is called a **concretization function** if it maps an element *x*′ in the abstract set *L*′ to an element γ(*x*′) in the concrete set *L*. That is, element γ(*x*′) in *L* is a **concretization** of *x*′ in *L*′.

Let *L*_{1}, *L*_{2}, *L*′_{1} and *L*′_{2} be ordered sets. The concrete semantics *f* is a monotonic function from *L*_{1} to *L*_{2}. A function *f*′ from *L*′_{1} to *L*′_{2} is said to be a **valid abstraction** of *f* if for all *x*′ in *L*′_{1}, (*f* ∘ γ)(*x*′) ≤ (γ ∘ *f*′)(*x*′).

Program semantics are generally described using fixed points in the presence of loops or recursive procedures. Let us suppose that *L* is a complete lattice and let *f* be a monotonic function from *L* into *L*. Then, any *x*′ such that *f*(*x*′) ≤ *x*′ is an abstraction of the least fixed-point of *f*, which exists, according to the Knaster–Tarski theorem.

The difficulty is now to obtain such an *x*′. If *L*′ is of finite height, or at least verifies the ascending chain condition (all ascending sequences are ultimately stationary), then such an *x*′ may be obtained as the stationary limit of the ascending sequence *x*′_{n} defined by induction as follows: *x*′_{0}=⊥ (the least element of *L*′) and *x*′_{n+1}=*f*′(*x*′_{n}).

In other cases, it is still possible to obtain such an *x*′ through a widening operator ^{[4]} ∇: for all *x* and *y*, *x* ∇ *y* should be greater or equal than both *x* and *y*, and for any sequence *y*′_{n}, the sequence defined by *x*′_{0}=⊥ and *x*′_{n+1}=*x*′_{n} ∇ *y*′_{n} is ultimately stationary. We can then take *y*′_{n}=*f*′(*x*′_{n}).

In some cases, it is possible to define abstractions using Galois connections (α, γ) where α is from *L* to *L*′ and γ is from *L*′ to *L*. This supposes the existence of best abstractions, which is not necessarily the case. For instance, if we abstract sets of couples (*x*, *y*) of real numbers by enclosing convex polyhedra, there is no optimal abstraction to the disc defined by *x*^{2}+*y*^{2} ≤ 1.

One can assign to each variable *x* available at a given program point an interval [*L*_{x}, *H*_{x}]. A state assigning the value *v*(*x*) to variable *x* will be a concretization of these intervals if for all *x*, *v*(*x*) is in [*L*_{x}, *H*_{x}]. From the intervals [*L*_{x}, *H*_{x}] and [*L*_{y}, *H*_{y}] for variables *x* and *y*, one can easily obtain intervals for *x*+*y* ([*L*_{x}+*L*_{y}, *H*_{x}+*H*_{y}]) and for *x*−*y* ([*L*_{x}−*H*_{y}, *H*_{x}−*L*_{y}]); note that these are *exact* abstractions, since the set of possible outcomes for, say, *x*+*y*, is precisely the interval ([*L*_{x}+*L*_{y}, *H*_{x}+*H*_{y}]). More complex formulas can be derived for multiplication, division, etc., yielding so-called interval arithmetics.^{[5]}

Let us now consider the following very simple program:

y = x; z = x - y;

With reasonable arithmetic types, the result for `z` should be zero. But if we do interval arithmetic starting from `x` in [0, 1], one gets `z` in [−1, +1]. While each of the operations taken individually was exactly abstracted, their composition isn't.

The problem is evident: we did not keep track of the equality relationship between `x` and `y`; actually, this domain of intervals does not take into account any relationships between variables, and is thus a **non-relational domain**. Non-relational domains tend to be fast and simple to implement, but imprecise.

Some examples of **relational** numerical abstract domains are:

- congruence relations on integers
^{[6]}^{[7]} - convex polyhedra
^{[8]}(cf. left picture) – with some high computational costs - "octagons"
^{[9]}^{[10]}^{[11]} - difference-bound matrices
^{[citation needed]} - linear equalities
^{[citation needed]}

and combinations thereof (cf. right picture).^{[citation needed]}

When one chooses an abstract domain, one typically has to strike a balance between keeping fine-grained relationships, and high computational costs.

Sound tools guarantee that the verification they perform is correct and exhaustive. They can never yield false negatives, but by undecidability may produce false alarms (or false positive) signaling a potential error with no instance during any execution (because the static analysis is not precise enough to eliminate the potential error).

- Astrée
- CodeContracts static checker
^{[12]} - CodePeer
- CPAchecker
- ECLAIR
- Fluctuat
- Frama-C value analysis
- Julia Static Analyzer for Java, Android and Java bytecode
^{[13]} - Penjili
^{[14]} - Polyspace
- Predator
^{[15]} - IKOS
^{[16]} - Verasco
^{[17]}

Unsound tools do not guarantee that the verification they perform is correct and exhaustive. They can yield false alarms/positive as well as false negative, not signaling an error that occur for at least one program execution, because the static analysis they perform is incorrect (i.e., they fail to consider some possible executions). As a consequence, they can falsely claim that an unsafe program is safe.

- Codesonar
^{[18]} - Coverity Prevent
- Klocwork Insight
^{[clarification needed]} - Parasoft Jtest
^{[clarification needed]} - Parasoft C/C++test
^{[clarification needed]} - Red Lizard's Goanna
^{[clarification needed]}

- Standard interpretation
- Model checking
- Symbolic simulation
- Symbolic execution
- List of tools for static code analysis — contains both abstract-interpretation based (sound) and ad-hoc (unsound) tools
- Static program analysis — overview of analysis methods, including, but not restricted to, abstract interpretation

**^**Patrick Cousot, Radhia Cousot: "Abstract Interpretation: A Unified Lattice Model for Static Analysis of Programs by Construction or Approximation of Fixpoints". Conference Record of the Fourth ACM Symposium on Principles of Programming Languages, Los Angeles, California, USA, January 1977. ACM, 1977, pp. 238-252**^**Patrick Cousot, Radhia Cousot: "Systematic Design of Program Analysis Frameworks". Conference Record of the Sixth Annual ACM Symposium on Principles of Programming Languages, San Antonio, Texas, USA, January 1979. ACM Press, 1979, pp. 269-282**^**Faure, Christèle. "PolySpace Technologies History". Retrieved 3 October 2010.**^**P. Cousot, R. Cousot (Aug 1992). "Comparing the Galois Connection and Widening / Narrowing Approaches to Abstract Interpretation" (PDF). In Maurice Bruynooghe and Martin Wirsing.*Proc. 4th Int. Symp. on Programming Language Implementation and Logic Programming (PLILP)*. LNCS.**631**. Springer. pp. 269–296.**^**Patrick Cousot and Radhia Cousot (1976). "Static determination of dynamic properties of programs" (PDF).*Proceedings of the Second International Symposium on Programming*. Dunod, Paris, France. pp. 106—130.**^**P. Granger (1989). "Static Analysis of Arithmetical Congruences".*International Journal of Computer Mathematics*.**30**: 165—190. doi:10.1080/00207168908803778.**^**P. Granger (1991). "Static Analysis of Linear Congruence Equalities Among Variables of a Program". In S. Abramsky and T.S.E. Maibaum.*Proc. Int. J. Conf. on Theory and Practice of Software Development (TAPSOFT)*. LNCS.**493**. Springer. pp. 169—192.**^**Patrick Cousot and Nicolas Halbwachs (Jan 1978). "Automatic Discovery of Linear Restraints Among Variables of a Program" (PDF).*Conf. Rec. 5th ACM Symp. on Principles of Programming Languages (POPL)*. pp. 84—97.**^**Antoine Miné (Dec 2004).*Weakly Relational Numerical Abstract Domains*(PDF) (Ph.D. thesis). Laboratoire d'Informatique de l'École Normale Supérieure.**^**Antoine Miné (2006). "The Octagon Abstract Domain".*Higher Order Symbol. Comput*.**19**(1): 31—100. doi:10.1007/s10990-006-8609-1.**^**Robert Clarisó and Jordi Cortadella (2007). "The Octahedron Abstract Domain" (PDF).*Science of Computer Programming*.**64**: 115—139. doi:10.1016/j.scico.2006.03.009.**^**CodeContracts static checker (cccheck)**^**Julia Static Analyzer for Java, Android and Java bytecode**^**Penjili**^**predator**^**IKOS**^**Verasco**^**Codesonar

- A web-page on Abstract Interpretation maintained by Patrick Cousot
- Roberto Bagnara's paper showing how it is possible to implement an abstract-interpretation based static analyzer for a C-like programming language
- A conference on Verification, Model-Checking, and Abstract Interpretation (VMCAI), affiliated at the POPL conference, proceedings appearing in the Spinger LNCS series: 2005=vol.3385, 2008=vol.4905 (ed. F. Logozzo et al.), ...

- Lecture notes

- Abstract Interpretation. Patrick Cousot. MIT.
- David Schmidt's lecture notes on abstract interpretation
- Møller and Schwarzbach's lecture notes on Static Program Analysis
- Agostino Cortesi's lecture notes on Program Analysis and Verification
- Slides by Grégoire Sutre going though every step of Abstract Interpretation with many examples - also introducing Galois connections

None of the audio/visual content is hosted on this site. All media is embedded from other sites such as GoogleVideo, Wikipedia, YouTube etc. Therefore, this site has no control over the copyright issues of the streaming media.

All issues concerning copyright violations should be aimed at the sites hosting the material. This site does not host any of the streaming media and the owner has not uploaded any of the material to the video hosting servers. Anyone can find the same content on Google Video or YouTube by themselves.

The owner of this site cannot know which documentaries are in public domain, which has been uploaded to e.g. YouTube by the owner and which has been uploaded without permission. The copyright owner must contact the source if he wants his material off the Internet completely.

Wikipedia content is licensed under the GFDL and (CC) license