Gradually typed languages allow statically typed and dynamically typed code to interact while maintaining benefits of both styles. The key to reasoning about these mixed programs is Siek-Vitousek-Cimini-Boyland's (dynamic) gradual guarantee, which says that giving components of a program more precise types only adds runtime type checking, and does not otherwise change behavior. In this paper, we give a semantic reformulation of the gradual guarantee called graduality. We change the name to promote the analogy that graduality is to gradual typing what parametricity is to polymorphism. Each gives a local-to-global, syntactic-to-semantic reasoning principle that is formulated in terms of a kind of observational approximation.Utilizing the analogy, we develop a novel logical relation for proving graduality. We show that embeddingprojection pairs (ep pairs) are to graduality what relations are to parametricity. We argue that casts between two types where one is "more dynamic" (less precise) than the other necessarily form an ep pair, and we use this to cleanly prove the graduality cases for casts from the ep-pair property. To construct ep pairs, we give an analysis of the type dynamism relation-also known as type precision or naïve subtyping-that interprets the rules for type dynamism as compositional constructions on ep pairs, analogous to the coercion interpretation of subtyping.CCS Concepts: • Software and its engineering → General programming languages; • Social and professional topics → History of programming languages;Additional Key Words and Phrases: Gradual typing, keyword2, keyword3 * In this paper, we use blue to typeset our gradual cast calculus λ G and red to typeset our typed language with errors λ T ,℧ . The paper will be much easier to read if viewed/printed in color. 1 The same work also introduces a static gradual guarantee that says that changing the types in a program to be less dynamic means type checking becomes stricter. We do not consider this in our paper because we only consider the semantics of cast calculi, not the type systems of gradual surface languages. We discuss the relationship further in §7