A new graphical calculus of proofs

We offer a simple graphical representation for proofs of intuitionistic logic, which is inspired by proof nets and interaction nets (two formalisms originating in linear logic). This graphical calculus of proofs inherits good features from each, but is not constrained by them. By the Curry-Howard isomorphism, the representation applies equally to the lambda calculus, offering an alternative diagrammatic representation of functional computations.

💡 Research Summary

The paper introduces a novel graphical calculus for intuitionistic logic proofs, built on the concept of port graphs, a flexible graph formalism that generalizes both proof nets and interaction nets. The authors begin by motivating the need for a visual representation that avoids inessential permutations inherent in traditional syntactic proof systems such as sequent calculus. While proof nets provide a clean graphical syntax for linear logic, they require additional structures (e.g., boxes) for many fragments of intuitionistic logic, making the representation fragmented. Interaction nets, on the other hand, are easy to implement but tend to clutter proofs with low‑level operational details.

To combine the strengths of both, the authors adopt port graphs, where each node possesses an explicit set of ports that can be labeled with formulas or meta‑information (e.g., active/inactive, principal/auxiliary). A port‑graph rewrite rule consists of a left‑hand side (L), a right‑hand side (R), and a distinguished arrow node (⇒) that encodes the correspondence between ports of L and R, guaranteeing that no dangling edges appear after rewriting.

The core contribution is a systematic translation from natural‑deduction proofs in intuitionistic logic to port‑graph structures. Each logical rule becomes a node type:

• Axiom (Ax) – a node with two ports both labeled by the same formula (often omitted in diagrams, as in proof nets).
• Exchange (X) – realized by swapping the connections of two edges, reflecting the permutation of antecedents.
• Weakening (W) – a node with a distinguished “erasing” port indicating the introduction of an unused hypothesis.
• Contraction (C) – a node with a “copying” port that merges two identical hypotheses into one.
• ∧‑Introduction (∧I) – a node with two premise ports (for A and B) and a conclusion port labeled A∧B.
• ∧‑Elimination (∧E1, ∧E2) – nodes that project the first or second conjunct from a conjunction.
• ⇒‑Introduction (⇒I) and ⇒‑Elimination (⇒E) – nodes that correspond to λ‑abstraction and application, respectively.

The translation preserves the hierarchical structure of the proof: sub‑proofs become sub‑graphs that are connected to the ports of the rule node representing the outer inference.

Normalization (cut‑elimination) is expressed as graph rewriting. The authors define one‑step normalization rules that replace a pair of adjacent introduction and elimination nodes (e.g., ∧I followed by ∧E1) with a direct connection, possibly inserting weakening or contraction nodes as needed. This mirrors the detour‑removal steps of Prawitz’s normalization and makes the substitution process explicit in the graph. Because port‑graph rewriting is defined via injective morphisms, the rewrite steps are confluent and can be mechanized using existing tools.

Through the Curry‑Howard isomorphism, the same graphical calculus applies to the λ‑calculus. A λ‑term’s typing derivation is translated into a port graph, and β‑reduction corresponds precisely to the ⇒I/⇒E rewrite pattern. Consequently, the calculus provides a unified visual language for both logical proofs and functional program execution, enabling intuitive debugging, educational visualization, and potential optimizations based on graph‑rewriting strategies.

The paper also discusses related work, including deduction graphs, sharing graphs, and bigraphs, highlighting how port graphs subsume these formalisms while offering explicit sharing and nesting capabilities.

In the concluding sections, the authors argue that their approach allows users to select the level of abstraction appropriate for a given analysis: a high‑level view shows the overall flow of logical connectives, whereas a low‑level view exposes the exact copying and erasing operations needed for implementation. They suggest future directions such as extending the calculus to handle exponentials (requiring boxes), integrating automated matching algorithms for efficient rewrite application, and exploring connections with proof assistants.

Overall, the paper presents a well‑motivated, technically sound, and practically useful graphical calculus that bridges proof theory and functional programming through a common port‑graph framework, opening avenues for both theoretical investigation and tool development.