Abstraction Functions as Types

2025-02-27

AI Summary

This paper addresses the substitutability challenge in modular development for dependently typed systems. We propose a phase-separated abstraction mechanism that strictly separates interface behavior (public) from algorithmic implementation (private), ensuring library replacements preserve client behavior. Innovatively, we internalize noninterference and disentanglement modal theorems into abstract function construction—first unifying ADT’s public/private layering and computational cost privacy within dependent types. Using phase-sensitive dependent types, modal logic, and phased quotient types, we formally verify—within the single-valued Calf framework—that interface implementations admit free substitution, satisfy behavioral correctness, and guarantee private cost irrelevance. Our approach significantly enhances both expressivity and efficiency of modular verification.

Technology Category

• Constraint Satisfaction and Optimization: Satisfiability Modulo Theories
• Knowledge Representation and Reasoning: Diagnosis and Abductive Reasoning
• Computer Vision: Multi-modal Vision

Application Category

• Security and Privacy: Data transparency and provenance
• User Modeling, Personalization and Recommendation: User privacy protection in personalized systems
• Systems and Infrastructure for Web, Mobile and WoT: Experiences and lessons learnt from Web-based algorithms and system deployments

Abstract

Modular development of programs relies on the principle that library code may be freely replaced without affecting client behavior. While an interface mediating this interaction should require a precise behavior of its implementations, allowing for downstream verification of client code, it should do so in a manner that allows private algorithmic and representation choices to vary freely. In this work we demonstrate how such modularity can be achieved in dependent type theory using a phase distinction between private algorithmic content and public client-facing behavior. We observe that modalities associated with such a phase distinction and their corresponding theorems, particularly noninterference and fracture, give rise to precise descriptions of common constructions surrounding algorithms and data structures. Using a modal construction to classify types that sufficiently restrict client-facing behavior, we use the noninterference property for the phase to state and prove a modularity property guaranteeing that implementations may be freely replaced without affecting behavior. We then cast the fracture property in the light of abstraction functions, showing internally that every type consists of a private algorithmic component, a public behavioral component representing an abstract data type, and an abstraction function between them that is uniformly activated by the behavioral phase for streamlined verification of client correctness. Finally, we use phased quotient types to ergonomically mark private data for behavioral deletion. We situate this development in a univalent adaptation of Calf, a dependent type theory for cost analysis, in order to amplify these points: beyond hiding private implementation details, we treat cost as a private matter that may be varied freely without affecting the behavior of clients.

Problem

• Achieving modularity in dependent type theory
• Separating private algorithmic content from public behavior
• Ensuring implementation replacement without affecting client behavior

Innovation

• Phase distinction for modularity in type theory
• Modal construction for client-facing behavior restriction
• Phased quotient types for private data deletion