realizability in cyclic proof
play

Realizability in Cyclic Proof Extracting Ordering Information for - PowerPoint PPT Presentation

Dec 28, 2023 •302 likes •1.02k views

Realizability in Cyclic Proof Extracting Ordering Information for Infinite Descent 1 School of Computing, University of Kent, Canterbury, UK 2 Department of Computer Science, UCL, London, UK Reuben N. S. Rowe 1 James Brotherston 2 TABLEAUX,

  1. Realizability in Cyclic Proof Extracting Ordering Information for Infinite Descent 1 School of Computing, University of Kent, Canterbury, UK 2 Department of Computer Science, UCL, London, UK Reuben N. S. Rowe 1 James Brotherston 2 TABLEAUX, Brasília, Brazil, Tuesday 26 th September 2017

  2. Motivation: Program Termination shuffle(y); 1 } rev(y); { y x->next list y n 1 } { y x->next x->next list y n 1 } } } { list x n } list y n { y struct ll { int data; ll *next; } 1 list x n n 0 x NULL list x ->next n void rev(ll *x) ll *y = x -> next; { /* reverses list */ } void shuffle(ll *x) { list x n } { if ( x != NULL ) { { list x->next n 1 } 1/15

  3. Motivation: Program Termination rev(y); { list x n } } } 1 } list y n x->next { y shuffle(y); 1 } list y n x->next { y 1 } struct ll { int data; ll *next; } list y n x->next { y ll *y = x -> next; 1 } { list x->next n if ( x != NULL ) { { { list x n } void shuffle(ll *x) { /* reverses list */ } void rev(ll *x) 1/15 list ( x , n ) ⇔ ( n = 0 ∧ x = NULL ) ∨ list ( x ->next , n − 1 )

  4. Motivation: Program Termination rev(y); } 1 } list y n x->next { y shuffle(y); 1 } list y n x->next { y 1 } struct ll { int data; ll *next; } list y n x->next { y ll *y = x -> next; 1 } { list x->next n if ( x != NULL ) { { /* reverses list */ } void rev(ll *x) 1/15 list ( x , n ) ⇔ ( n = 0 ∧ x = NULL ) ∨ list ( x ->next , n − 1 ) void shuffle(ll *x) { list ( x , n ) } { } { list ( x , n ) }

  5. Motivation: Program Termination x->next } 1 } list y n x->next { y shuffle(y); 1 } list y n { y struct ll { int data; ll *next; } rev(y); ll *y = x -> next; if ( x != NULL ) { { /* reverses list */ } void rev(ll *x) 1/15 list ( x , n ) ⇔ ( n = 0 ∧ x = NULL ) ∨ list ( x ->next , n − 1 ) void shuffle(ll *x) { list ( x , n ) } { { list ( x->next , n − 1 ) } { y = x->next ∧ list ( y , n − 1 ) } } { list ( x , n ) }

  6. Motivation: Program Termination struct ll { int data; ll *next; } } 1 } list y n x->next { y shuffle(y); 1 } list y n x->next { y rev(y); ll *y = x -> next; if ( x != NULL ) { 1/15 list ( x , n ) ⇔ ( n = 0 ∧ x = NULL ) ∨ list ( x ->next , n − 1 ) void rev(ll *x) { list ( x , n ) } { . . . } { list ( x , n ) } void shuffle(ll *x) { list ( x , n ) } { { list ( x->next , n − 1 ) } { y = x->next ∧ list ( y , n − 1 ) } } { list ( x , n ) }

  7. Motivation: Program Termination struct ll { int data; ll *next; } } 1 } list y n x->next { y shuffle(y); 1 } list y n x->next { y rev(y); ll *y = x -> next; if ( x != NULL ) { 1/15 list ( x , n ) ⇔ ( n = 0 ∧ x = NULL ) ∨ list ( x ->next , n − 1 ) void rev(ll *x) { list ( x , n ) } { . . . } { list ( x , n ) } void shuffle(ll *x) { list ( x , n ) } { { list ( x->next , n − 1 ) } { y = x->next ∧ list ( y , n − 1 ) } } { list ( x , n ) }

  8. Motivation: Program Termination struct ll { int data; ll *next; } } 1 } list y n x->next { y shuffle(y); rev(y); ll *y = x -> next; if ( x != NULL ) { 1/15 list ( x , n ) ⇔ ( n = 0 ∧ x = NULL ) ∨ list ( x ->next , n − 1 ) void rev(ll *x) { list ( x , n ) } { . . . } { list ( x , n ) } void shuffle(ll *x) { list ( x , n ) } { { list ( x->next , n − 1 ) } { y = x->next ∧ list ( y , n − 1 ) } { y = x->next ∧ list ( y , n − 1 ) } } { list ( x , n ) }

  9. Motivation: Program Termination struct ll { int data; ll *next; } } 1 } list y n x->next { y shuffle(y); rev(y); ll *y = x -> next; if ( x != NULL ) { 1/15 list ( x , n ) ⇔ ( n = 0 ∧ x = NULL ) ∨ list ( x ->next , n − 1 ) void rev(ll *x) { list ( x , n ) } { . . . } { list ( x , n ) } void shuffle(ll *x) { list ( x , n ) } { { list ( x->next , n − 1 ) } { y = x->next ∧ list ( y , n − 1 ) } { y = x->next ∧ list ( y , n − 1 ) } } { list ( x , n ) }

  10. Motivation: Program Termination struct ll { int data; ll *next; } if ( x != NULL ) { ll *y = x -> next; rev(y); shuffle(y); } 1/15 list ( x , n ) ⇔ ( n = 0 ∧ x = NULL ) ∨ list ( x ->next , n − 1 ) void rev(ll *x) { list ( x , n ) } { . . . } { list ( x , n ) } void shuffle(ll *x) { list ( x , n ) } { { list ( x->next , n − 1 ) } { y = x->next ∧ list ( y , n − 1 ) } { y = x->next ∧ list ( y , n − 1 ) } { y = x->next ∧ list ( y , n − 1 ) } } { list ( x , n ) }

  11. Motivation: Program Termination struct ll { int data; ll *next; } if ( x != NULL ) { ll *y = x -> next; rev(y); shuffle(y); } 1/15 list ( x ) ⇔ ( n = 0 ∧ x = NULL ) ∨ list ( x ->next ) void rev(ll *x) { list α ( x ) } { . . . } { list α ( x ) } void shuffle(ll *x) { list α ( x ) } { { list β ( x->next ) ∧ β < α } { y = x->next ∧ list β ( y ) ∧ β < α } { y = x->next ∧ list β ( y ) ∧ β < α } { y = x->next ∧ list β ( y ) ∧ β < α } } { list α ( x ) }

  12. Motivation: Program Termination shuffle(y); P x Q y Q y P x struct ll { int data; ll *next; } } 1/15 rev(y); if ( x != NULL ) { ll *y = x -> next; list ( x ) ⇔ ( n = 0 ∧ x = NULL ) ∨ list ( x ->next ) void rev(ll *x) { list α ( x ) } { . . . } { list α ( x ) } void shuffle(ll *x) { list α ( x ) } { [ [ · ] ] : Formulas → ℘ ( Models ) { list β ( x->next ) ∧ β < α } [ [ · ] ] ⊥ ⊑ [ [ · ] ] 1 ⊑ . . . [ [ · ] ] α ⊑ [ [ · ] ] α + 1 ⊑ . . . ⊑ [ [ · ] ] { y = x->next ∧ list β ( y ) ∧ β < α } { y = x->next ∧ list β ( y ) ∧ β < α } { y = x->next ∧ list β ( y ) ∧ β < α } } { list α ( x ) }

  13. Motivation: Program Termination ll *y = x -> next; struct ll { int data; ll *next; } } shuffle(y); rev(y); 1/15 if ( x != NULL ) { list ( x ) ⇔ ( n = 0 ∧ x = NULL ) ∨ list ( x ->next ) void rev(ll *x) { list α ( x ) } { . . . } { list α ( x ) } void shuffle(ll *x) { list α ( x ) } { [ [ · ] ] : Formulas → ℘ ( Models ) { list β ( x->next ) ∧ β < α } [ [ · ] ] ⊥ ⊑ [ [ · ] ] 1 ⊑ . . . [ [ · ] ] α ⊑ [ [ · ] ] α + 1 ⊑ . . . ⊑ [ [ · ] ] { y = x->next ∧ list β ( y ) ∧ β < α } ∀ α . [ [ P ( ⃗ x )] ] α ⊆ [ [ Q ( ⃗ y )] ] α ≡ Q ( ⃗ y ) ≤ P ( ⃗ x ) { y = x->next ∧ list β ( y ) ∧ β < α } { y = x->next ∧ list β ( y ) ∧ β < α } } { list α ( x ) }

  14. Motivation: Program Termination struct ll { int data; ll *next; } conditions, in the form of entailments , e.g. Intra-procedural analysis produces verification } shuffle(y); rev(y); ll *y = x -> next; if ( x != NULL ) { 1/15 list ( x ) ⇔ ( n = 0 ∧ x = NULL ) ∨ list ( x ->next ) void rev(ll *x) { list α ( x ) } { . . . } { list α ( x ) } void shuffle(ll *x) { list α ( x ) } { { list β ( x->next ) ∧ β < α } { y = x->next ∧ list β ( y ) ∧ β < α } { y = x->next ∧ list β ( y ) ∧ β < α } x ̸ = NULL ∧ y = x ->next ∧ list ( y ) ⊢ list ( x ) { y = x->next ∧ list β ( y ) ∧ β < α } } { list α ( x ) }

  15. Motivation: Program Termination } (Inference) (Axiom) . . struct ll { int data; ll *next; } . . . . . . 1/15 shuffle(y); rev(y); ll *y = x -> next; if ( x != NULL ) { list ( x ) ⇔ ( n = 0 ∧ x = NULL ) ∨ list ( x ->next ) void rev(ll *x) { list α ( x ) } { . . . } { list α ( x ) } void shuffle(ll *x) { list α ( x ) } { { list β ( x->next ) ∧ β < α } • • · · • . . . . . • { y = x->next ∧ list β ( y ) ∧ β < α } · · • • { y = x->next ∧ list β ( y ) ∧ β < α } • · { y = x->next ∧ list β ( y ) ∧ β < α } · · . . . P ( ⃗ x ) . . . ⊢ . . . Q ( ⃗ y ) . . . } { list α ( x ) }

  16. Motivation: Program Termination } (Inference) (Axiom) . struct ll { int data; ll *next; } . . . . . . . 1/15 shuffle(y); rev(y); ll *y = x -> next; if ( x != NULL ) { list ( x ) ⇔ ( n = 0 ∧ x = NULL ) ∨ list ( x ->next ) void rev(ll *x) { list α ( x ) } { . . . } { list α ( x ) } void shuffle(ll *x) { list α ( x ) } { { list β ( x->next ) ∧ β < α } • • · · • . . . . . • { y = x->next ∧ list β ( y ) ∧ β < α } · · • • Q ( ⃗ y ) ≤ ? P ( ⃗ { y = x->next ∧ list β ( y ) ∧ β < α } x ) • · { y = x->next ∧ list β ( y ) ∧ β < α } · · . . . P ( ⃗ x ) . . . ⊢ . . . Q ( ⃗ y ) . . . } { list α ( x ) }

  17. Motivation: Program Termination } (Inference) (Axiom) . struct ll { int data; ll *next; } . . . . . . . 1/15 shuffle(y); rev(y); ll *y = x -> next; if ( x != NULL ) { list ( x ) ⇔ ( n = 0 ∧ x = NULL ) ∨ list ( x ->next ) void rev(ll *x) { list α ( x ) } { . . . } { list α ( x ) } void shuffle(ll *x) { list α ( x ) } { { list β ( x->next ) ∧ β < α } • • · · • . . . . . • { y = x->next ∧ list β ( y ) ∧ β < α } · · • • Q ( ⃗ y ) < ? P ( ⃗ { y = x->next ∧ list β ( y ) ∧ β < α } x ) • · { y = x->next ∧ list β ( y ) ∧ β < α } · · . . . P ( ⃗ x ) . . . ⊢ . . . Q ( ⃗ y ) . . . } { list α ( x ) }

Recommend

An introduction to cyclic proof James Brotherston Imperial College, London London Theory Day 11

An introduction to cyclic proof James Brotherston Imperial College, London London Theory Day 11

An introduction to cyclic proof James Brotherston Imperial College, London London Theory Day 11 April, 2008 Tree proof vs. cyclic proof (1) Usually a proof is a finite tree of sequents ( ): (Axiom) (Axiom) (Axiom)

169 views • 15 slides
Classical realizability and side-effects Etienne Miquey 1,2 1 Equipe r 2 (INRIA), IRIF,

Classical realizability and side-effects Etienne Miquey 1,2 1 Equipe r 2 (INRIA), IRIF,

Introduction A constructive proof of DC Algebraic models of classical realizability Classical realizability and side-effects Etienne Miquey 1,2 1 Equipe r 2 (INRIA), IRIF, Universit e Paris-Diderot 2 IMERL, Fac. de Ingenier a,

1.24k views • 113 slides
A Combinatorial Proof of the Cyclic Sieving Phenomenon for Faces of Coxeterhedra Tung-Shan Fu

A Combinatorial Proof of the Cyclic Sieving Phenomenon for Faces of Coxeterhedra Tung-Shan Fu

A Combinatorial Proof of the Cyclic Sieving Phenomenon for Faces of Coxeterhedra Tung-Shan Fu Pingtung Institute of Commerce Based on joint work with S.-P. Eu and Y.-J. Pan Cyclic sieving phenomenon X : a finite set X ( q ) : a

932 views • 74 slides
An Introduction to Cyclic Proofs James Brotherston University College London PARIS workshop,

An Introduction to Cyclic Proofs James Brotherston University College London PARIS workshop,

An Introduction to Cyclic Proofs James Brotherston University College London PARIS workshop, FLoC, Oxford, 7th July 2018 1/ 21 Cyclic pre-proofs A cyclic pre-proof is a derivation tree with a backlink from each open leaf (bud) to an

818 views • 62 slides
Transitive Closure Logic Infinitary and Cyclic Proof Systems 1 School of Computing, University of

Transitive Closure Logic Infinitary and Cyclic Proof Systems 1 School of Computing, University of

Transitive Closure Logic Infinitary and Cyclic Proof Systems 1 School of Computing, University of Kent, Canterbury, UK 2 Dept of Computer Science, Cornell University, Ithaca, NY, USA Reuben N. S. Rowe 1 Liron Cohen 2 PARIS Workshop @ FLoC, Sunday 8

859 views • 81 slides
Krivines Classical Realizability from a Categorical Prespective Thomas Streicher (TU

Krivines Classical Realizability from a Categorical Prespective Thomas Streicher (TU

Krivines Classical Realizability from a Categorical Prespective Thomas Streicher (TU Darmstadt) July 2010 The Scenario In Krivines work on Classical Realizability he emphasizes that his notion of realizability is a generalization of

380 views • 26 slides
An introduction to Krivine realizability Alexandre Miquel D E . . O L - P O G I U I

An introduction to Krivine realizability Alexandre Miquel D E . . O L - P O G I U I

Introduction 2nd-order arithmetic (PA2) The c -calculus Realizability Adequacy Witness extraction An introduction to Krivine realizability Alexandre Miquel D E . . O L - P O G I U I Q C E A U R D A E L July 20th,

989 views • 61 slides
An introduction to Kleene realizability Alexandre Miquel D E . . O L - P O G I U I Q

An introduction to Kleene realizability Alexandre Miquel D E . . O L - P O G I U I Q

Introduction Intuitionism &amp; constructivity Heyting Arithmetic Kleene realizability PCAs Concl. An introduction to Kleene realizability Alexandre Miquel D E . . O L - P O G I U I Q C E A U R D A E L July 19th, 2016

901 views • 71 slides
Krivines Classical Realizability from a Categorical Perspective Thomas Streicher (TU

Krivines Classical Realizability from a Categorical Perspective Thomas Streicher (TU

Krivines Classical Realizability from a Categorical Perspective Thomas Streicher (TU Darmstadt) July 2011 The Scenario Krivines Classical Realizability will turn out as a generalization of forcing as known from set theory. Following Hyland

525 views • 33 slides
Realizability games for the specification problem Mauricio Guillermo 2 , Etienne Miquey 1,2 1

Realizability games for the specification problem Mauricio Guillermo 2 , Etienne Miquey 1,2 1

G 1 : a first game G 2 : general case Introduction Classical realizability Specification Conclusion Realizability games for the specification problem Mauricio Guillermo 2 , Etienne Miquey 1,2 1 Team r 2 (INRIA), PPS, Universit e

1.26k views • 110 slides
A Practical Framework for Curry-Style Languages (Inspired by realizability semantics) Rodolphe

A Practical Framework for Curry-Style Languages (Inspired by realizability semantics) Rodolphe

A Practical Framework for Curry-Style Languages (Inspired by realizability semantics) Rodolphe Lepigre 1/18 Context: using realizability for programming languages Last years talk was about the PML language: A simple but powerful

496 views • 18 slides
On quasi-cyclic codes as a generalization of cyclic codes Morgan Barbier

On quasi-cyclic codes as a generalization of cyclic codes Morgan Barbier

On quasi-cyclic codes as a generalization of cyclic codes Morgan Barbier morgan.barbier@unicaen.fr Joint work with: Christophe Chabot Guillaume Quintin University of Caen GREYC Dinard, C2 October 9th 2012 1 / 23 Outline

427 views • 26 slides
Realizability Semantics of Parametric Polymorphism, General References, and Recursive Types Lars

Realizability Semantics of Parametric Polymorphism, General References, and Recursive Types Lars

Realizability Semantics of Parametric Polymorphism, General References, and Recursive Types Lars Birkedal IT University of Copenhagen Joint work with Kristian Stvring and Jacob Thamsborg Sep, 2008 Lars Birkedal (ITU) Realizability for ,

681 views • 25 slides
Reasoning on programs using Step-indexed Realizability Guilhem Jaber PPS, IRIF, Universite Paris

Reasoning on programs using Step-indexed Realizability Guilhem Jaber PPS, IRIF, Universite Paris

Reasoning on programs using Step-indexed Realizability Guilhem Jaber PPS, IRIF, Universite Paris Diderot Realizability in Uruguay 2016 July 19th 2016 1 / 23 How to reason formally on programs ? Program logics (Hoare, Separation, . . . ) Type

702 views • 47 slides
Constructing classical realizability models of Zermelo-Fraenkel set theory Alexandre Miquel Plume

Constructing classical realizability models of Zermelo-Fraenkel set theory Alexandre Miquel Plume

The model M ( A ) Properties of M ( A ) ZF Realizing axioms More axioms Realizability algebras Constructing classical realizability models of Zermelo-Fraenkel set theory Alexandre Miquel Plume team LIP / ENS Lyon June 5th, 2012 R

1.05k views • 61 slides
Efficient Compilation of Cyclic Esterel Programs Jan Lukoschus Reinhard von Hanxleden

Efficient Compilation of Cyclic Esterel Programs Jan Lukoschus Reinhard von Hanxleden

Classes of Cyclic Esterel Programs Existing solutions Proposal 1: Runtime solution Proposal 2: Static Partial Evaluation Proposal 3: Esterel preprocessing for cyclic signals Efficient Compilation of Cyclic Esterel Programs Jan Lukoschus

941 views • 60 slides
The cyclic sieving phenomenon - an introduction Bruce Sagan Department of Mathematics Michigan

The cyclic sieving phenomenon - an introduction Bruce Sagan Department of Mathematics Michigan

The cyclic sieving phenomenon - an introduction Bruce Sagan Department of Mathematics Michigan State University East Lansing, MI 48824-1027 sagan@math.msu.edu www.math.msu.edu/ sagan July 5, 2011 Definitions and an example Proof by

1.69k views • 121 slides
Towards a realizability model of homotopy type theory Jonas Frey joint work (in progress) with

Towards a realizability model of homotopy type theory Jonas Frey joint work (in progress) with

Towards a realizability model of homotopy type theory Jonas Frey joint work (in progress) with Steve Awodey and Pieter Hofstra CT 2017 Vancouver 1 / 24 Overview Motivation : construct realizability model of homotopy type theory , to show

567 views • 24 slides
Cyclic Codes Saravanan Vijayakumaran sarva@ee.iitb.ac.in Department of Electrical Engineering

Cyclic Codes Saravanan Vijayakumaran sarva@ee.iitb.ac.in Department of Electrical Engineering

Cyclic Codes Saravanan Vijayakumaran sarva@ee.iitb.ac.in Department of Electrical Engineering Indian Institute of Technology Bombay August 26, 2014 1 / 25 Cyclic Codes Definition A cyclic shift of a vector v 0 v 1 v n

559 views • 25 slides
Realizability and parametricity in pure type systems Jean-Philippe Bernardy Chalmers

Realizability and parametricity in pure type systems Jean-Philippe Bernardy Chalmers

Realizability and parametricity in pure type systems Jean-Philippe Bernardy Chalmers university Marc Lasson Ecole Normale Sup erieure de Lyon February 15, 2011 1 / 41 Realizability and parametricity in pure type systems Marc

1.45k views • 130 slides
A study of cyclic codes BCH and Reed-Solomon code Welington Santos UFPR January 2015 Cyclic

A study of cyclic codes BCH and Reed-Solomon code Welington Santos UFPR January 2015 Cyclic

A study of cyclic codes BCH and Reed-Solomon code Welington Santos UFPR January 2015 Cyclic Codes Definition A linear ( n, k ) code C over F q is called cyclic if ( a 0 , a 1 , . . . , a n 1 ) C implies ( a n 1 , a 0 , . . . , a n

85 views • 6 slides
On the various definitions of cyclic operads Category Theory 2015, Aveiro Pierre-Louis Curien and

On the various definitions of cyclic operads Category Theory 2015, Aveiro Pierre-Louis Curien and

Cyclic operads revisited The -syntax Microcosm principle for cyclic operads On the various definitions of cyclic operads Category Theory 2015, Aveiro Pierre-Louis Curien and Jovana Obradovi c r 2 team, PPS Laboratory, CNRS, Universit

526 views • 24 slides
Descent sets of cyclic permutations Sergi Elizalde Dartmouth College AMS Fall Eastern Section

Descent sets of cyclic permutations Sergi Elizalde Dartmouth College AMS Fall Eastern Section

Definitions Main result Non-bijective proof Final remarks Descent sets of cyclic permutations Sergi Elizalde Dartmouth College AMS Fall Eastern Section Meeting Special Session on Algebraic Combinatorics Sergi Elizalde Descent sets of

1.05k views • 79 slides
An Introduction to Cyclic Proofs (part II) James Brotherston University College London PARIS

An Introduction to Cyclic Proofs (part II) James Brotherston University College London PARIS

An Introduction to Cyclic Proofs (part II) James Brotherston University College London PARIS workshop, FLoC, Oxford, 8th July 2018 1/ 13 Cyclic proofs Cyclic pre-proofs are derivation trees with backlinks: (Axiom)

142 views • 13 slides

More recommend