Strong free-channel barbed bisimilarity
InductiveFree-channel input and output observables#✓fully proved
A visible input or output subject. Restricted variables are not subjects of these free-channel observations.
inductive Observable where
| input (channel : ℕ)
| output (channel : ℕ)
deriving DecidableEq, Repr
Used by 17
InductiveFree-channel guard offered without reduction#✓fully proved
A selected free-channel guard exposed without reduction. Restrictions hide bound subjects but do not hide free constants.
inductive Offer : Proc → Observable → Prop where
| input {p q : Proc} {a : ℕ} :
Select p (.inp (.const a) q) → Offer p (.input a)
| output {p q : Proc} {a : ℕ} {b : Name} :
Select p (.out (.const a) b q) → Offer p (.output a)
| parL {p q : Proc} {o : Observable} :
Offer p o → Offer (.par p q) o
| parR {p q : Proc} {o : Observable} :
Offer q o → Offer (.par p q) o
| nu {p : Proc} {o : Observable} : Offer p o → Offer (.nu p) o
inductive Proc where
| nil : Proc
| out (a b : Name) (p : Proc) : Proc
| inp (a : Name) (p : Proc) : Proc
| par (p q : Proc) : Proc
| nu (p : Proc) : Proc
| repl (p : Proc) : Proc
| sum (p q : Proc) : Proc
deriving DecidableEq, Repr
CSLibExt/Languages/PiCalculus/Basic.lean:52
inductive Observable where
| input (channel : ℕ)
| output (channel : ℕ)
deriving DecidableEq, Repr
CSLibExt/Languages/PiCalculus/Behavioural.lean:37
inductive Select : Proc → Proc → Prop
| refl (p : Proc) : Select p p
| left (p q : Proc) : Select (.sum p q) p
| right (p q : Proc) : Select (.sum p q) q
| trans {p q r : Proc} : Select p q → Select q r → Select p r
CSLibExt/Languages/PiCalculus/Basic.lean:162
inductive Name where
| const (n : ℕ) : Name
| var (i : ℕ) : Name
deriving DecidableEq, Repr
CSLibExt/Languages/PiCalculus/Basic.lean:45
Uses 4 · Used by 8
DefinitionImmediate free-channel barb#✓fully proved
Immediate free-channel readiness, up to the existing structural
congruence. A witness performs no Step.
def Barb (p : Proc) (o : Observable) : Prop :=
∃ q, Cong p q ∧ Offer q o
inductive Proc where
| nil : Proc
| out (a b : Name) (p : Proc) : Proc
| inp (a : Name) (p : Proc) : Proc
| par (p q : Proc) : Proc
| nu (p : Proc) : Proc
| repl (p : Proc) : Proc
| sum (p q : Proc) : Proc
deriving DecidableEq, Repr
CSLibExt/Languages/PiCalculus/Basic.lean:52
inductive Observable where
| input (channel : ℕ)
| output (channel : ℕ)
deriving DecidableEq, Repr
CSLibExt/Languages/PiCalculus/Behavioural.lean:37
inductive Cong : Proc → Proc → Prop
| refl (p : Proc) : Cong p p
| symm {p q : Proc} : Cong p q → Cong q p
| trans {p q r : Proc} : Cong p q → Cong q r → Cong p r
| par_comm (p q : Proc) : Cong (.par p q) (.par q p)
| par_assoc (p q r : Proc) : Cong (.par (.par p q) r) (.par p (.par q r))
| par_nil (p : Proc) : Cong (.par p .nil) p
| par_cong {p p' q q' : Proc} : Cong p p' → Cong q q' →
Cong (.par p q) (.par p' q')
| nu_cong {p p' : Proc} : Cong p p' → Cong (.nu p) (.nu p')
| scope (p q : Proc) :
Cong (.par (.nu p) q) (.nu (.par p (liftProc 0 q)))
⋯
CSLibExt/Languages/PiCalculus/Basic.lean:137
inductive Offer : Proc → Observable → Prop where
| input {p q : Proc} {a : ℕ} :
Select p (.inp (.const a) q) → Offer p (.input a)
| output {p q : Proc} {a : ℕ} {b : Name} :
Select p (.out (.const a) b q) → Offer p (.output a)
| parL {p q : Proc} {o : Observable} :
Offer p o → Offer (.par p q) o
| parR {p q : Proc} {o : Observable} :
Offer q o → Offer (.par p q) o
| nu {p : Proc} {o : Observable} : Offer p o → Offer (.nu p) o
CSLibExt/Languages/PiCalculus/Behavioural.lean:44
Uses 4 · Used by 14
InductiveLabels for reductions and barb observations#✓fully proved
Labels for reductions and observation-only self-loops.
inductive BehaviourLabel where
| reduce
| observe (o : Observable)
deriving DecidableEq, Repr
inductive Observable where
| input (channel : ℕ)
| output (channel : ℕ)
deriving DecidableEq, Repr
CSLibExt/Languages/PiCalculus/Behavioural.lean:37
Uses 1 · Used by 8
DefinitionReduction LTS decorated with barb observations#✓fully proved
The existing reduction semantics decorated with barb tests. The observation transitions do not consume a prefix or transmit a name.
def observedLTS : LTS Proc BehaviourLabel where
Tr p label q := match label with
| .reduce => Step p q
| .observe o => p = q ∧ Barb p o
inductive Proc where
| nil : Proc
| out (a b : Name) (p : Proc) : Proc
| inp (a : Name) (p : Proc) : Proc
| par (p q : Proc) : Proc
| nu (p : Proc) : Proc
| repl (p : Proc) : Proc
| sum (p q : Proc) : Proc
deriving DecidableEq, Repr
CSLibExt/Languages/PiCalculus/Basic.lean:52
inductive BehaviourLabel where
| reduce
| observe (o : Observable)
deriving DecidableEq, Repr
CSLibExt/Languages/PiCalculus/Behavioural.lean:61
inductive Step : Proc → Proc → Prop
| commSelect {a : Name} {b : Name} {p' q' p q : Proc} :
Select p (.out a b p') → Select q (.inp a q') →
Step (.par p q) (.par p' (subst q' b))
| parL {p p' q : Proc} : Step p p' → Step (.par p q) (.par p' q)
| parR {p p' q : Proc} : Step p p' → Step (.par q p) (.par q p')
| nu {p p' : Proc} : Step p p' → Step (.nu p) (.nu p')
| cong {p p' q q' : Proc} : Cong p p' → Step p' q' → Cong q' q →
Step p q
CSLibExt/Languages/PiCalculus/Basic.lean:172
def Barb (p : Proc) (o : Observable) : Prop :=
∃ q, Cong p q ∧ Offer q o
CSLibExt/Languages/PiCalculus/Behavioural.lean:57
Uses 5 · Used by 7
DefinitionStrong barbed bisimilarity#✓fully proved
Strong barbed bisimilarity, using the canonical CSLib bisimulation API. No context closure is built into this relation.
def BarbedBisimilar : Proc → Proc → Prop :=
LTS.HomBisimilarity observedLTS
inductive Proc where
| nil : Proc
| out (a b : Name) (p : Proc) : Proc
| inp (a : Name) (p : Proc) : Proc
| par (p q : Proc) : Proc
| nu (p : Proc) : Proc
| repl (p : Proc) : Proc
| sum (p q : Proc) : Proc
deriving DecidableEq, Repr
CSLibExt/Languages/PiCalculus/Basic.lean:52
def observedLTS : LTS Proc BehaviourLabel where
Tr p label q := match label with
| .reduce => Step p q
| .observe o => p = q ∧ Barb p o
CSLibExt/Languages/PiCalculus/Behavioural.lean:68
Uses 3 · Used by 10
TheoremDecorated-LTS bisimulations are exactly strong barbed bisimulations#✓fully proved
The decorated LTS has precisely the strong reduction-matching and immediate-barb-preservation clauses of a strong barbed bisimulation.
theorem isBisimulation_observedLTS_iff (r : Proc → Proc → Prop) :
LTS.IsHomBisimulation observedLTS r ↔
∀ ⦃p q⦄, r p q →
(∀ p', Step p p' → ∃ q', Step q q' ∧ r p' q') ∧
(∀ q', Step q q' → ∃ p', Step p p' ∧ r p' q') ∧
(∀ o, Barb p o ↔ Barb q o)
inductive Proc where
| nil : Proc
| out (a b : Name) (p : Proc) : Proc
| inp (a : Name) (p : Proc) : Proc
| par (p q : Proc) : Proc
| nu (p : Proc) : Proc
| repl (p : Proc) : Proc
| sum (p q : Proc) : Proc
deriving DecidableEq, Repr
CSLibExt/Languages/PiCalculus/Basic.lean:52
def observedLTS : LTS Proc BehaviourLabel where
Tr p label q := match label with
| .reduce => Step p q
| .observe o => p = q ∧ Barb p o
CSLibExt/Languages/PiCalculus/Behavioural.lean:68
inductive Step : Proc → Proc → Prop
| commSelect {a : Name} {b : Name} {p' q' p q : Proc} :
Select p (.out a b p') → Select q (.inp a q') →
Step (.par p q) (.par p' (subst q' b))
| parL {p p' q : Proc} : Step p p' → Step (.par p q) (.par p' q)
| parR {p p' q : Proc} : Step p p' → Step (.par q p) (.par q p')
| nu {p p' : Proc} : Step p p' → Step (.nu p) (.nu p')
| cong {p p' q q' : Proc} : Cong p p' → Step p' q' → Cong q' q →
Step p q
CSLibExt/Languages/PiCalculus/Basic.lean:172
def Barb (p : Proc) (o : Observable) : Prop :=
∃ q, Cong p q ∧ Offer q o
CSLibExt/Languages/PiCalculus/Behavioural.lean:57
TheoremStructural congruence preserves immediate barbs#✓fully proved
Structural congruence preserves immediate barbs.
theorem Cong.barb_iff {p q : Proc} (h : Cong p q) (o : Observable) :
Barb p o ↔ Barb q o
inductive Proc where
| nil : Proc
| out (a b : Name) (p : Proc) : Proc
| inp (a : Name) (p : Proc) : Proc
| par (p q : Proc) : Proc
| nu (p : Proc) : Proc
| repl (p : Proc) : Proc
| sum (p q : Proc) : Proc
deriving DecidableEq, Repr
CSLibExt/Languages/PiCalculus/Basic.lean:52
inductive Cong : Proc → Proc → Prop
| refl (p : Proc) : Cong p p
| symm {p q : Proc} : Cong p q → Cong q p
| trans {p q r : Proc} : Cong p q → Cong q r → Cong p r
| par_comm (p q : Proc) : Cong (.par p q) (.par q p)
| par_assoc (p q r : Proc) : Cong (.par (.par p q) r) (.par p (.par q r))
| par_nil (p : Proc) : Cong (.par p .nil) p
| par_cong {p p' q q' : Proc} : Cong p p' → Cong q q' →
Cong (.par p q) (.par p' q')
| nu_cong {p p' : Proc} : Cong p p' → Cong (.nu p) (.nu p')
| scope (p q : Proc) :
Cong (.par (.nu p) q) (.nu (.par p (liftProc 0 q)))
⋯
CSLibExt/Languages/PiCalculus/Basic.lean:137
inductive Observable where
| input (channel : ℕ)
| output (channel : ℕ)
deriving DecidableEq, Repr
CSLibExt/Languages/PiCalculus/Behavioural.lean:37
def Barb (p : Proc) (o : Observable) : Prop :=
∃ q, Cong p q ∧ Offer q o
CSLibExt/Languages/PiCalculus/Behavioural.lean:57
Uses 5 · Used by 1
TheoremStructural congruence is a strong barbed bisimulation#✓fully proved
Structural congruence is a strong barbed bisimulation: reductions match one for one, while free-channel observations match immediately.
theorem cong_isBarbedBisimulation :
LTS.IsHomBisimulation observedLTS Cong
def observedLTS : LTS Proc BehaviourLabel where
Tr p label q := match label with
| .reduce => Step p q
| .observe o => p = q ∧ Barb p o
CSLibExt/Languages/PiCalculus/Behavioural.lean:68
inductive Cong : Proc → Proc → Prop
| refl (p : Proc) : Cong p p
| symm {p q : Proc} : Cong p q → Cong q p
| trans {p q r : Proc} : Cong p q → Cong q r → Cong p r
| par_comm (p q : Proc) : Cong (.par p q) (.par q p)
| par_assoc (p q r : Proc) : Cong (.par (.par p q) r) (.par p (.par q r))
| par_nil (p : Proc) : Cong (.par p .nil) p
| par_cong {p p' q q' : Proc} : Cong p p' → Cong q q' →
Cong (.par p q) (.par p' q')
| nu_cong {p p' : Proc} : Cong p p' → Cong (.nu p) (.nu p')
| scope (p q : Proc) :
Cong (.par (.nu p) q) (.nu (.par p (liftProc 0 q)))
⋯
CSLibExt/Languages/PiCalculus/Basic.lean:137
Uses 9 · Used by 1
TheoremStructurally congruent processes are barbed bisimilar#✓fully proved
Every structural law of Basic is sound for strong barbed
bisimilarity, including scope extrusion and replication unfolding.
theorem Cong.barbedBisimilar {p q : Proc} (h : Cong p q) :
BarbedBisimilar p q
inductive Proc where
| nil : Proc
| out (a b : Name) (p : Proc) : Proc
| inp (a : Name) (p : Proc) : Proc
| par (p q : Proc) : Proc
| nu (p : Proc) : Proc
| repl (p : Proc) : Proc
| sum (p q : Proc) : Proc
deriving DecidableEq, Repr
CSLibExt/Languages/PiCalculus/Basic.lean:52
inductive Cong : Proc → Proc → Prop
| refl (p : Proc) : Cong p p
| symm {p q : Proc} : Cong p q → Cong q p
| trans {p q r : Proc} : Cong p q → Cong q r → Cong p r
| par_comm (p q : Proc) : Cong (.par p q) (.par q p)
| par_assoc (p q r : Proc) : Cong (.par (.par p q) r) (.par p (.par q r))
| par_nil (p : Proc) : Cong (.par p .nil) p
| par_cong {p p' q q' : Proc} : Cong p p' → Cong q q' →
Cong (.par p q) (.par p' q')
| nu_cong {p p' : Proc} : Cong p p' → Cong (.nu p) (.nu p')
| scope (p q : Proc) :
Cong (.par (.nu p) q) (.nu (.par p (liftProc 0 q)))
⋯
CSLibExt/Languages/PiCalculus/Basic.lean:137
def BarbedBisimilar : Proc → Proc → Prop :=
LTS.HomBisimilarity observedLTS
CSLibExt/Languages/PiCalculus/Behavioural.lean:75
DefinitionUnguarded output in a process#✓fully proved
An output not behind a prefix, on any subject (including bound names). This is an overapproximation for arbitrary unguarded sums, not a barb.
def HasUnguardedOutput : Proc → Prop
| .nil => False
| .out _ _ _ => True
| .inp _ _ => False
| .par p q => HasUnguardedOutput p ∨ HasUnguardedOutput q
| .nu p => HasUnguardedOutput p
| .repl p => HasUnguardedOutput p
| .sum p q => HasUnguardedOutput p ∨ HasUnguardedOutput q
inductive Proc where
| nil : Proc
| out (a b : Name) (p : Proc) : Proc
| inp (a : Name) (p : Proc) : Proc
| par (p q : Proc) : Proc
| nu (p : Proc) : Proc
| repl (p : Proc) : Proc
| sum (p q : Proc) : Proc
deriving DecidableEq, Repr
CSLibExt/Languages/PiCalculus/Basic.lean:52
Uses 2 · Used by 6
TheoremStructural congruence preserves unguarded outputs#✓fully proved
Structural rearrangement cannot expose an output from an input-guarded process. This includes arbitrary uses of replication and scope laws.
theorem Cong.hasUnguardedOutput_iff {p q : Proc} (h : Cong p q) :
HasUnguardedOutput p ↔ HasUnguardedOutput q
inductive Proc where
| nil : Proc
| out (a b : Name) (p : Proc) : Proc
| inp (a : Name) (p : Proc) : Proc
| par (p q : Proc) : Proc
| nu (p : Proc) : Proc
| repl (p : Proc) : Proc
| sum (p q : Proc) : Proc
deriving DecidableEq, Repr
CSLibExt/Languages/PiCalculus/Basic.lean:52
inductive Cong : Proc → Proc → Prop
| refl (p : Proc) : Cong p p
| symm {p q : Proc} : Cong p q → Cong q p
| trans {p q r : Proc} : Cong p q → Cong q r → Cong p r
| par_comm (p q : Proc) : Cong (.par p q) (.par q p)
| par_assoc (p q r : Proc) : Cong (.par (.par p q) r) (.par p (.par q r))
| par_nil (p : Proc) : Cong (.par p .nil) p
| par_cong {p p' q q' : Proc} : Cong p p' → Cong q q' →
Cong (.par p q) (.par p' q')
| nu_cong {p p' : Proc} : Cong p p' → Cong (.nu p) (.nu p')
| scope (p q : Proc) :
Cong (.par (.nu p) q) (.nu (.par p (liftProc 0 q)))
⋯
CSLibExt/Languages/PiCalculus/Basic.lean:137
def HasUnguardedOutput : Proc → Prop
| .nil => False
| .out _ _ _ => True
| .inp _ _ => False
| .par p q => HasUnguardedOutput p ∨ HasUnguardedOutput q
| .nu p => HasUnguardedOutput p
| .repl p => HasUnguardedOutput p
| .sum p q => HasUnguardedOutput p ∨ HasUnguardedOutput q
CSLibExt/Languages/PiCalculus/Behavioural.lean:132
Uses 8 · Used by 1
TheoremEvery reduction source has an unguarded output#✓fully proved
Every reduction needs an unguarded output in its source, even when communication is private or structural congruence is used arbitrarily.
theorem Step.hasUnguardedOutput {p q : Proc} (h : Step p q) :
HasUnguardedOutput p
inductive Proc where
| nil : Proc
| out (a b : Name) (p : Proc) : Proc
| inp (a : Name) (p : Proc) : Proc
| par (p q : Proc) : Proc
| nu (p : Proc) : Proc
| repl (p : Proc) : Proc
| sum (p q : Proc) : Proc
deriving DecidableEq, Repr
CSLibExt/Languages/PiCalculus/Basic.lean:52
inductive Step : Proc → Proc → Prop
| commSelect {a : Name} {b : Name} {p' q' p q : Proc} :
Select p (.out a b p') → Select q (.inp a q') →
Step (.par p q) (.par p' (subst q' b))
| parL {p p' q : Proc} : Step p p' → Step (.par p q) (.par p' q)
| parR {p p' q : Proc} : Step p p' → Step (.par q p) (.par q p')
| nu {p p' : Proc} : Step p p' → Step (.nu p) (.nu p')
| cong {p p' q q' : Proc} : Cong p p' → Step p' q' → Cong q' q →
Step p q
CSLibExt/Languages/PiCalculus/Basic.lean:172
def HasUnguardedOutput : Proc → Prop
| .nil => False
| .out _ _ _ => True
| .inp _ _ => False
| .par p q => HasUnguardedOutput p ∨ HasUnguardedOutput q
| .nu p => HasUnguardedOutput p
| .repl p => HasUnguardedOutput p
| .sum p q => HasUnguardedOutput p ∨ HasUnguardedOutput q
CSLibExt/Languages/PiCalculus/Behavioural.lean:132
Uses 8 · Used by 2
TheoremProcesses without unguarded output cannot reduce#✓fully proved
Outputless processes cannot reduce. Input guards may still have
observable input barbs; this theorem does not identify them with nil.
theorem not_step_of_no_output {p : Proc}
(h : ¬ HasUnguardedOutput p) (q : Proc) : ¬ Step p q
inductive Proc where
| nil : Proc
| out (a b : Name) (p : Proc) : Proc
| inp (a : Name) (p : Proc) : Proc
| par (p q : Proc) : Proc
| nu (p : Proc) : Proc
| repl (p : Proc) : Proc
| sum (p q : Proc) : Proc
deriving DecidableEq, Repr
CSLibExt/Languages/PiCalculus/Basic.lean:52
def HasUnguardedOutput : Proc → Prop
| .nil => False
| .out _ _ _ => True
| .inp _ _ => False
| .par p q => HasUnguardedOutput p ∨ HasUnguardedOutput q
| .nu p => HasUnguardedOutput p
| .repl p => HasUnguardedOutput p
| .sum p q => HasUnguardedOutput p ∨ HasUnguardedOutput q
CSLibExt/Languages/PiCalculus/Behavioural.lean:132
inductive Step : Proc → Proc → Prop
| commSelect {a : Name} {b : Name} {p' q' p q : Proc} :
Select p (.out a b p') → Select q (.inp a q') →
Step (.par p q) (.par p' (subst q' b))
| parL {p p' q : Proc} : Step p p' → Step (.par p q) (.par p' q)
| parR {p p' q : Proc} : Step p p' → Step (.par q p) (.par q p')
| nu {p p' : Proc} : Step p p' → Step (.nu p) (.nu p')
| cong {p p' q q' : Proc} : Cong p p' → Step p' q' → Cong q' q →
Step p q
CSLibExt/Languages/PiCalculus/Basic.lean:172
Uses 4
TheoremExposed guards are barbs#✓fully proved
A directly exposed guard is a barb, with the reflexive structural representative as witness.
theorem Barb.of_offer {p : Proc} {o : Observable} (h : Offer p o) :
Barb p o
inductive Proc where
| nil : Proc
| out (a b : Name) (p : Proc) : Proc
| inp (a : Name) (p : Proc) : Proc
| par (p q : Proc) : Proc
| nu (p : Proc) : Proc
| repl (p : Proc) : Proc
| sum (p q : Proc) : Proc
deriving DecidableEq, Repr
CSLibExt/Languages/PiCalculus/Basic.lean:52
inductive Observable where
| input (channel : ℕ)
| output (channel : ℕ)
deriving DecidableEq, Repr
CSLibExt/Languages/PiCalculus/Behavioural.lean:37
inductive Offer : Proc → Observable → Prop where
| input {p q : Proc} {a : ℕ} :
Select p (.inp (.const a) q) → Offer p (.input a)
| output {p q : Proc} {a : ℕ} {b : Name} :
Select p (.out (.const a) b q) → Offer p (.output a)
| parL {p q : Proc} {o : Observable} :
Offer p o → Offer (.par p q) o
| parR {p q : Proc} {o : Observable} :
Offer q o → Offer (.par p q) o
| nu {p : Proc} {o : Observable} : Offer p o → Offer (.nu p) o
CSLibExt/Languages/PiCalculus/Behavioural.lean:44
def Barb (p : Proc) (o : Observable) : Prop :=
∃ q, Cong p q ∧ Offer q o
CSLibExt/Languages/PiCalculus/Behavioural.lean:57
Uses 5 · Used by 4
TheoremThe inactive process has no barbs#✓fully proved
The inactive process has no barb, even after structural rearrangement.
@[simp] theorem barb_nil (o : Observable) : ¬ Barb .nil o
inductive Observable where
| input (channel : ℕ)
| output (channel : ℕ)
deriving DecidableEq, Repr
CSLibExt/Languages/PiCalculus/Behavioural.lean:37
def Barb (p : Proc) (o : Observable) : Prop :=
∃ q, Cong p q ∧ Offer q o
CSLibExt/Languages/PiCalculus/Behavioural.lean:57
Uses 11 · Used by 1
TheoremBarbs of an output prefix#✓fully proved
Output readiness sees only its free subject and direction, not its object or guarded continuation.
@[simp] theorem barb_out_iff (a b : Name) (p : Proc) (o : Observable) :
Barb (.out a b p) o ↔ ∃ n, a = .const n ∧ o = .output n
inductive Name where
| const (n : ℕ) : Name
| var (i : ℕ) : Name
deriving DecidableEq, Repr
CSLibExt/Languages/PiCalculus/Basic.lean:45
inductive Proc where
| nil : Proc
| out (a b : Name) (p : Proc) : Proc
| inp (a : Name) (p : Proc) : Proc
| par (p q : Proc) : Proc
| nu (p : Proc) : Proc
| repl (p : Proc) : Proc
| sum (p q : Proc) : Proc
deriving DecidableEq, Repr
CSLibExt/Languages/PiCalculus/Basic.lean:52
inductive Observable where
| input (channel : ℕ)
| output (channel : ℕ)
deriving DecidableEq, Repr
CSLibExt/Languages/PiCalculus/Behavioural.lean:37
def Barb (p : Proc) (o : Observable) : Prop :=
∃ q, Cong p q ∧ Offer q o
CSLibExt/Languages/PiCalculus/Behavioural.lean:57
Uses 12
TheoremBarbs of an input prefix#✓fully proved
Waiting inputs are observable, despite being unable to reduce alone.
@[simp] theorem barb_inp_iff (a : Name) (p : Proc) (o : Observable) :
Barb (.inp a p) o ↔ ∃ n, a = .const n ∧ o = .input n
inductive Name where
| const (n : ℕ) : Name
| var (i : ℕ) : Name
deriving DecidableEq, Repr
CSLibExt/Languages/PiCalculus/Basic.lean:45
inductive Proc where
| nil : Proc
| out (a b : Name) (p : Proc) : Proc
| inp (a : Name) (p : Proc) : Proc
| par (p q : Proc) : Proc
| nu (p : Proc) : Proc
| repl (p : Proc) : Proc
| sum (p q : Proc) : Proc
deriving DecidableEq, Repr
CSLibExt/Languages/PiCalculus/Basic.lean:52
inductive Observable where
| input (channel : ℕ)
| output (channel : ℕ)
deriving DecidableEq, Repr
CSLibExt/Languages/PiCalculus/Behavioural.lean:37
def Barb (p : Proc) (o : Observable) : Prop :=
∃ q, Cong p q ∧ Offer q o
CSLibExt/Languages/PiCalculus/Behavioural.lean:57
Uses 12
TheoremBarbs of a restricted output prefix#✓fully proved
A restricted output is visible exactly when its subject is free. Sending the private name on a free subject remains observable.
@[simp] theorem barb_nu_out_iff (a b : Name) (p : Proc) (o : Observable) :
Barb (.nu (.out a b p)) o ↔ ∃ n, a = .const n ∧ o = .output n
inductive Name where
| const (n : ℕ) : Name
| var (i : ℕ) : Name
deriving DecidableEq, Repr
CSLibExt/Languages/PiCalculus/Basic.lean:45
inductive Proc where
| nil : Proc
| out (a b : Name) (p : Proc) : Proc
| inp (a : Name) (p : Proc) : Proc
| par (p q : Proc) : Proc
| nu (p : Proc) : Proc
| repl (p : Proc) : Proc
| sum (p q : Proc) : Proc
deriving DecidableEq, Repr
CSLibExt/Languages/PiCalculus/Basic.lean:52
inductive Observable where
| input (channel : ℕ)
| output (channel : ℕ)
deriving DecidableEq, Repr
CSLibExt/Languages/PiCalculus/Behavioural.lean:37
def Barb (p : Proc) (o : Observable) : Prop :=
∃ q, Cong p q ∧ Offer q o
CSLibExt/Languages/PiCalculus/Behavioural.lean:57
Uses 12
TheoremBarbed bisimilar processes have the same barbs#✓fully proved
Bisimilar processes have the same immediate free-channel barbs.
theorem BarbedBisimilar.barb_iff {p q : Proc}
(h : BarbedBisimilar p q) (o : Observable) : Barb p o ↔ Barb q o
inductive Proc where
| nil : Proc
| out (a b : Name) (p : Proc) : Proc
| inp (a : Name) (p : Proc) : Proc
| par (p q : Proc) : Proc
| nu (p : Proc) : Proc
| repl (p : Proc) : Proc
| sum (p q : Proc) : Proc
deriving DecidableEq, Repr
CSLibExt/Languages/PiCalculus/Basic.lean:52
def BarbedBisimilar : Proc → Proc → Prop :=
LTS.HomBisimilarity observedLTS
CSLibExt/Languages/PiCalculus/Behavioural.lean:75
inductive Observable where
| input (channel : ℕ)
| output (channel : ℕ)
deriving DecidableEq, Repr
CSLibExt/Languages/PiCalculus/Behavioural.lean:37
def Barb (p : Proc) (o : Observable) : Prop :=
∃ q, Cong p q ∧ Offer q o
CSLibExt/Languages/PiCalculus/Behavioural.lean:57
Uses 8 · Used by 2
TheoremBarbed bisimilarity matches each reduction by one reduction#✓fully proved
A reduction from the first process is matched by one reduction, with strong barbed bisimilar derivatives.
theorem BarbedBisimilar.step {p q p' : Proc}
(h : BarbedBisimilar p q) (hs : Step p p') :
∃ q', Step q q' ∧ BarbedBisimilar p' q'
inductive Proc where
| nil : Proc
| out (a b : Name) (p : Proc) : Proc
| inp (a : Name) (p : Proc) : Proc
| par (p q : Proc) : Proc
| nu (p : Proc) : Proc
| repl (p : Proc) : Proc
| sum (p q : Proc) : Proc
deriving DecidableEq, Repr
CSLibExt/Languages/PiCalculus/Basic.lean:52
def BarbedBisimilar : Proc → Proc → Prop :=
LTS.HomBisimilarity observedLTS
CSLibExt/Languages/PiCalculus/Behavioural.lean:75
inductive Step : Proc → Proc → Prop
| commSelect {a : Name} {b : Name} {p' q' p q : Proc} :
Select p (.out a b p') → Select q (.inp a q') →
Step (.par p q) (.par p' (subst q' b))
| parL {p p' q : Proc} : Step p p' → Step (.par p q) (.par p' q)
| parR {p p' q : Proc} : Step p p' → Step (.par q p) (.par q p')
| nu {p p' : Proc} : Step p p' → Step (.nu p) (.nu p')
| cong {p p' q q' : Proc} : Cong p p' → Step p' q' → Cong q' q →
Step p q
CSLibExt/Languages/PiCalculus/Basic.lean:172
Uses 8 · Used by 1
TheoremFree-channel input is not barbed bisimilar to nil#✓fully proved
Waiting for input is not equivalent to doing nothing. Reduction-only bisimilarity would miss this distinction.
theorem input_not_barbedBisimilar_nil (a : ℕ) (p : Proc) :
¬ BarbedBisimilar (.inp (.const a) p) .nil
inductive Proc where
| nil : Proc
| out (a b : Name) (p : Proc) : Proc
| inp (a : Name) (p : Proc) : Proc
| par (p q : Proc) : Proc
| nu (p : Proc) : Proc
| repl (p : Proc) : Proc
| sum (p q : Proc) : Proc
deriving DecidableEq, Repr
CSLibExt/Languages/PiCalculus/Basic.lean:52
def BarbedBisimilar : Proc → Proc → Prop :=
LTS.HomBisimilarity observedLTS
CSLibExt/Languages/PiCalculus/Behavioural.lean:75
Uses 10
DefinitionMay-barb after finitely many reductions#✓fully proved
A free-channel barb reachable by finitely many existing reductions, possibly zero. This is a may observation, not a weak equivalence.
def MayBarb (p : Proc) (o : Observable) : Prop :=
∃ p', Relation.ReflTransGen Step p p' ∧ Barb p' o
inductive Proc where
| nil : Proc
| out (a b : Name) (p : Proc) : Proc
| inp (a : Name) (p : Proc) : Proc
| par (p q : Proc) : Proc
| nu (p : Proc) : Proc
| repl (p : Proc) : Proc
| sum (p q : Proc) : Proc
deriving DecidableEq, Repr
CSLibExt/Languages/PiCalculus/Basic.lean:52
inductive Observable where
| input (channel : ℕ)
| output (channel : ℕ)
deriving DecidableEq, Repr
CSLibExt/Languages/PiCalculus/Behavioural.lean:37
inductive Step : Proc → Proc → Prop
| commSelect {a : Name} {b : Name} {p' q' p q : Proc} :
Select p (.out a b p') → Select q (.inp a q') →
Step (.par p q) (.par p' (subst q' b))
| parL {p p' q : Proc} : Step p p' → Step (.par p q) (.par p' q)
| parR {p p' q : Proc} : Step p p' → Step (.par q p) (.par q p')
| nu {p p' : Proc} : Step p p' → Step (.nu p) (.nu p')
| cong {p p' q q' : Proc} : Cong p p' → Step p' q' → Cong q' q →
Step p q
CSLibExt/Languages/PiCalculus/Basic.lean:172
def Barb (p : Proc) (o : Observable) : Prop :=
∃ q, Cong p q ∧ Offer q o
CSLibExt/Languages/PiCalculus/Behavioural.lean:57
Uses 4 · Used by 1
TheoremBarbed bisimilarity transfers finite reduction paths#✓fully proved
A finite reduction path transfers across strong barbed bisimilarity.
theorem BarbedBisimilar.reductionPath {p q p' : Proc}
(h : BarbedBisimilar p q) (hs : Relation.ReflTransGen Step p p') :
∃ q', Relation.ReflTransGen Step q q' ∧ BarbedBisimilar p' q'
inductive Proc where
| nil : Proc
| out (a b : Name) (p : Proc) : Proc
| inp (a : Name) (p : Proc) : Proc
| par (p q : Proc) : Proc
| nu (p : Proc) : Proc
| repl (p : Proc) : Proc
| sum (p q : Proc) : Proc
deriving DecidableEq, Repr
CSLibExt/Languages/PiCalculus/Basic.lean:52
def BarbedBisimilar : Proc → Proc → Prop :=
LTS.HomBisimilarity observedLTS
CSLibExt/Languages/PiCalculus/Behavioural.lean:75
inductive Step : Proc → Proc → Prop
| commSelect {a : Name} {b : Name} {p' q' p q : Proc} :
Select p (.out a b p') → Select q (.inp a q') →
Step (.par p q) (.par p' (subst q' b))
| parL {p p' q : Proc} : Step p p' → Step (.par p q) (.par p' q)
| parR {p p' q : Proc} : Step p p' → Step (.par q p) (.par q p')
| nu {p p' : Proc} : Step p p' → Step (.nu p) (.nu p')
| cong {p p' q q' : Proc} : Cong p p' → Step p' q' → Cong q' q →
Step p q
CSLibExt/Languages/PiCalculus/Basic.lean:172
Uses 4 · Used by 1
TheoremBarbed bisimilarity preserves may-barbs#✓fully proved
Strong barbed bisimilarity preserves finite may observations.
theorem BarbedBisimilar.mayBarb_iff {p q : Proc}
(h : BarbedBisimilar p q) (o : Observable) :
MayBarb p o ↔ MayBarb q o
inductive Proc where
| nil : Proc
| out (a b : Name) (p : Proc) : Proc
| inp (a : Name) (p : Proc) : Proc
| par (p q : Proc) : Proc
| nu (p : Proc) : Proc
| repl (p : Proc) : Proc
| sum (p q : Proc) : Proc
deriving DecidableEq, Repr
CSLibExt/Languages/PiCalculus/Basic.lean:52
def BarbedBisimilar : Proc → Proc → Prop :=
LTS.HomBisimilarity observedLTS
CSLibExt/Languages/PiCalculus/Behavioural.lean:75
inductive Observable where
| input (channel : ℕ)
| output (channel : ℕ)
deriving DecidableEq, Repr
CSLibExt/Languages/PiCalculus/Behavioural.lean:37
def MayBarb (p : Proc) (o : Observable) : Prop :=
∃ p', Relation.ReflTransGen Step p p' ∧ Barb p' o
CSLibExt/Languages/PiCalculus/Behavioural.lean:303
Loading dependency explorer…
The dependency explorer needs JavaScript and its graph data.