Theories of bounded arithmetic for deep inference proof systems
Anupam Das
Ecole Normale Sup´´ erieure de Lyon
Team Carte, LORIA, Nancy March 9, 2015
Outline
1 Introduction 2 Monotone proofs
3 Atomic flows and normalisation 4 Relativised bounded arithmetic
5 Bounded arithmetics for monotone systems 6 Example: correctness of merge-sort
7 Conclusions
Outline
1 Introduction 2 Monotone proofs
3 Atomic flows and normalisation 4 Relativised bounded arithmetic
5 Bounded arithmetics for monotone systems 6 Example: correctness of merge-sort
7 Conclusions
Motivation
• Proof complexity: find lower bounds for Frege systems.
• Subproblem: lower bounds for certainrestrictionson proofs.
• This talk: vary the permitted interactions betweenlogical and structuralsteps in proofs.
• Closely related to normalisation procedures in deep inference.
• (My motivation: proof complexity of deep inference.)
Motivation
• Proof complexity: find lower boundsfor Frege systems.
• Subproblem: lower bounds for certainrestrictionson proofs.
• This talk: vary the permitted interactions betweenlogical and structuralsteps in proofs.
• Closely related to normalisation procedures in deep inference.
• (My motivation: proof complexity of deep inference.)
Motivation
• Proof complexity: find lower boundsfor Frege systems.
• Subproblem: lower bounds for certainrestrictionson proofs.
• This talk: vary the permitted interactions betweenlogical and structuralsteps in proofs.
• Closely related to normalisation procedures in deep inference.
• (My motivation: proof complexity of deep inference.)
Motivation
• Proof complexity: find lower boundsfor Frege systems.
• Subproblem: lower bounds for certainrestrictionson proofs.
• This talk: vary the permitted interactions betweenlogical andstructural steps in proofs.
• Closely related to normalisation procedures in deep inference.
• (My motivation: proof complexity of deep inference.)
Motivation
• Proof complexity: find lower boundsfor Frege systems.
• Subproblem: lower bounds for certainrestrictionson proofs.
• This talk: vary the permitted interactions betweenlogical andstructural steps in proofs.
• Closely related to normalisation procedures in deep inference.
• (My motivation: proof complexity of deep inference.)
Motivation
• Proof complexity: find lower boundsfor Frege systems.
• Subproblem: lower bounds for certainrestrictionson proofs.
• This talk: vary the permitted interactions betweenlogical andstructural steps in proofs.
• Closely related to normalisation procedures in deep inference.
• (My motivation: proof complexity of deep inference.)
Motivation
• Theories of bounded arithmetic areuniform versions of propositional systems.
• Induction formulae can only have bounded quantifiers. E.g.
∀x≤t.∃y ≤t0(x).φ(x,y)
• Proofs of Π1 sentences areformal templates for associated classes of propositional proofs withlow complexity.
• Other uses: bounded reverse mathematics, extraction of algorithms of low complexity,...
Motivation
• Theories of bounded arithmetic areuniform versions of propositional systems.
• Induction formulae can only have bounded quantifiers.
E.g.
∀x≤t.∃y ≤t0(x).φ(x,y)
• Proofs of Π1 sentences areformal templates for associated classes of propositional proofs withlow complexity.
• Other uses: bounded reverse mathematics, extraction of algorithms of low complexity,...
Motivation
• Theories of bounded arithmetic areuniform versions of propositional systems.
• Induction formulae can only have bounded quantifiers. E.g.
∀x≤t.∃y ≤t0(x).φ(x,y)
• Proofs of Π1 sentences areformal templates for associated classes of propositional proofs withlow complexity.
• Other uses: bounded reverse mathematics, extraction of algorithms of low complexity,...
Motivation
• Theories of bounded arithmetic areuniform versions of propositional systems.
• Induction formulae can only have bounded quantifiers. E.g.
∀x≤t.∃y ≤t0(x).φ(x,y)
• Proofs of Π1 sentences areformal templates for associated classes of propositional proofs withlow complexity.
• Other uses: bounded reverse mathematics, extraction of algorithms of low complexity,...
Motivation
• Theories of bounded arithmetic areuniform versions of propositional systems.
• Induction formulae can only have bounded quantifiers. E.g.
∀x≤t.∃y ≤t0(x).φ(x,y)
• Proofs of Π1 sentences areformal templates for associated classes of propositional proofs withlow complexity.
• Other uses: bounded reverse mathematics, extraction of algorithms of low complexity,...
The proposed programme of research
1 Formulate a bounded arithmetic for monotone proofs. Fixed pointssimulate formula classes ofunbounded depth.
2 Recover normal formsof proofs asfragmentsof this theory. Restricting topolynomial inductionsuffices.
. . . bygraph-rewriting-based normalisation indeep inference.
3 Deliver positiveproof complexity resultsand gain intuition towards possiblenegative results.
The proposed programme of research
1 Formulate a bounded arithmetic for monotone proofs.
Fixed pointssimulate formula classes ofunbounded depth.
2 Recover normal formsof proofs asfragmentsof this theory. Restricting topolynomial inductionsuffices.
. . . bygraph-rewriting-based normalisation indeep inference.
3 Deliver positiveproof complexity resultsand gain intuition towards possiblenegative results.
The proposed programme of research
1 Formulate a bounded arithmetic for monotone proofs.
Fixed pointssimulate formula classes ofunbounded depth.
2 Recover normal formsof proofs asfragmentsof this theory. Restricting topolynomial inductionsuffices.
. . . bygraph-rewriting-based normalisation indeep inference.
3 Deliver positiveproof complexity resultsand gain intuition towards possiblenegative results.
The proposed programme of research
1 Formulate a bounded arithmetic for monotone proofs.
Fixed pointssimulate formula classes ofunbounded depth.
2 Recover normal formsof proofs asfragmentsof this theory.
Restricting topolynomial inductionsuffices.
. . . bygraph-rewriting-based normalisation indeep inference.
3 Deliver positiveproof complexity resultsand gain intuition towards possiblenegative results.
The proposed programme of research
1 Formulate a bounded arithmetic for monotone proofs.
Fixed pointssimulate formula classes ofunbounded depth.
2 Recover normal formsof proofs asfragmentsof this theory.
Restricting topolynomial inductionsuffices.
. . . bygraph-rewriting-based normalisation indeep inference.
3 Deliver positiveproof complexity resultsand gain intuition towards possiblenegative results.
The proposed programme of research
1 Formulate a bounded arithmetic for monotone proofs.
Fixed pointssimulate formula classes ofunbounded depth.
2 Recover normal formsof proofs asfragmentsof this theory.
Restricting topolynomial inductionsuffices.
. . . bygraph-rewriting-based normalisation indeep inference.
3 Deliver positiveproof complexity resultsand gain intuition towards possiblenegative results.
The proposed programme of research
1 Formulate a bounded arithmetic for monotone proofs.
Fixed pointssimulate formula classes ofunbounded depth.
2 Recover normal formsof proofs asfragmentsof this theory.
Restricting topolynomial inductionsuffices.
. . . bygraph-rewriting-based normalisation indeep inference.
3 Deliver positiveproof complexity resultsand gain intuition towards possiblenegative results.
Outline
1 Introduction
2 Monotone proofs
3 Atomic flows and normalisation 4 Relativised bounded arithmetic
5 Bounded arithmetics for monotone systems 6 Example: correctness of merge-sort
7 Conclusions
Monotone and normal proofs
• Monotone proofs are obtained by the followingrewrite system,
w1 :A∧B →A w2 :A→A∨B
c1 :A→A∧A c2 :A∨A→A s:A∧(B∨C)→(A∧B)∨C modulo associativity and commutativity of∧ and∨.
• Equivalent to the class of negation-freesequent proofs.
• Normal proofs: all 1-steps occur before all 2-steps.
• (Monotone and normal proofs are also equivalent to certain
‘analytic’deep inferencesystems.)
Monotone and normal proofs
• Monotone proofs are obtained by the followingrewrite system,
w1 :A∧B →A w2 :A→A∨B
c1 :A→A∧A c2 :A∨A→A s:A∧(B∨C)→(A∧B)∨C modulo associativity and commutativity of∧ and∨.
• Equivalent to the class of negation-freesequent proofs.
• Normal proofs: all 1-steps occur before all 2-steps.
• (Monotone and normal proofs are also equivalent to certain
‘analytic’deep inferencesystems.)
Monotone and normal proofs
• Monotone proofs are obtained by the followingrewrite system,
w1 :A∧B →A w2 :A→A∨B
c1 :A→A∧A c2 :A∨A→A s:A∧(B∨C)→(A∧B)∨C modulo associativity and commutativity of∧ and∨.
• Equivalent to the class of negation-freesequent proofs.
• Normal proofs: all 1-steps occur before all 2-steps.
• (Monotone and normal proofs are also equivalent to certain
‘analytic’deep inferencesystems.)
Monotone and normal proofs
• Monotone proofs are obtained by the followingrewrite system,
w1 :A∧B →A w2 :A→A∨B
c1 :A→A∧A c2 :A∨A→A s:A∧(B∨C)→(A∧B)∨C modulo associativity and commutativity of∧ and∨.
• Equivalent to the class of negation-freesequent proofs.
• Normal proofs: all 1-steps occur before all 2-steps.
• (Monotone and normal proofs are also equivalent to certain
‘analytic’deep inferencesystems.)
Outline
1 Introduction 2 Monotone proofs
3 Atomic flows and normalisation 4 Relativised bounded arithmetic
5 Bounded arithmetics for monotone systems 6 Example: correctness of merge-sort
7 Conclusions
Normalisation procedures from deep inference
• Deep inference enjoysfine-grained normalisation procedures.
• These transform monotone proofs to normal ones.
• The idea is as follows:
1 Atomic flow: trace the paths of atoms through proofs.
2 Graph rewritingsteps induce sound manipulationson their associated proofs.
3 Complexity determined bynumber of pathsin the input flow.
• Path counting algorithms from graph theory can then be employed to give accurate estimates.
Normalisation procedures from deep inference
• Deep inference enjoysfine-grained normalisation procedures.
• These transform monotone proofs to normal ones.
• The idea is as follows:
1 Atomic flow: trace the paths of atoms through proofs.
2 Graph rewritingsteps induce sound manipulationson their associated proofs.
3 Complexity determined bynumber of pathsin the input flow.
• Path counting algorithms from graph theory can then be employed to give accurate estimates.
Normalisation procedures from deep inference
• Deep inference enjoysfine-grained normalisation procedures.
• These transform monotone proofs to normal ones.
• The idea is as follows:
1 Atomic flow: trace the paths of atoms through proofs.
2 Graph rewritingsteps induce sound manipulationson their associated proofs.
3 Complexity determined bynumber of pathsin the input flow.
• Path counting algorithms from graph theory can then be employed to give accurate estimates.
Normalisation procedures from deep inference
• Deep inference enjoysfine-grained normalisation procedures.
• These transform monotone proofs to normal ones.
• The idea is as follows:
1 Atomic flow: trace the paths of atoms through proofs.
2 Graph rewritingsteps induce sound manipulationson their associated proofs.
3 Complexity determined bynumber of pathsin the input flow.
• Path counting algorithms from graph theory can then be employed to give accurate estimates.
Normalisation procedures from deep inference
• Deep inference enjoysfine-grained normalisation procedures.
• These transform monotone proofs to normal ones.
• The idea is as follows:
1 Atomic flow: trace the paths of atoms through proofs.
2 Graph rewritingsteps induce sound manipulationson their associated proofs.
3 Complexity determined bynumber of pathsin the input flow.
• Path counting algorithms from graph theory can then be employed to give accurate estimates.
Normalisation procedures from deep inference
• Deep inference enjoysfine-grained normalisation procedures.
• These transform monotone proofs to normal ones.
• The idea is as follows:
1 Atomic flow: trace the paths of atoms through proofs.
2 Graph rewritingsteps induce sound manipulationson their associated proofs.
3 Complexity determined bynumber of pathsin the input flow.
• Path counting algorithms from graph theory can then be employed to give accurate estimates.
Example of an atomic flow
a
−→
w
a∨a
−→
c2
(a∧a)∨a
−→
c2
(a∧a)∨(a∧a)
−→
c1
a∧a
−→
w1
(a∨b)∧a
−→
s/AC
a∨(b∧a)
−→
c2
(a∧a)∨(b∧a)
−→
w2/AC (a∧a)∨b
Local rewriting rules
We consider the followingrewrite system on atomic flows:
→ → →
→ →
→
Theorem
• System isterminating and confluent.
• Induces a transformation from monotone proofs to normal proofspreserving premisses and conclusions.
• Time complexity: polynomial in number of paths of input.
Local rewriting rules
We consider the followingrewrite system on atomic flows:
→ → →
→ →
→
Theorem
• System isterminating and confluent.
• Induces a transformation from monotone proofs to normal proofspreserving premisses and conclusions.
• Time complexity: polynomial in number of paths of input.
Local rewriting rules
We consider the followingrewrite system on atomic flows:
→ → →
→ →
→
Theorem
• System isterminating and confluent.
• Induces a transformation from monotone proofs to normal proofspreserving premisses and conclusions.
• Time complexity: polynomial in number of paths of input.
Local rewriting rules
We consider the followingrewrite system on atomic flows:
→ → →
→ →
→
Theorem
• System isterminating and confluent.
• Induces a transformation from monotone proofs to normal proofspreserving premisses and conclusions.
• Time complexity: polynomial in number of paths of input.
Local rewriting rules
We consider the followingrewrite system on atomic flows:
→ → →
→ →
→
Theorem
• System isterminating and confluent.
• Induces a transformation from monotone proofs to normal proofspreserving premisses and conclusions.
• Time complexity: polynomial in number of paths of input.
Example of a flow reduction
→ → →
Complexity issues
• When is normalisationefficient?
• The typical problem: loops formed fromc1 andc2 nodes alternating in series. E.g.,
. . .
• If there are n loops in total then the number of (maximal) paths is 2n.
Complexity issues
• When is normalisationefficient?
• The typical problem: loops formed fromc1 andc2 nodes alternating in series.
E.g.,
. . .
• If there are n loops in total then the number of (maximal) paths is 2n.
Complexity issues
• When is normalisationefficient?
• The typical problem: loops formed fromc1 andc2 nodes alternating in series. E.g.,
.. .
• If there are n loops in total then the number of (maximal) paths is 2n.
Complexity issues
• When is normalisationefficient?
• The typical problem: loops formed fromc1 andc2 nodes alternating in series. E.g.,
.. .
• If there are n loops in total then the number of (maximal) paths is 2n.
Outline
1 Introduction 2 Monotone proofs
3 Atomic flows and normalisation
4 Relativised bounded arithmetic
5 Bounded arithmetics for monotone systems 6 Example: correctness of merge-sort
7 Conclusions
The Paris-Wilkie translation
• Parikh first considered the theory I∆0, essentially Robinson’s Arithmetic with induction on ∆0-formulae.
• By free-cut elimination all variables in a proof of a Π1 formula can be bounded by a term, i.e. a polynomial.
• Paris and Wilkie gave a translation relating this theory to propositional proofs:
I∆0proofs of Π1formulae are translated toclassesof propositional proofs.
Proofs arepolynomialin size and boundedin depth. Relates concepts in logic to those in (proof) complexity.
The Paris-Wilkie translation
• Parikh first considered the theory I∆0, essentially Robinson’s Arithmetic with induction on ∆0-formulae.
• By free-cut elimination all variables in a proof of a Π1 formula can be bounded by a term, i.e. a polynomial.
• Paris and Wilkie gave a translation relating this theory to propositional proofs:
I∆0proofs of Π1formulae are translated toclassesof propositional proofs.
Proofs arepolynomialin size and boundedin depth. Relates concepts in logic to those in (proof) complexity.
The Paris-Wilkie translation
• Parikh first considered the theory I∆0, essentially Robinson’s Arithmetic with induction on ∆0-formulae.
• By free-cut elimination all variables in a proof of a Π1 formula can be bounded by a term, i.e. a polynomial.
• Paris and Wilkie gave a translation relating this theory to propositional proofs:
I∆0proofs of Π1formulae are translated toclasses of propositional proofs.
Proofs arepolynomialin size and boundedin depth. Relates concepts in logic to those in (proof) complexity.
The Paris-Wilkie translation
• Parikh first considered the theory I∆0, essentially Robinson’s Arithmetic with induction on ∆0-formulae.
• By free-cut elimination all variables in a proof of a Π1 formula can be bounded by a term, i.e. a polynomial.
• Paris and Wilkie gave a translation relating this theory to propositional proofs:
I∆0proofs of Π1formulae are translated toclasses of propositional proofs.
Proofs arepolynomialin size andbounded in depth.
Relates concepts in logic to those in (proof) complexity.
The Paris-Wilkie translation
• Parikh first considered the theory I∆0, essentially Robinson’s Arithmetic with induction on ∆0-formulae.
• By free-cut elimination all variables in a proof of a Π1 formula can be bounded by a term, i.e. a polynomial.
• Paris and Wilkie gave a translation relating this theory to propositional proofs:
I∆0proofs of Π1formulae are translated toclasses of propositional proofs.
Proofs arepolynomialin size andbounded in depth.
Relates concepts in logic to those in (proof) complexity.
Translation of formulae
Closed ∆0-formulae are translated as follows: hP(t)i := pval(t) hs ≤ti :=
(> val(s)≤val(t)
⊥ val(s)>val(t) hφ ? ψi := hφi?hψi
h(∃x ≤t)φ(x)i :=
val(t)
W
k=0
hφ(k)i
h(∀x ≤t)φ(x)i :=
val(t)
V
k=0
hφ(k)i
Translation of formulae
Closed ∆0-formulae are translated as follows:
hP(t)i := pval(t) hs ≤ti :=
(> val(s)≤val(t)
⊥ val(s)>val(t) hφ ? ψi := hφi?hψi
h(∃x ≤t)φ(x)i :=
val(t)
W
k=0
hφ(k)i
h(∀x ≤t)φ(x)i :=
val(t)
V
k=0
hφ(k)i
Translation of proofs
• By free-cut elimination an I∆0-proof of ∀x.φ(x) can be assumed to contain only ∆0-formulae in the free variablex.
• From here proof steps are translated locally.
• For example, this is how the induction ruleis translated:
π(x)
Γ, φ(x)→φ(x+ 1),∆
I N D−−−−−−−−−−−−−−−−−−−−−−−−−−
Γ, φ(0)→φ(t),∆
hπ(0)i
hΓi,hφ(0)i → hφ(1)i,h∆i
· · · hπ(t)i
hΓi,hφ(t−1)i → hφ(t)i,h∆i
cut==========================================================================
hΓi, . . . ,hΓi,hφ(0)i → hφ(t)i,h∆i, . . . ,h∆i
c===================================================
hΓi,hφ(0)i → hφ(t)i,h∆i
Translation of proofs
• By free-cut elimination an I∆0-proof of ∀x.φ(x) can be assumed to contain only ∆0-formulae in the free variablex.
• From here proof steps are translated locally.
• For example, this is how the induction ruleis translated:
π(x)
Γ, φ(x)→φ(x+ 1),∆
I N D−−−−−−−−−−−−−−−−−−−−−−−−−−
Γ, φ(0)→φ(t),∆
hπ(0)i
hΓi,hφ(0)i → hφ(1)i,h∆i
· · · hπ(t)i
hΓi,hφ(t−1)i → hφ(t)i,h∆i
cut==========================================================================
hΓi, . . . ,hΓi,hφ(0)i → hφ(t)i,h∆i, . . . ,h∆i
c===================================================
hΓi,hφ(0)i → hφ(t)i,h∆i
Translation of proofs
• By free-cut elimination an I∆0-proof of ∀x.φ(x) can be assumed to contain only ∆0-formulae in the free variablex.
• From here proof steps are translated locally.
• For example, this is how the induction ruleis translated:
π(x)
Γ, φ(x)→φ(x+ 1),∆
I N D−−−−−−−−−−−−−−−−−−−−−−−−−−
Γ, φ(0)→φ(t),∆
hπ(0)i
hΓi,hφ(0)i → hφ(1)i,h∆i
· · · hπ(t)i
hΓi,hφ(t−1)i → hφ(t)i,h∆i
cut==========================================================================
hΓi, . . . ,hΓi,hφ(0)i → hφ(t)i,h∆i, . . . ,h∆i
c===================================================
hΓi,hφ(0)i → hφ(t)i,h∆i
Translation of proofs
• By free-cut elimination an I∆0-proof of ∀x.φ(x) can be assumed to contain only ∆0-formulae in the free variablex.
• From here proof steps are translated locally.
• For example, this is how the induction ruleis translated:
π(x)
Γ, φ(x)→φ(x+ 1),∆
I N D−−−−−−−−−−−−−−−−−−−−−−−−−−
Γ, φ(0)→φ(t),∆
hπ(0)i
hΓi,hφ(0)i → hφ(1)i,h∆i
· · · hπ(t)i
hΓi,hφ(t−1)i → hφ(t)i,h∆i
cut==========================================================================
hΓi, . . . ,hΓi,hφ(0)i → hφ(t)i,h∆i, . . . ,h∆i
c===================================================
hΓi,hφ(0)i → hφ(t)i,h∆i
Outline
1 Introduction 2 Monotone proofs
3 Atomic flows and normalisation 4 Relativised bounded arithmetic
5 Bounded arithmetics for monotone systems 6 Example: correctness of merge-sort
7 Conclusions
Simulating monotonicity and deep inference
• Monotonicity: nonlogical symbols must occur in positive contextin induction steps.
• Deep inference: admit inductive definitions of predicates.
• E.g. we can define the thresholdpredicate, which is true just when k of P(a), . . . ,P(b) are true:
TP(k,a,b) ↔ ∃i ≤k .
TP i,a,ba+b2 c
∧ TP k−i,ba+b2 c+ 1,b
• (We should somehow control the complexity of closure functions, but we will not address this in this talk.)
Simulating monotonicity and deep inference
• Monotonicity: nonlogical symbols must occur in positive contextin induction steps.
• Deep inference: admit inductive definitions of predicates.
• E.g. we can define the thresholdpredicate, which is true just when k of P(a), . . . ,P(b) are true:
TP(k,a,b) ↔ ∃i ≤k .
TP i,a,ba+b2 c
∧ TP k−i,ba+b2 c+ 1,b
• (We should somehow control the complexity of closure functions, but we will not address this in this talk.)
Simulating monotonicity and deep inference
• Monotonicity: nonlogical symbols must occur in positive contextin induction steps.
• Deep inference: admit inductive definitionsof predicates.
• E.g. we can define the thresholdpredicate, which is true just when k of P(a), . . . ,P(b) are true:
TP(k,a,b) ↔ ∃i ≤k .
TP i,a,ba+b2 c
∧ TP k−i,ba+b2 c+ 1,b
• (We should somehow control the complexity of closure functions, but we will not address this in this talk.)
Simulating monotonicity and deep inference
• Monotonicity: nonlogical symbols must occur in positive contextin induction steps.
• Deep inference: admit inductive definitionsof predicates.
• E.g. we can define the thresholdpredicate, which is true just when k of P(a), . . . ,P(b) are true:
TP(k,a,b) ↔ ∃i ≤k .
TP i,a,ba+b2 c
∧ TP k−i,ba+b2 c+ 1,b
• (We should somehow control the complexity of closure functions, but we will not address this in this talk.)
Simulating monotonicity and deep inference
• Monotonicity: nonlogical symbols must occur in positive contextin induction steps.
• Deep inference: admit inductive definitionsof predicates.
• E.g. we can define the thresholdpredicate, which is true just when k of P(a), . . . ,P(b) are true:
TP(k,a,b) ↔ ∃i ≤k .
TP i,a,ba+b2 c
∧ TP k−i,ba+b2 c+ 1,b
• (We should somehow control the complexity of closure functions, but we will not address this in this talk.)
Induction in deep inference
π(x)
Γ, φ(x)→φ(x+ 1),∆
I N D−−−−−−−−−−−−−−−−−−−−−−−−−−
Γ, φ(0)→φ(t),∆
= · · · ·
Induction in deep inference
Consider the translation of an induction step in deep inference:
π(x)
Γ, φ(x)→φ(x+ 1),∆
I N D−−−−−−−−−−−−−−−−−−−−−−−−−−
Γ, φ(0)→φ(t),∆
c↑ −−−−−Γ−
Γ∧Γ∧φ(0)
=−−−−−−−−−−−−−−−−−−−−−− c↑ −−−−−Γ−
Γ∧Γ∧ Γ∧φ(0)
π(0)
φ(1)∨∆
s−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
Γ
c↑ −−−−−−
Γ∧Γ∧
Γ∧φ(1)
π(1)
φ(2)∨∆
∨ ∆∨∆
c↓ −−−−−−−
∆
s−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
...
s−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
Γ∧
Γ∧φ(t−1)
π(t−2)
φ(t−1)∨∆
∨ ∆∨∆
c↓ −−−−−−−
∆
s−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
Γ∧φ(t−1)
π(t−1)
φ(t)∨∆
∨ ∆∨∆
c↓ −−−−−−−
∆
=−−−−−−−−−−−−−−−−−−−−−−−−−−−
φ(t)∨ ∆∨∆
c↓ −−−−−−−
∆
= · · · ·
Induction in deep inference
Analysing this from astructural point of view:
π(x)
Γ, φ(x)→φ(x+ 1),∆
I N D−−−−−−−−−−−−−−−−−−−−−−−−−−
Γ, φ(0)→φ(t),∆
c↑−−−−−−Γ Γ∧Γ∧φ(0)
=−−−−−−−−−−−−−−−−−−−−−−
c↑−−−−−−Γ Γ∧Γ∧
Γ∧φ(0)
π(0)
φ(1)∨∆
s−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
c↑−−−−−−Γ Γ∧Γ∧
Γ∧φ(1)
π(1)
φ(2)∨∆
∨ ∆∨∆
c↓−−−−−−−
∆
s−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
...
s−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
Γ∧ Γ∧φ(t−1)
π(t−2)
φ(t−1)∨∆
∨ ∆∨∆
c↓−−−−−−−
∆
s−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
Γ∧φ(t−1)
π(t−1)
φ(t)∨∆
∨ ∆∨∆
c↓−−−−−−−
∆
=−−−−−−−−−−−−−−−−−−−−−−−−−−−
∆∨∆
= · · · ·
Induction in deep inference
Analysing this from astructural point of view:
π(x)
Γ, φ(x)→φ(x+ 1),∆
I N D−−−−−−−−−−−−−−−−−−−−−−−−−−
Γ, φ(0)→φ(t),∆
= · · · ·
Induction in deep inference
Analysing this from astructural point of view:
π(x)
Γ, φ(x)→φ(x+ 1),∆
I N D−−−−−−−−−−−−−−−−−−−−−−−−−−
Γ, φ(0)→φ(t),∆
= · · · ·
Induction in deep inference
Analysing this from astructural point of view:
π(x)
Γ, φ(x)→φ(x+ 1),∆
I N D−−−−−−−−−−−−−−−−−−−−−−−−−−
Γ, φ(0)→φ(t),∆
= · · · ·
Induction in deep inference
• Multiple inductions induce flows with polynomial-length sequences of loops, meaninginefficient normalisation.
• Solution: replace induction withpolynomial induction: Γ, φ(bx2c)→φ(x),∆
PIND−−−−−−−−−−−−−−−−−−−−−−−
Γ, φ(0)→φ(t),∆
• Length of atomic flows is now polylogarithmicallybounded.
• So time complexity of normalisation isquasipolynomially bounded.
Induction in deep inference
• Multiple inductions induce flows with polynomial-length sequences of loops, meaninginefficient normalisation.
• Solution: replace induction withpolynomial induction:
Γ, φ(bx2c)→φ(x),∆
PIND−−−−−−−−−−−−−−−−−−−−−−−
Γ, φ(0)→φ(t),∆
• Length of atomic flows is now polylogarithmicallybounded.
• So time complexity of normalisation isquasipolynomially bounded.
Induction in deep inference
• Multiple inductions induce flows with polynomial-length sequences of loops, meaninginefficient normalisation.
• Solution: replace induction withpolynomial induction:
Γ, φ(bx2c)→φ(x),∆
PIND−−−−−−−−−−−−−−−−−−−−−−−
Γ, φ(0)→φ(t),∆
• Length of atomic flows is now polylogarithmicallybounded.
• So time complexity of normalisation isquasipolynomially bounded.
Induction in deep inference
• Multiple inductions induce flows with polynomial-length sequences of loops, meaninginefficient normalisation.
• Solution: replace induction withpolynomial induction:
Γ, φ(bx2c)→φ(x),∆
PIND−−−−−−−−−−−−−−−−−−−−−−−
Γ, φ(0)→φ(t),∆
• Length of atomic flows is now polylogarithmicallybounded.
• So time complexity of normalisation isquasipolynomially bounded.
Outline
1 Introduction 2 Monotone proofs
3 Atomic flows and normalisation 4 Relativised bounded arithmetic
5 Bounded arithmetics for monotone systems 6 Example: correctness of merge-sort
7 Conclusions
Definition of merge sort
Aninductive definition for merge-sort on a stringσ =σ1σ2, with
|σ1|=|σ2|=n, can be given as follows, Definition (Merge sort)
sort(σ) :=merge(sort(σ1),sort(σ2)) wheremerge(α1· · ·αm, β1· · ·βn) :=τ1τ2 with,
τ1 = merge(α1· · ·αk, β1· · ·βc−k), τ2 = merge(αk+1· · ·αn, βc−k+1· · ·αn) forc =bm+n2 cand the leastk such that τi1≤τj2 for all i,j. Naturally, we shouldformally prove that some suchk exists.
Definition of merge sort
Aninductive definition for merge-sort on a stringσ =σ1σ2, with
|σ1|=|σ2|=n, can be given as follows,
Definition (Merge sort)
sort(σ) :=merge(sort(σ1),sort(σ2)) wheremerge(α1· · ·αm, β1· · ·βn) :=τ1τ2 with,
τ1 = merge(α1· · ·αk, β1· · ·βc−k), τ2 = merge(αk+1· · ·αn, βc−k+1· · ·αn) forc =bm+n2 cand the leastk such that τi1≤τj2 for all i,j. Naturally, we shouldformally prove that some suchk exists.
Definition of merge sort
Aninductive definition for merge-sort on a stringσ =σ1σ2, with
|σ1|=|σ2|=n, can be given as follows, Definition (Merge sort)
sort(σ) :=merge(sort(σ1),sort(σ2))
wheremerge(α1· · ·αm, β1· · ·βn) :=τ1τ2 with, τ1 = merge(α1· · ·αk, β1· · ·βc−k), τ2 = merge(αk+1· · ·αn, βc−k+1· · ·αn) forc =bm+n2 cand the leastk such that τi1≤τj2 for all i,j. Naturally, we shouldformally prove that some suchk exists.
Definition of merge sort
Aninductive definition for merge-sort on a stringσ =σ1σ2, with
|σ1|=|σ2|=n, can be given as follows, Definition (Merge sort)
sort(σ) :=merge(sort(σ1),sort(σ2)) wheremerge(α1· · ·αm, β1· · ·βn) :=τ1τ2 with,
τ1 = merge(α1· · ·αk, β1· · ·βc−k), τ2 = merge(αk+1· · ·αn, βc−k+1· · ·αn) forc =bm+n2 cand the leastk such that τi1≤τj2 for all i,j.
Naturally, we shouldformally prove that some suchk exists.
Definition of merge sort
Aninductive definition for merge-sort on a stringσ =σ1σ2, with
|σ1|=|σ2|=n, can be given as follows, Definition (Merge sort)
sort(σ) :=merge(sort(σ1),sort(σ2)) wheremerge(α1· · ·αm, β1· · ·βn) :=τ1τ2 with,
τ1 = merge(α1· · ·αk, β1· · ·βc−k), τ2 = merge(αk+1· · ·αn, βc−k+1· · ·αn) forc =bm+n2 cand the leastk such that τi1≤τj2 for all i,j. Naturally, we shouldformally provethat some such k exists.
Sign-change lemma
Essentially we need the following lemma:
Lemma
If a<b, f(a)<0 and f(b)≥0 ⇒ then∃x ∈[a,b) such that f(x)<0and f(x+ 1)≥0.
We can prove this in our theory using aninterval-halving algorithm. Proof.
By induction onb−a. For thebase case we have thatb−a= 1, sox =a will do.
For theinductive step, let c =da+b2 e and we have that f(c)≥0 orf(c)<0. In the former case we appeal to the inductive
hypothesis on the interval [a,c), and in the latter [c,b).
Sign-change lemma
Essentially we need the following lemma:
Lemma
If a<b, f(a)<0 and f(b)≥0 ⇒ then∃x ∈[a,b) such that f(x)<0and f(x+ 1)≥0.
We can prove this in our theory using aninterval-halving algorithm.
Proof.
By induction onb−a. For thebase case we have thatb−a= 1, sox =a will do.
For theinductive step, let c =da+b2 e and we have that f(c)≥0 orf(c)<0. In the former case we appeal to the inductive
hypothesis on the interval [a,c), and in the latter [c,b).
Sign-change lemma
Essentially we need the following lemma:
Lemma
If a<b, f(a)<0 and f(b)≥0 ⇒ then∃x ∈[a,b) such that f(x)<0and f(x+ 1)≥0.
We can prove this in our theory using aninterval-halving algorithm.
Proof.
By induction onb−a. For thebase case we have thatb−a= 1, sox =a will do.
For theinductive step, let c =da+b2 e and we have that f(c)≥0 orf(c)<0. In the former case we appeal to the inductive
hypothesis on the interval [a,c), and in the latter [c,b).
Sign-change lemma
Essentially we need the following lemma:
Lemma
If a<b, f(a)<0 and f(b)≥0 ⇒ then∃x ∈[a,b) such that f(x)<0and f(x+ 1)≥0.
We can prove this in our theory using aninterval-halving algorithm.
Proof.
By induction onb−a. For thebase case we have thatb−a= 1, sox =a will do.
For theinductive step, let c =da+b2 e and we have that f(c)≥0 orf(c)<0. In the former case we appeal to the inductive
hypothesis on the interval [a,c), and in the latter [c,b).
Well-definedness
Theorem
The functions sort and merge are well-defined.
Correctness
A stringσ is sortedif, for every i <|σ|, we have that σi ≤σi+1. Theorem
For any stringσ, sort(σ) is sorted.
Proof sketch.
Letσ =σ1σ2 and proceed by induction on |σ|. By the inductive definition we have thatsort(σ) =merge(sort(σ1),sort(σ2)). The two arguments of the merge are sorted, by the inductive hypothesis and, byinvoking another inductionand appealing to the construction of merge, we have that the merge of two sorted strings is sorted, whence the result follows.
Correctness
A stringσ is sortedif, for every i <|σ|, we have that σi ≤σi+1.
Theorem
For any stringσ, sort(σ) is sorted.
Proof sketch.
Letσ =σ1σ2 and proceed by induction on |σ|. By the inductive definition we have thatsort(σ) =merge(sort(σ1),sort(σ2)). The two arguments of the merge are sorted, by the inductive hypothesis and, byinvoking another inductionand appealing to the construction of merge, we have that the merge of two sorted strings is sorted, whence the result follows.
Correctness
A stringσ is sortedif, for every i <|σ|, we have that σi ≤σi+1. Theorem
For any stringσ, sort(σ) is sorted.
Proof sketch.
Letσ =σ1σ2 and proceed by induction on |σ|. By the inductive definition we have thatsort(σ) =merge(sort(σ1),sort(σ2)). The two arguments of the merge are sorted, by the inductive hypothesis and, byinvoking another inductionand appealing to the construction of merge, we have that the merge of two sorted strings is sorted, whence the result follows.
Correctness
A stringσ is sortedif, for every i <|σ|, we have that σi ≤σi+1. Theorem
For any stringσ, sort(σ) is sorted.
Proof sketch.
Letσ =σ1σ2 and proceed by induction on |σ|.
By the inductive definition we have thatsort(σ) =merge(sort(σ1),sort(σ2)). The two arguments of the merge are sorted, by the inductive hypothesis and, byinvoking another inductionand appealing to the construction of merge, we have that the merge of two sorted strings is sorted, whence the result follows.
Correctness
A stringσ is sortedif, for every i <|σ|, we have that σi ≤σi+1. Theorem
For any stringσ, sort(σ) is sorted.
Proof sketch.
Letσ =σ1σ2 and proceed by induction on |σ|. By the inductive definition we have thatsort(σ) =merge(sort(σ1),sort(σ2)).
The two arguments of the merge are sorted, by the inductive hypothesis and, byinvoking another inductionand appealing to the construction of merge, we have that the merge of two sorted strings is sorted, whence the result follows.
Correctness
A stringσ is sortedif, for every i <|σ|, we have that σi ≤σi+1. Theorem
For any stringσ, sort(σ) is sorted.
Proof sketch.
Letσ =σ1σ2 and proceed by induction on |σ|. By the inductive definition we have thatsort(σ) =merge(sort(σ1),sort(σ2)).
The two arguments of the merge are sorted, by the inductive hypothesis and, byinvoking another inductionand appealing to the construction ofmerge, we have that the merge of two sorted strings is sorted, whence the result follows.