(* The NSL protocol describes the interaction between two participants,
Alice (`A`) and Bob (`B`),
who want to exchange their respective secret random data `nA` and `nB`
without them beeing revealed to an active attacker.

Each participant has its own secret encryption key and the two
associated public keys `pkA` and `pkB` are distributed prior to
the exchange, which is as follows:

A -> B: {nA,pkA}_pkB
B -> A: {nA,nB,pkB}_pkA
A -> B: {nB,nA}_pkB

In this file we prove that a simple scenario of this protocol
is indistinguishabile from a variant where encrypted messages
are replaced by their length (in unary), relying on the
IND-CCA2 crypto assumption. We explain how this is useful to
prove the strong secrecy of the exchanged nonces `nA` and `nB`.

We consider a single session of each participant. The initiator
`A` uses a public key that is chosen by the attacker, allowing
man in the middle attacks.
We assume a tagging mechanism to distinguish the first and last
messages from `A`. *)

include Basic.
Typed-check process:

null

Added action dependencies lemmas:


System after processing:

null

System Empty registered with actions (init).
[warning>Loaded "Prelude.sp".
<]axiom [any] eq_iff : forall (x,y:bool), (x = y) = (x <=> y)
axiom [any] eq_not : forall (x,y:bool), (not x = not y) = (x = y)
Goal eq_sym :
(x = y) = (y = x)
[goal> Focused goal (1/1):
System: any
Type variables: 'a
Variables: x,y:'a
----------------------------------------
(x = y) = (y = x)

[> Line 17: by (rewrite ...) [goal> lemma eq_sym is proved

lemma [any] eq_sym ['a] : forall (x,y:'a), (x = y) = (y = x)
Exiting proof mode.

Goal neq_sym :
(x <> y) = (y <> x)
[goal> Focused goal (1/1):
System: any
Type variables: 'a
Variables: x,y:'a
----------------------------------------
(x <> y) = (y <> x)

[> Line 23: by (rewrite ...) [goal> lemma neq_sym is proved

lemma [any] neq_sym ['a] : forall (x,y:'a), (x <> y) = (y <> x)
Exiting proof mode.

Goal eq_refl_e :
(x = x) = true
[goal> Focused goal (1/1):
System: any
Type variables: 'a
Variables: x:'a
----------------------------------------
(x = x) = true

[> Line 31: by (rewrite ...) [goal> lemma eq_refl_e is proved

lemma [any] eq_refl_e ['a] : forall (x:'a), (x = x) = true
Exiting proof mode.

Goal eq_refl :
x = x
[goal> Focused goal (1/1):
System: any
Type variables: 'a
Variables: x:'a
----------------------------------------
x = x

[> Line 43: by (rewrite ...) [goal> lemma eq_refl is proved

lemma [any] eq_refl ['a] : forall (x:'a), x = x
Exiting proof mode.

Goal neq_irrefl :
x <> x <=> false
[goal> Focused goal (1/1):
System: any
Type variables: 'a
Variables: x:'a
----------------------------------------
x <> x <=> false

[> Line 51: by split [goal> lemma neq_irrefl is proved

lemma [any] neq_irrefl ['a] : forall (x:'a), x <> x <=> false
Exiting proof mode.

Goal eq_assoc :
((b0 = b1) = b2) = (b0 = (b1 = b2))
[goal> Focused goal (1/1):
System: any
Variables: b0,b1,b2:bool
----------------------------------------
((b0 = b1) = b2) = (b0 = (b1 = b2))

[> Line 65: ((have ...); 1: by (rewrite ...)) [goal> Focused goal (1/1):
System: any
Variables: b0,b1,b2:bool[const]
true_false: (true = false) = false
----------------------------------------
((b0 = b1) = b2) = (b0 = (b1 = b2))

[> Line 67: ((have ...); 1: by (rewrite ...)) [goal> Focused goal (1/1):
System: any
Variables: b0,b1,b2:bool[const]
false_true: (false = true) = false
true_false: (true = false) = false
----------------------------------------
((b0 = b1) = b2) = (b0 = (b1 = b2))

[> Line 69: ((case ..., b0);
((case ..., b1);((case ..., b2);(try (auto ...)))))
[goal> Focused goal (1/2):
System: any
Variables: b0,b1,b2:bool[const]
false_true: (false = true) = false
true_false: (true = false) = false
----------------------------------------
not b2 => not b1 => b0 => ((true = false) = false) = (true = (false = false))

[> Line 69: by (rewrite ...) [goal> Focused goal (1/1):
System: any
Variables: b0,b1,b2:bool[const]
false_true: (false = true) = false
true_false: (true = false) = false
----------------------------------------
b2 => not b1 => not b0 => ((false = false) = true) = (false = (false = true))

[> Line 69: by (rewrite ...) [goal> lemma eq_assoc is proved

lemma [any] eq_assoc :
forall (b0,b1,b2:bool), ((b0 = b1) = b2) = (b0 = (b1 = b2))
Exiting proof mode.

Goal true_false :
(true = false) = false
[goal> Focused goal (1/1):
System: any
----------------------------------------
(true = false) = false

[> Line 87: by (rewrite ...) [goal> lemma true_false is proved

lemma [any] true_false : (true = false) = false
Exiting proof mode.

Goal false_true :
(false = true) = false
[goal> Focused goal (1/1):
System: any
----------------------------------------
(false = true) = false

[> Line 97: by (rewrite ...) [goal> lemma false_true is proved

lemma [any] false_true : (false = true) = false
Exiting proof mode.

Goal eq_true :
(b = true) = b
[goal> Focused goal (1/1):
System: any
Variables: b:bool
----------------------------------------
(b = true) = b

[> Line 107: by (case ..., b) [goal> lemma eq_true is proved

lemma [any] eq_true : forall (b:bool), (b = true) = b
Exiting proof mode.

Goal eq_true2 :
(true = b) = b
[goal> Focused goal (1/1):
System: any
Variables: b:bool
----------------------------------------
(true = b) = b

[> Line 115: by (case ..., b) [goal> lemma eq_true2 is proved

lemma [any] eq_true2 : forall (b:bool), (true = b) = b
Exiting proof mode.

axiom [any] not_true : not true = false
axiom [any] not_false : not false = true
Goal not_not :
not (not b) = b
[goal> Focused goal (1/1):
System: any
Variables: b:bool
----------------------------------------
not (not b) = b

[> Line 145: by (case ..., b) [goal> lemma not_not is proved

lemma [any] not_not : forall (b:bool), not (not b) = b
Exiting proof mode.

Goal not_eq :
not (x = y) = (x <> y)
[goal> Focused goal (1/1):
System: any
Type variables: 'a
Variables: x,y:'a
----------------------------------------
not (x = y) = (x <> y)

[> Line 157: by (rewrite ...) [goal> lemma not_eq is proved

lemma [any] not_eq ['a] : forall (x,y:'a), not (x = y) = (x <> y)
Exiting proof mode.

Goal not_neq :
not (x <> y) = (x = y)
[goal> Focused goal (1/1):
System: any
Type variables: 'a
Variables: x,y:'a
----------------------------------------
not (x <> y) = (x = y)

[> Line 169: by (rewrite ...) [goal> lemma not_neq is proved

lemma [any] not_neq ['a] : forall (x,y:'a), not (x <> y) = (x = y)
Exiting proof mode.

Goal not_eqfalse :
(b = false) = not b
[goal> Focused goal (1/1):
System: any
Variables: b:bool
----------------------------------------
(b = false) = not b

[> Line 181: by (case ..., b) [goal> lemma not_eqfalse is proved

lemma [any] not_eqfalse : forall (b:bool), (b = false) = not b
Exiting proof mode.

Goal not_impl :
not (a => b) = (a && not b)
[goal> Focused goal (1/1):
System: any
Variables: a,b:bool
----------------------------------------
not (a => b) = (a && not b)

[> Line 191: ((rewrite ...);(split;(intro H))) [goal> Focused goal (1/2):
System: any
Variables: a,b:bool[const]
H: not (a => b)
----------------------------------------
a && not b

[> Line 193: split [goal> Focused goal (1/3):
System: any
Variables: a,b:bool[const]
H: not (a => b)
----------------------------------------
a

[> Line 195: (rewrite ...) [goal> Focused goal (1/3):
System: any
Variables: a,b:bool[const]
H: not (a => b)
----------------------------------------
not (not a)

[> Line 197: (intro Hna) [goal> Focused goal (1/3):
System: any
Variables: a,b:bool[const]
H: not (a => b)
Hna: not a
----------------------------------------
false

[> Line 199: by (apply ... ) [goal> Focused goal (1/2):
System: any
Variables: a,b:bool[const]
H: not (a => b)
----------------------------------------
not b

[> Line 201: (intro Hb) [goal> Focused goal (1/2):
System: any
Variables: a,b:bool[const]
H: not (a => b)
Hb: b
----------------------------------------
false

[> Line 203: by (apply ... ) [goal> Focused goal (1/1):
System: any
Variables: a,b:bool[const]
H: a && not b
----------------------------------------
not (a => b)

[> Line 205: (intro Hi) [goal> Focused goal (1/1):
System: any
Variables: a,b:bool[const]
H: a && not b
Hi: a => b
----------------------------------------
false

[> Line 207: (destruct H, [Ha Hnb]) [goal> Focused goal (1/1):
System: any
Variables: a,b:bool[const]
Ha: a
Hi: a => b
Hnb: not b
----------------------------------------
false

[> Line 209: (apply ... ) [goal> Focused goal (1/1):
System: any
Variables: a,b:bool[const]
Ha: a
Hi: a => b
Hnb: not b
----------------------------------------
b

[> Line 211: by (apply ... ) [goal> lemma not_impl is proved

lemma [any] not_impl : forall (a,b:bool), not (a => b) = (a && not b)
Exiting proof mode.

Goal eq_false :
((x = y) = false) = (x <> y)
[goal> Focused goal (1/1):
System: any
Type variables: 'a
Variables: x,y:'a
----------------------------------------
((x = y) = false) = (x <> y)

[> Line 227: (rewrite ...) [goal> Focused goal (1/1):
System: any
Type variables: 'a
Variables: x,y:'a
----------------------------------------
((x = y) = false) = not (x = y)

[> Line 227: ((case ..., (= x y));(intro _)) [goal> Focused goal (1/2):
System: any
Type variables: 'a
Variables: x,y:'a
_: x = y
----------------------------------------
(true = false) = not true

[> Line 227: (simpl ...) [goal> Focused goal (1/2):
System: any
Type variables: 'a
Variables: x,y:'a
_: x = y
----------------------------------------
true

[> Line 227: (auto ...) [goal> Focused goal (1/1):
System: any
Type variables: 'a
Variables: x,y:'a
_: not (x = y)
----------------------------------------
(false = false) = not false

[> Line 229: by (rewrite ...) [goal> lemma eq_false is proved

lemma [any] eq_false ['a] : forall (x,y:'a), ((x = y) = false) = (x <> y)
Exiting proof mode.

axiom [any] and_comm : forall (b,b':bool), (b && b') = (b' && b)
Goal and_dist :
((b0 || b1) && b2) = (b0 && b2 || b1 && b2)
[goal> Focused goal (1/1):
System: any
Variables: b0,b1,b2:bool
----------------------------------------
((b0 || b1) && b2) = (b0 && b2 || b1 && b2)

[> Line 249: (rewrite ...) [goal> Focused goal (1/1):
System: any
Variables: b0,b1,b2:bool[const]
----------------------------------------
(b0 || b1) && b2 <=> b0 && b2 || b1 && b2

[> Line 249: by split [goal> lemma and_dist is proved

lemma [any] and_dist :
forall (b0,b1,b2:bool), ((b0 || b1) && b2) = (b0 && b2 || b1 && b2)
Exiting proof mode.

axiom [any] and_true_l : forall (b:bool), (true && b) = b
Goal and_true_r :
(b && true) = b
[goal> Focused goal (1/1):
System: any
Variables: b:bool
----------------------------------------
(b && true) = b

[> Line 261: by (rewrite ... ...) [goal> lemma and_true_r is proved

lemma [any] and_true_r : forall (b:bool), (b && true) = b
Exiting proof mode.

axiom [any] and_false_l : forall (b:bool), (false && b) = false
Goal and_false_r :
(b && false) = false
[goal> Focused goal (1/1):
System: any
Variables: b:bool
----------------------------------------
(b && false) = false

[> Line 275: by (rewrite ... ...) [goal> lemma and_false_r is proved

lemma [any] and_false_r : forall (b:bool), (b && false) = false
Exiting proof mode.

Goal and_double :
(b && b) = b
[goal> Focused goal (1/1):
System: any
Variables: b:bool
----------------------------------------
(b && b) = b

[> Line 285: by (case ..., b) [goal> lemma and_double is proved

lemma [any] and_double : forall (b:bool), (b && b) = b
Exiting proof mode.

axiom [any] or_comm : forall (b,b':bool), (b || b') = (b' || b)
Goal or_dist :
((b0 || b2) && (b1 || b2)) = (b0 && b1 || b2)
[goal> Focused goal (1/1):
System: any
Variables: b0,b1,b2:bool
----------------------------------------
((b0 || b2) && (b1 || b2)) = (b0 && b1 || b2)

[> Line 301: (rewrite ...) [goal> Focused goal (1/1):
System: any
Variables: b0,b1,b2:bool[const]
----------------------------------------
(b0 || b2) && (b1 || b2) <=> b0 && b1 || b2

[> Line 301: by split [goal> lemma or_dist is proved

lemma [any] or_dist :
forall (b0,b1,b2:bool), ((b0 || b2) && (b1 || b2)) = (b0 && b1 || b2)
Exiting proof mode.

axiom [any] or_false_l : forall (b:bool), (false || b) = b
Goal or_false_r :
(b || false) = b
[goal> Focused goal (1/1):
System: any
Variables: b:bool
----------------------------------------
(b || false) = b

[> Line 313: by (rewrite ... ...) [goal> lemma or_false_r is proved

lemma [any] or_false_r : forall (b:bool), (b || false) = b
Exiting proof mode.

axiom [any] or_true_l : forall (b:bool), (true || b) = true
Goal or_true_r :
(b || true) = true
[goal> Focused goal (1/1):
System: any
Variables: b:bool
----------------------------------------
(b || true) = true

[> Line 327: by (rewrite ... ...) [goal> lemma or_true_r is proved

lemma [any] or_true_r : forall (b:bool), (b || true) = true
Exiting proof mode.

Goal or_double :
(b || b) = b
[goal> Focused goal (1/1):
System: any
Variables: b:bool
----------------------------------------
(b || b) = b

[> Line 335: by (case ..., b) [goal> lemma or_double is proved

lemma [any] or_double : forall (b:bool), (b || b) = b
Exiting proof mode.

Goal impl_charac :
(b => b') = (not b || b')
[goal> Focused goal (1/1):
System: any
Variables: b,b':bool
----------------------------------------
(b => b') = (not b || b')

[> Line 349: (((rewrite ...);(split;((case ..., b);(case ..., b'))));
(intro //=))
[goal> lemma impl_charac is proved

lemma [any] impl_charac : forall (b,b':bool), (b => b') = (not b || b')
Exiting proof mode.

Goal impl_false_l :
(false => b) = true
[goal> Focused goal (1/1):
System: any
Variables: b:bool
----------------------------------------
(false => b) = true

[> Line 357: by ((rewrite ...);(case ..., b)) [goal> lemma impl_false_l is proved

lemma [any] impl_false_l : forall (b:bool), (false => b) = true
Exiting proof mode.

Goal impl_true_r :
(b => true) = true
[goal> Focused goal (1/1):
System: any
Variables: b:bool
----------------------------------------
(b => true) = true

[> Line 365: (auto ...) [goal> lemma impl_true_r is proved

lemma [any] impl_true_r : forall (b:bool), (b => true) = true
Exiting proof mode.

Goal impl_true_l :
(true => b) = b
[goal> Focused goal (1/1):
System: any
Variables: b:bool
----------------------------------------
(true => b) = b

[> Line 373: by (rewrite ...) [goal> lemma impl_true_l is proved

lemma [any] impl_true_l : forall (b:bool), (true => b) = b
Exiting proof mode.

Goal impl_contra :
(b => c) = (not c => not b)
[goal> Focused goal (1/1):
System: any
Variables: b,c:bool
----------------------------------------
(b => c) = (not c => not b)

[> Line 383: (rewrite ... /=) [goal> Focused goal (1/1):
System: any
Variables: b,c:bool[const]
----------------------------------------
(not b || c) = (c || not b)

[> Line 385: by (rewrite ...) [goal> lemma impl_contra is proved

lemma [any] impl_contra : forall (b,c:bool), (b => c) = (not c => not b)
Exiting proof mode.

Goal not_and :
not (a && b) = (not a || not b)
[goal> Focused goal (1/1):
System: any
Variables: a,b:bool
----------------------------------------
not (a && b) = (not a || not b)

[> Line 401: (rewrite ...) [goal> Focused goal (1/1):
System: any
Variables: a,b:bool[const]
----------------------------------------
not (a && b) <=> not a || not b

[> Line 403: (((case ..., a);(case ..., b));(intro //=)) [goal> lemma not_and is proved

lemma [any] not_and : forall (a,b:bool), not (a && b) = (not a || not b)
Exiting proof mode.

Goal not_or :
not (a || b) = (not a && not b)
[goal> Focused goal (1/1):
System: any
Variables: a,b:bool
----------------------------------------
not (a || b) = (not a && not b)

[> Line 413: (rewrite ...) [goal> Focused goal (1/1):
System: any
Variables: a,b:bool[const]
----------------------------------------
not (a || b) <=> not a && not b

[> Line 415: (((case ..., a);(case ..., b));(intro //=)) [goal> lemma not_or is proved

lemma [any] not_or : forall (a,b:bool), not (a || b) = (not a && not b)
Exiting proof mode.

Goal if_true :
b => if b then x else y = x
[goal> Focused goal (1/1):
System: any
Type variables: 'a
Variables: b:bool,x,y:'a
----------------------------------------
b => if b then x else y = x

[> Line 433: (intro *) [goal> Focused goal (1/1):
System: any
Type variables: 'a
Variables: b:bool[const],x,y:'a
H: b
----------------------------------------
if b then x else y = x

[> Line 435: (case ..., (if b x y)) [goal> Focused goal (1/2):
System: any
Type variables: 'a
Variables: b:bool[const],x,y:'a
H: b
----------------------------------------
b && if b then x else y = x => x = x

[> Line 437: (auto ...) [goal> Focused goal (1/1):
System: any
Type variables: 'a
Variables: b:bool[const],x,y:'a
H: b
----------------------------------------
not b && if b then x else y = y => y = x

[> Line 439: (intro [HH _]) [goal> Focused goal (1/1):
System: any
Type variables: 'a
Variables: b:bool[const],x,y:'a
H: b
HH: not b
_: if b then x else y = y
----------------------------------------
y = x

[> Line 439: by (have ...) [goal> lemma if_true is proved

lemma [any] if_true ['a] :
forall (b:bool,x,y:'a), b => if b then x else y = x
Exiting proof mode.

Goal if_true0 :
if true then x else y = x
[goal> Focused goal (1/1):
System: any
Type variables: 'a
Variables: x,y:'a
----------------------------------------
if true then x else y = x

[> Line 451: by (rewrite ...) [goal> lemma if_true0 is proved

lemma [any] if_true0 ['a] : forall (x,y:'a), if true then x else y = x
Exiting proof mode.

Goal if_false :
not b => if b then x else y = y
[goal> Focused goal (1/1):
System: any
Type variables: 'a
Variables: b:bool,x,y:'a
----------------------------------------
not b => if b then x else y = y

[> Line 465: ((intro *);(case ..., (if b x y))) [goal> Focused goal (1/2):
System: any
Type variables: 'a
Variables: b:bool[const],x,y:'a
H: not b
----------------------------------------
b && if b then x else y = x => x = y

[> Line 467: (intro [H1 H2]) [goal> Focused goal (1/2):
System: any
Type variables: 'a
Variables: b:bool[const],x,y:'a
H: not b
H1: b
H2: if b then x else y = x
----------------------------------------
x = y

[> Line 469: by (rewrite ... in H2) [goal> Focused goal (1/1):
System: any
Type variables: 'a
Variables: b:bool[const],x,y:'a
H: not b
----------------------------------------
not b && if b then x else y = y => y = y

[> Line 471: (auto ...) [goal> lemma if_false is proved

lemma [any] if_false ['a] :
forall (b:bool,x,y:'a), not b => if b then x else y = y
Exiting proof mode.

Goal if_false0 :
if false then x else y = y
[goal> Focused goal (1/1):
System: any
Type variables: 'a
Variables: x,y:'a
----------------------------------------
if false then x else y = y

[> Line 483: by (rewrite ...) [goal> lemma if_false0 is proved

lemma [any] if_false0 ['a] : forall (x,y:'a), if false then x else y = y
Exiting proof mode.

Goal if_then_then :
if b then (if b' then x else y) else y = if (b && b') then x else y
[goal> Focused goal (1/1):
System: any
Type variables: 'a
Variables: b,b':bool,x,y:'a
----------------------------------------
if b then (if b' then x else y) else y = if (b && b') then x else y

[> Line 497: by ((case ..., b);(case ..., b')) [goal> lemma if_then_then is proved

lemma [any] if_then_then ['a] :
forall (b,b':bool,x,y:'a),
if b then (if b' then x else y) else y = if (b && b') then x else y
Exiting proof mode.

Goal if_then_or :
if b0 then m0 else if b1 then m0 else m1 = if (b0 || b1) then m0 else m1
[goal> Focused goal (1/1):
System: any
Variables: b0,b1:bool,m0,m1:message
----------------------------------------
if b0 then m0 else if b1 then m0 else m1 = if (b0 || b1) then m0 else m1

[> Line 513: ((have ...); 1: by (auto ...)) [goal> Focused goal (1/2):
System: any
Variables: b0,b1:bool[const],m0,m1:message
_: b0
----------------------------------------
if b0 then m0 else if b1 then m0 else m1 = if (b0 || b1) then m0 else m1

[> Line 513: ((rewrite ...);(intro //)) [goal> Focused goal (1/2):
System: any
Variables: b0,b1:bool[const],m0,m1:message
_: b0
----------------------------------------
m0 = if (b0 || b1) then m0 else m1

[> Line 513: ((rewrite ...);(intro //)) [goal> Focused goal (1/1):
System: any
Variables: b0,b1:bool[const],m0,m1:message
_: not b0
----------------------------------------
if b0 then m0 else if b1 then m0 else m1 = if (b0 || b1) then m0 else m1

[> Line 515: ((have ...); 1: by (auto ...)) [goal> Focused goal (1/2):
System: any
Variables: b0,b1:bool[const],m0,m1:message
_: b1
_: not b0
----------------------------------------
if b0 then m0 else if b1 then m0 else m1 = if (b0 || b1) then m0 else m1

[> Line 515: ((rewrite ...);(intro //)) [goal> Focused goal (1/2):
System: any
Variables: b0,b1:bool[const],m0,m1:message
_: b1
_: not b0
----------------------------------------
if b1 then m0 else m1 = if (b0 || b1) then m0 else m1

[> Line 515: ((rewrite ...);(intro //)) [goal> Focused goal (1/1):
System: any
Variables: b0,b1:bool[const],m0,m1:message
_: not b1
_: not b0
----------------------------------------
if b0 then m0 else if b1 then m0 else m1 = if (b0 || b1) then m0 else m1

[> Line 517: ((rewrite ...);(intro //)) [goal> lemma if_then_or is proved

lemma [any] if_then_or :
forall (b0,b1:bool,m0,m1:message),
if b0 then m0 else if b1 then m0 else m1 = if (b0 || b1) then m0 else m1
Exiting proof mode.

Goal if_then_implies :
if b then (if b' then x else y) else z =
if b then (if (b => b') then x else y) else z
[goal> Focused goal (1/1):
System: any
Type variables: 'a
Variables: b,b':bool,x,y,z:'a
----------------------------------------
if b then (if b' then x else y) else z =
if b then (if (b => b') then x else y) else z

[> Line 531: ((case ..., b);
((intro H);
((case ..., b');((intro H');((simpl ...);(try (auto ...)))))))
[goal> lemma if_then_implies is proved

lemma [any] if_then_implies ['a] :
forall (b,b':bool,x,y,z:'a),
if b then (if b' then x else y) else z =
if b then (if (b => b') then x else y) else z
Exiting proof mode.

Goal if_same :
if b then x else x = x
[goal> Focused goal (1/1):
System: any
Type variables: 'a
Variables: b:bool,x:'a
----------------------------------------
if b then x else x = x

[> Line 543: by (case ..., b) [goal> lemma if_same is proved

lemma [any] if_same ['a] : forall (b:bool,x:'a), if b then x else x = x
Exiting proof mode.

Goal if_then :
b = b' => if b then (if b' then x else y) else z = if b then x else z
[goal> Focused goal (1/1):
System: any
Type variables: 'a
Variables: b,b':bool,x,y,z:'a
----------------------------------------
b = b' => if b then (if b' then x else y) else z = if b then x else z

[> Line 561: by ((intro ->);(case ..., b')) [goal> lemma if_then is proved

lemma [any] if_then ['a] :
forall (b,b':bool,x,y,z:'a),
b = b' => if b then (if b' then x else y) else z = if b then x else z
Exiting proof mode.

Goal if_then_inv :
if b then m0 else m1 = if b then (if b then m0) else m1
[goal> Focused goal (1/1):
System: any
Variables: b:bool,m0,m1:message
----------------------------------------
if b then m0 else m1 = if b then (if b then m0) else m1

[> Line 575: (auto ...) [goal> lemma if_then_inv is proved

lemma [any] if_then_inv :
forall (b:bool,m0,m1:message),
if b then m0 else m1 = if b then (if b then m0) else m1
Exiting proof mode.

Goal if_else :
b = b' => if b then x else if b' then y else z = if b then x else z
[goal> Focused goal (1/1):
System: any
Type variables: 'a
Variables: b,b':bool,x,y,z:'a
----------------------------------------
b = b' => if b then x else if b' then y else z = if b then x else z

[> Line 589: by ((intro ->);(case ..., b')) [goal> lemma if_else is proved

lemma [any] if_else ['a] :
forall (b,b':bool,x,y,z:'a),
b = b' => if b then x else if b' then y else z = if b then x else z
Exiting proof mode.

Goal if_else_inv :
if b then m0 else m1 = if b then m0 else if not b then m1
[goal> Focused goal (1/1):
System: any
Variables: b:bool,m0,m1:message
----------------------------------------
if b then m0 else m1 = if b then m0 else if not b then m1

[> Line 601: by (case ..., b) [goal> lemma if_else_inv is proved

lemma [any] if_else_inv :
forall (b:bool,m0,m1:message),
if b then m0 else m1 = if b then m0 else if not b then m1
Exiting proof mode.

Goal if_push :
if b then m0 else m1 = if b then (if b then m0) else if not b then m1
[goal> Focused goal (1/1):
System: any
Variables: b:bool,m0,m1:message
----------------------------------------
if b then m0 else m1 = if b then (if b then m0) else if not b then m1

[> Line 609: by (rewrite ... ...) [goal> lemma if_push is proved

lemma [any] if_push :
forall (b:bool,m0,m1:message),
if b then m0 else m1 = if b then (if b then m0) else if not b then m1
Exiting proof mode.

Goal if_then_not :
b = not b' => if b then (if b' then x else y) else z = if b then y else z
[goal> Focused goal (1/1):
System: any
Type variables: 'a
Variables: b,b':bool,x,y,z:'a
----------------------------------------
b = not b' => if b then (if b' then x else y) else z = if b then y else z

[> Line 623: by ((intro ->);(case ..., b')) [goal> lemma if_then_not is proved

lemma [any] if_then_not ['a] :
forall (b,b':bool,x,y,z:'a),
b = not b' => if b then (if b' then x else y) else z = if b then y else z
Exiting proof mode.

Goal if_else_not :
b = not b' => if b then x else if b' then y else z = if b then x else y
[goal> Focused goal (1/1):
System: any
Type variables: 'a
Variables: b,b':bool,x,y,z:'a
----------------------------------------
b = not b' => if b then x else if b' then y else z = if b then x else y

[> Line 641: by ((intro ->);(case ..., b')) [goal> lemma if_else_not is proved

lemma [any] if_else_not ['a] :
forall (b,b':bool,x,y,z:'a),
b = not b' => if b then x else if b' then y else z = if b then x else y
Exiting proof mode.

Goal if_app :
f (if c then x else y) = if c then f x else f y
[goal> Focused goal (1/1):
System: any
Type variables: 'a, 'b
Variables: c:bool,f:'a -> 'b,x,y:'a
----------------------------------------
f (if c then x else y) = if c then f x else f y

[> Line 653: by (case ..., c) [goal> lemma if_app is proved

lemma [any] if_app ['a 'b] :
forall (f:'a -> 'b,c:bool,x,y:'a),
f (if c then x else y) = if c then f x else f y
Exiting proof mode.

Goal fst_pair :
fst <x,y> = x
[goal> Focused goal (1/1):
System: any
Variables: x,y:message
----------------------------------------
fst <x,y> = x

[> Line 665: (auto ...) [goal> lemma fst_pair is proved

lemma [any] fst_pair : forall (x,y:message), fst <x,y> = x
Exiting proof mode.

Goal snd_pair :
snd <x,y> = y
[goal> Focused goal (1/1):
System: any
Variables: x,y:message
----------------------------------------
snd <x,y> = y

[> Line 673: (auto ...) [goal> lemma snd_pair is proved

lemma [any] snd_pair : forall (x,y:message), snd <x,y> = y
Exiting proof mode.

Goal iff_def :
(x <=> y) = ((x => y) && (y => x))
[goal> Focused goal (1/1):
System: any
Variables: x,y:bool
----------------------------------------
(x <=> y) = ((x => y) && (y => x))

[> Line 689: ((rewrite ...);split) [goal> Focused goal (1/2):
System: any
Variables: x,y:bool[const]
----------------------------------------
x <=> y => (x => y) && (y => x)

[> Line 691: by (intro ->) [goal> Focused goal (1/1):
System: any
Variables: x,y:bool[const]
----------------------------------------
(x => y) && (y => x) => x <=> y

[> Line 693: (auto ...) [goal> lemma iff_def is proved

lemma [any] iff_def : forall (x,y:bool), (x <=> y) = ((x => y) && (y => x))
Exiting proof mode.

Goal iff_refl :
(x <=> x) = true
[goal> Focused goal (1/1):
System: any
Variables: x:bool
----------------------------------------
(x <=> x) = true

[> Line 703: by (rewrite ...) [goal> lemma iff_refl is proved

lemma [any] iff_refl : forall (x:bool), (x <=> x) = true
Exiting proof mode.

Goal iff_sym :
(x <=> y) = (y <=> x)
[goal> Focused goal (1/1):
System: any
Variables: x,y:bool
----------------------------------------
(x <=> y) = (y <=> x)

[> Line 715: by (rewrite ... ...) [goal> lemma iff_sym is proved

lemma [any] iff_sym : forall (x,y:bool), (x <=> y) = (y <=> x)
Exiting proof mode.

Goal true_iff_false :
(true <=> false) = false
[goal> Focused goal (1/1):
System: any
----------------------------------------
(true <=> false) = false

[> Line 725: by (rewrite ...) [goal> lemma true_iff_false is proved

lemma [any] true_iff_false : (true <=> false) = false
Exiting proof mode.

Goal false_iff_true :
(false <=> true) = false
[goal> Focused goal (1/1):
System: any
----------------------------------------
(false <=> true) = false

[> Line 737: by (rewrite ...) [goal> lemma false_iff_true is proved

lemma [any] false_iff_true : (false <=> true) = false
Exiting proof mode.

Goal contra_iff :
(not x <=> y) = (x <=> not y)
[goal> Focused goal (1/1):
System: any
Variables: x,y:bool
----------------------------------------
(not x <=> y) = (x <=> not y)

[> Line 751: (rewrite ...) [goal> Focused goal (1/1):
System: any
Variables: x,y:bool[const]
----------------------------------------
(not x <=> y) <=> (x <=> not y)

[> Line 753: (split;by (rewrite ... ...)) [goal> lemma contra_iff is proved

lemma [any] contra_iff : forall (x,y:bool), (not x <=> y) = (x <=> not y)
Exiting proof mode.

Goal exists_false1 :
(exists (a:'a), false) = false
[goal> Focused goal (1/1):
System: any
Type variables: 'a
----------------------------------------
(exists (a:'a), false) = false

[> Line 769: by (rewrite ...) [goal> lemma exists_false1 is proved

lemma [any] exists_false1 ['a] : (exists (a:'a), false) = false
Exiting proof mode.

Goal exists_false2 :
(exists (a:'a,b:'b), false) = false
[goal> Focused goal (1/1):
System: any
Type variables: 'a, 'b
----------------------------------------
(exists (a:'a,b:'b), false) = false

[> Line 777: by (rewrite ...) [goal> lemma exists_false2 is proved

lemma [any] exists_false2 ['a 'b] : (exists (a:'a,b:'b), false) = false
Exiting proof mode.

Goal exists_false3 :
(exists (a:'a,b:'b,c:'c), false) = false
[goal> Focused goal (1/1):
System: any
Type variables: 'a, 'b, 'c
----------------------------------------
(exists (a:'a,b:'b,c:'c), false) = false

[> Line 785: by (rewrite ...) [goal> lemma exists_false3 is proved

lemma [any] exists_false3 ['a 'b 'c] :
(exists (a:'a,b:'b,c:'c), false) = false
Exiting proof mode.

Goal exists_false4 :
(exists (a:'a,b:'b,c:'c,d:'d), false) = false
[goal> Focused goal (1/1):
System: any
Type variables: 'a, 'b, 'c, 'd
----------------------------------------
(exists (a:'a,b:'b,c:'c,d:'d), false) = false

[> Line 793: by (rewrite ...) [goal> lemma exists_false4 is proved

lemma [any] exists_false4 ['a 'b 'c 'd] :
(exists (a:'a,b:'b,c:'c,d:'d), false) = false
Exiting proof mode.

Goal exists_false5 :
(exists (a:'a,b:'b,c:'c,d:'d,e:'e), false) = false
[goal> Focused goal (1/1):
System: any
Type variables: 'a, 'b, 'c, 'd, 'e
----------------------------------------
(exists (a:'a,b:'b,c:'c,d:'d,e:'e), false) = false

[> Line 801: by (rewrite ...) [goal> lemma exists_false5 is proved

lemma [any] exists_false5 ['a 'b 'c 'd 'e] :
(exists (a:'a,b:'b,c:'c,d:'d,e:'e), false) = false
Exiting proof mode.

Goal exists_false6 :
(exists (a:'a,b:'b,c:'c,d:'d,e:'e,f:'f), false) = false
[goal> Focused goal (1/1):
System: any
Type variables: 'a, 'b, 'c, 'd, 'e, 'f
----------------------------------------
(exists (a:'a,b:'b,c:'c,d:'d,e:'e,f:'f), false) = false

[> Line 809: by (rewrite ...) [goal> lemma exists_false6 is proved

lemma [any] exists_false6 ['a 'b 'c 'd 'e 'f] :
(exists (a:'a,b:'b,c:'c,d:'d,e:'e,f:'f), false) = false
Exiting proof mode.

Goal forall_true1 :
(forall (a:'a), true) = true
[goal> Focused goal (1/1):
System: any
Type variables: 'a
----------------------------------------
(forall (a:'a), true) = true

[> Line 829: (auto ...) [goal> lemma forall_true1 is proved

lemma [any] forall_true1 ['a] : (forall (a:'a), true) = true
Exiting proof mode.

Goal forall_true2 :
(forall (a:'a,b:'b), true) = true
[goal> Focused goal (1/1):
System: any
Type variables: 'a, 'b
----------------------------------------
(forall (a:'a,b:'b), true) = true

[> Line 837: (auto ...) [goal> lemma forall_true2 is proved

lemma [any] forall_true2 ['a 'b] : (forall (a:'a,b:'b), true) = true
Exiting proof mode.

Goal forall_true3 :
(forall (a:'a,b:'b,c:'c), true) = true
[goal> Focused goal (1/1):
System: any
Type variables: 'a, 'b, 'c
----------------------------------------
(forall (a:'a,b:'b,c:'c), true) = true

[> Line 845: (auto ...) [goal> lemma forall_true3 is proved

lemma [any] forall_true3 ['a 'b 'c] : (forall (a:'a,b:'b,c:'c), true) = true
Exiting proof mode.

Goal forall_true4 :
(forall (a:'a,b:'b,c:'c,d:'d), true) = true
[goal> Focused goal (1/1):
System: any
Type variables: 'a, 'b, 'c, 'd
----------------------------------------
(forall (a:'a,b:'b,c:'c,d:'d), true) = true

[> Line 853: (auto ...) [goal> lemma forall_true4 is proved

lemma [any] forall_true4 ['a 'b 'c 'd] :
(forall (a:'a,b:'b,c:'c,d:'d), true) = true
Exiting proof mode.

Goal forall_true5 :
(forall (a:'a,b:'b,c:'c,d:'d,e:'e), true) = true
[goal> Focused goal (1/1):
System: any
Type variables: 'a, 'b, 'c, 'd, 'e
----------------------------------------
(forall (a:'a,b:'b,c:'c,d:'d,e:'e), true) = true

[> Line 861: (auto ...) [goal> lemma forall_true5 is proved

lemma [any] forall_true5 ['a 'b 'c 'd 'e] :
(forall (a:'a,b:'b,c:'c,d:'d,e:'e), true) = true
Exiting proof mode.

Goal forall_true6 :
(forall (a:'a,b:'b,c:'c,d:'d,e:'e,f:'f), true) = true
[goal> Focused goal (1/1):
System: any
Type variables: 'a, 'b, 'c, 'd, 'e, 'f
----------------------------------------
(forall (a:'a,b:'b,c:'c,d:'d,e:'e,f:'f), true) = true

[> Line 869: (auto ...) [goal> lemma forall_true6 is proved

lemma [any] forall_true6 ['a 'b 'c 'd 'e 'f] :
(forall (a:'a,b:'b,c:'c,d:'d,e:'e,f:'f), true) = true
Exiting proof mode.

axiom [any] len_zeroes : forall (x:message), len (zeroes x) = len x
axiom [any] exec_not_init :
forall (tau:timestamp),
init < tau => exec@tau = (exec@pred tau && cond@tau)
axiom [any] exec_init : forall (tau:timestamp), tau = init => exec@tau = true
axiom [any] cond_init : forall (tau:timestamp), tau = init => cond@tau = true
Goal exec_le :
tau' <= tau => exec@tau => exec@tau'
[goal> Focused goal (1/1):
System: any
Variables: tau,tau':timestamp
----------------------------------------
tau' <= tau => exec@tau => exec@tau'

[> Line 917: ((induction tau);(intro tau IH Hle Hexec)) [goal> Focused goal (1/1):
System: any
Variables: tau,tau':timestamp[const]
Hexec: exec@tau
Hle: tau' <= tau
IH: forall (tau0:timestamp),
tau0 < tau => tau' <= tau0 => exec@tau0 => exec@tau'
----------------------------------------
exec@tau'

[> Line 919: (case ..., (= tau tau')) [goal> Focused goal (1/2):
System: any
Variables: tau,tau':timestamp[const]
Hexec: exec@tau
Hle: tau' <= tau
IH: forall (tau0:timestamp),
tau0 < tau => tau' <= tau0 => exec@tau0 => exec@tau'
----------------------------------------
tau = tau' => exec@tau'

[> Line 921: (auto ...) [goal> Focused goal (1/1):
System: any
Variables: tau,tau':timestamp[const]
Hexec: exec@tau
Hle: tau' <= tau
IH: forall (tau0:timestamp),
tau0 < tau => tau' <= tau0 => exec@tau0 => exec@tau'
----------------------------------------
not (tau = tau') => exec@tau'

[> Line 923: (intro Hneq) [goal> Focused goal (1/1):
System: any
Variables: tau,tau':timestamp[const]
Hexec: exec@tau
Hle: tau' <= tau
Hneq: not (tau = tau')
IH: forall (tau0:timestamp),
tau0 < tau => tau' <= tau0 => exec@tau0 => exec@tau'
----------------------------------------
exec@tau'

[> Line 925: (rewrite ... // in Hexec) [goal> Focused goal (1/1):
System: any
Variables: tau,tau':timestamp[const]
Hexec: exec@pred tau && cond@tau
Hle: tau' <= tau
Hneq: not (tau = tau')
IH: forall (tau0:timestamp),
tau0 < tau => tau' <= tau0 => exec@tau0 => exec@tau'
----------------------------------------
exec@tau'

[> Line 927: by (apply ... ) [goal> lemma exec_le is proved

lemma [any] exec_le :
forall (tau,tau':timestamp), tau' <= tau => exec@tau => exec@tau'
Exiting proof mode.

Goal exec_cond :
happens(tau) => exec@tau => cond@tau
[goal> Focused goal (1/1):
System: any
Variables: tau:timestamp
----------------------------------------
happens(tau) => exec@tau => cond@tau

[> Line 937: (intro Hap Hexec) [goal> Focused goal (1/1):
System: any
Variables: tau:timestamp[const]
Hap: happens(tau)
Hexec: exec@tau
----------------------------------------
cond@tau

[> Line 939: ((case ..., (< init tau));(intro _)) [goal> Focused goal (1/2):
System: any
Variables: tau:timestamp[const]
Hap: happens(tau)
Hexec: exec@tau
_: init < tau
----------------------------------------
cond@tau

[> Line 941: by (rewrite ... in Hexec) [goal> Focused goal (1/1):
System: any
Variables: tau:timestamp[const]
Hap: happens(tau)
Hexec: exec@tau
_: not (init < tau)
----------------------------------------
cond@tau

[> Line 943: by (rewrite ...) [goal> lemma exec_cond is proved

lemma [any] exec_cond :
forall (tau:timestamp), happens(tau) => exec@tau => cond@tau
Exiting proof mode.

Goal f_apply :
x = y => f x = f y
[goal> Focused goal (1/1):
System: any
Type variables: 'a, 'b
Variables: f:'a -> 'b,x,y:'a
----------------------------------------
x = y => f x = f y

[> Line 955: by (intro ->) [goal> lemma f_apply is proved

lemma [any] f_apply ['a 'b] : forall (f:'a -> 'b,x,y:'a), x = y => f x = f y
Exiting proof mode.

Goal not_exists_1 :
not exists (a:'a), phi a = forall (a:'a), not (phi a)
[goal> Focused goal (1/1):
System: any
Type variables: 'a
Variables: phi:'a -> bool
----------------------------------------
not exists (a:'a), phi a = forall (a:'a), not (phi a)

[> Line 965: (rewrite ...) [goal> Focused goal (1/1):
System: any
Type variables: 'a
Variables: phi:'a -> bool
----------------------------------------
not exists (a:'a), phi a <=> forall (a:'a), not (phi a)

[> Line 967: split [goal> Focused goal (1/2):
System: any
Type variables: 'a
Variables: phi:'a -> bool
----------------------------------------
not exists (a:'a), phi a => forall (a:'a), not (phi a)

[> Line 969: (intro H a Hp) [goal> Focused goal (1/2):
System: any
Type variables: 'a
Variables: a:'a,phi:'a -> bool
H: not exists (a:'a), phi a
Hp: phi a
----------------------------------------
false

[> Line 971: (apply ... ) [goal> Focused goal (1/2):
System: any
Type variables: 'a
Variables: a:'a,phi:'a -> bool
H: not exists (a:'a), phi a
Hp: phi a
----------------------------------------
exists (a:'a), phi a

[> Line 973: by (exists a) [goal> Focused goal (1/1):
System: any
Type variables: 'a
Variables: phi:'a -> bool
----------------------------------------
(forall (a:'a), not (phi a)) => not exists (a:'a), phi a

[> Line 975: (intro H [a Hp]) [goal> Focused goal (1/1):
System: any
Type variables: 'a
Variables: a:'a,phi:'a -> bool
H: forall (a:'a), not (phi a)
Hp: phi a
----------------------------------------
false

[> Line 977: by (have ...) [goal> lemma not_exists_1 is proved

lemma [any] not_exists_1 ['a] :
forall (phi:'a -> bool),
not exists (a:'a), phi a = forall (a:'a), not (phi a)
Exiting proof mode.

Goal not_exists_2 :
not exists (a:'a,b:'b), phi a b = forall (a:'a,b:'b), not (phi a b)
[goal> Focused goal (1/1):
System: any
Type variables: 'a, 'b
Variables: phi:'a -> 'b -> bool
----------------------------------------
not exists (a:'a,b:'b), phi a b = forall (a:'a,b:'b), not (phi a b)

[> Line 989: (rewrite ...) [goal> Focused goal (1/1):
System: any
Type variables: 'a, 'b
Variables: phi:'a -> 'b -> bool
----------------------------------------
not exists (a:'a,b:'b), phi a b <=> forall (a:'a,b:'b), not (phi a b)

[> Line 991: split [goal> Focused goal (1/2):
System: any
Type variables: 'a, 'b
Variables: phi:'a -> 'b -> bool
----------------------------------------
not exists (a:'a,b:'b), phi a b => forall (a:'a,b:'b), not (phi a b)

[> Line 993: (intro H a b Hp) [goal> Focused goal (1/2):
System: any
Type variables: 'a, 'b
Variables: a:'a,b:'b,phi:'a -> 'b -> bool
H: not exists (a:'a,b:'b), phi a b
Hp: phi a b
----------------------------------------
false

[> Line 995: (apply ... ) [goal> Focused goal (1/2):
System: any
Type variables: 'a, 'b
Variables: a:'a,b:'b,phi:'a -> 'b -> bool
H: not exists (a:'a,b:'b), phi a b
Hp: phi a b
----------------------------------------
exists (a:'a,b:'b), phi a b

[> Line 997: by (exists a, b) [goal> Focused goal (1/1):
System: any
Type variables: 'a, 'b
Variables: phi:'a -> 'b -> bool
----------------------------------------
(forall (a:'a,b:'b), not (phi a b)) => not exists (a:'a,b:'b), phi a b

[> Line 999: (intro H [a b Hp]) [goal> Focused goal (1/1):
System: any
Type variables: 'a, 'b
Variables: a:'a,b:'b,phi:'a -> 'b -> bool
H: forall (a:'a,b:'b), not (phi a b)
Hp: phi a b
----------------------------------------
false

[> Line 1001: by (have ...) [goal> lemma not_exists_2 is proved

lemma [any] not_exists_2 ['a 'b] :
forall (phi:'a -> 'b -> bool),
not exists (a:'a,b:'b), phi a b = forall (a:'a,b:'b), not (phi a b)
Exiting proof mode.

axiom [any] not_forall_1 ['a] :
forall (phi:'a -> bool),
not forall (a:'a), phi a = exists (a:'a), not (phi a)
axiom [any] not_forall_2 ['a 'b] :
forall (phi:'a -> 'b -> bool),
not forall (a:'a,b:'b), phi a b = exists (a:'a,b:'b), not (phi a b)
axiom [any] try_carac_1 ['a 'b] :
forall (phi:'a -> bool,f:'a -> 'b,g:'b),
try find x:'a such that phi x in f x else g =
if (exists (x:'a), phi x) then f (choose phi) else g
Goal choose_spec :
phi x => phi (choose phi)
[goal> Focused goal (1/1):
System: any
Type variables: 'a
Variables: phi:'a -> bool,x:'a
----------------------------------------
phi x => phi (choose phi)

[> Line 1053: (intro H) [goal> Focused goal (1/1):
System: any
Type variables: 'a
Variables: phi:'a -> bool,x:'a
H: phi x
----------------------------------------
phi (choose phi)

[> Line 1059: (have ...) [goal> Focused goal (1/2):
System: any
Type variables: 'a
Variables: phi:'a -> bool,x:'a
H: phi x
----------------------------------------
phi (choose phi) = if (exists (x:'a), phi x) then phi (choose phi) else false

[> Line 1061: ?? [goal> Focused goal (1/2):
System: any
Type variables: 'a
Variables: phi:'a -> bool,x:'a
H: phi x
----------------------------------------
phi (choose phi) = if (exists (x:'a), phi x) then phi (choose phi) else false

[> Line 1063: ((rewrite ...);(intro //)) [goal> Focused goal (1/2):
System: any
Type variables: 'a
Variables: phi:'a -> bool,x:'a
H: phi x
----------------------------------------
exists (x:'a), phi x

[> Line 1063: by (exists x) [goal> Focused goal (1/1):
System: any
Type variables: 'a
Variables: phi:'a -> bool,x:'a
H: phi x
----------------------------------------
if (exists (x:'a), phi x) then phi (choose phi) else false

[> Line 1065: ?? [goal> Focused goal (1/1):
System: any
Type variables: 'a
Variables: phi:'a -> bool,x:'a
H: phi x
----------------------------------------
if (exists (x:'a), phi x) then phi (choose phi) else false

[> Line 1067: (rewrite ...) [goal> Focused goal (1/1):
System: any
Type variables: 'a
Variables: phi:'a -> bool,x:'a
H: phi x
----------------------------------------
try find x:'a such that phi x in phi x else false

[> Line 1069: (case ...,
try find x:_ such that (phi x) in (phi x) else false)
[goal> Focused goal (1/2):
System: any
Type variables: 'a
Variables: phi:'a -> bool,x:'a
H: phi x
----------------------------------------
(exists (x:'a),
phi x && try find x:'a such that phi x in phi x else false = phi x) =>
try find x:'a such that phi x in phi x else false

[> Line 1071: (auto ...) [goal> Focused goal (1/1):
System: any
Type variables: 'a
Variables: phi:'a -> bool,x:'a
H: phi x
----------------------------------------
(forall (x:'a), not (phi x)) &&
try find x:'a such that phi x in phi x else false = false =>
try find x:'a such that phi x in phi x else false

[> Line 1073: ((intro [HH _]);by (have ...)) [goal> lemma choose_spec is proved

lemma [any] choose_spec ['a] :
forall (phi:'a -> bool,x:'a), phi x => phi (choose phi)
Exiting proof mode.

Goal try_choose :
phi x => try find x:'a such that phi x in f x else g = f (choose phi)
[goal> Focused goal (1/1):
System: any
Type variables: 'a, 'b
Variables: f:'a -> 'b,g:'b,phi:'a -> bool,x:'a
----------------------------------------
phi x => try find x:'a such that phi x in f x else g = f (choose phi)

[> Line 1091: (intro H) [goal> Focused goal (1/1):
System: any
Type variables: 'a, 'b
Variables: f:'a -> 'b,g:'b,phi:'a -> bool,x:'a
H: phi x
----------------------------------------
try find x:'a such that phi x in f x else g = f (choose phi)

[> Line 1093: (rewrite ...) [goal> Focused goal (1/1):
System: any
Type variables: 'a, 'b
Variables: f:'a -> 'b,g:'b,phi:'a -> bool,x:'a
H: phi x
----------------------------------------
if (exists (x:'a), phi x) then f (choose phi) else g = f (choose phi)

[> Line 1095: ((rewrite ...);(intro //)) [goal> Focused goal (1/1):
System: any
Type variables: 'a, 'b
Variables: f:'a -> 'b,g:'b,phi:'a -> bool,x:'a
H: phi x
----------------------------------------
exists (x:'a), phi x

[> Line 1097: by (exists x) [goal> lemma try_choose is proved

lemma [any] try_choose ['a 'b] :
forall (phi:'a -> bool,f:'a -> 'b,g:'b,x:'a),
phi x => try find x:'a such that phi x in f x else g = f (choose phi)
Exiting proof mode.

Goal forall_exists :
(forall (x:'a), exists (y:'b), phi x y) =
exists (y':'a -> 'b), forall (x:'a), phi x (y' x)
[goal> Focused goal (1/1):
System: any
Type variables: 'a, 'b
Variables: phi:'a -> 'b -> bool
----------------------------------------
(forall (x:'a), exists (y:'b), phi x y) =
exists (y':'a -> 'b), forall (x:'a), phi x (y' x)

[> Line 1115: ((rewrite ...);split) [goal> Focused goal (1/2):
System: any
Type variables: 'a, 'b
Variables: phi:'a -> 'b -> bool
----------------------------------------
(forall (x:'a), exists (y:'b), phi x y) =>
exists (y':'a -> 'b), forall (x:'a), phi x (y' x)

[> Line 1117: (intro H) [goal> Focused goal (1/2):
System: any
Type variables: 'a, 'b
Variables: phi:'a -> 'b -> bool
H: forall (x:'a), exists (y:'b), phi x y
----------------------------------------
exists (y':'a -> 'b), forall (x:'a), phi x (y' x)

[> Line 1119: (exists (fun (x : _) => (choose (fun (y : _) => (phi x y))))) [goal> Focused goal (1/2):
System: any
Type variables: 'a, 'b
Variables: phi:'a -> 'b -> bool
H: forall (x:'a), exists (y:'b), phi x y
----------------------------------------
forall (x:'a), phi x ((fun (x:'a) => choose (fun (y:'b) => phi x y)) x)

[> Line 1121: ((intro x);(simpl ...)) [goal> Focused goal (1/2):
System: any
Type variables: 'a, 'b
Variables: phi:'a -> 'b -> bool,x:'a
H: forall (x:'a), exists (y:'b), phi x y
----------------------------------------
phi x (choose (fun (y:'b) => phi x y))

[> Line 1123: (have (.. := ...)) [goal> Focused goal (1/2):
System: any
Type variables: 'a, 'b
Variables: phi:'a -> 'b -> bool,x:'a,y:'b
H: forall (x:'a), exists (y:'b), phi x y
Hy: phi x y
----------------------------------------
phi x (choose (fun (y:'b) => phi x y))

[> Line 1131: ((have ...); 1: by (auto ...)) [goal> Focused goal (1/2):
System: any
Type variables: 'a, 'b
Variables: phi:'a -> 'b -> bool,x:'a,y:'b
H: forall (x:'a), exists (y:'b), phi x y
Hy: phi x y
----------------------------------------
(fun (y:'b) => phi x y) (choose (fun (y:'b) => phi x y))

[> Line 1133: (apply ... ) [goal> Focused goal (1/2):
System: any
Type variables: 'a, 'b
Variables: phi:'a -> 'b -> bool,x:'a,y:'b
H: forall (x:'a), exists (y:'b), phi x y
Hy: phi x y
----------------------------------------
(fun (y:'b) => phi x y) y

[> Line 1135: ((simpl ...);assumption) [goal> Focused goal (1/1):
System: any
Type variables: 'a, 'b
Variables: phi:'a -> 'b -> bool
----------------------------------------
(exists (y':'a -> 'b), forall (x:'a), phi x (y' x)) =>
forall (x:'a), exists (y:'b), phi x y

[> Line 1137: (intro [y' H] x) [goal> Focused goal (1/1):
System: any
Type variables: 'a, 'b
Variables: phi:'a -> 'b -> bool,x:'a,y':'a -> 'b
H: forall (x:'a), phi x (y' x)
----------------------------------------
exists (y:'b), phi x y

[> Line 1139: (exists (y' x)) [goal> Focused goal (1/1):
System: any
Type variables: 'a, 'b
Variables: phi:'a -> 'b -> bool,x:'a,y':'a -> 'b
H: forall (x:'a), phi x (y' x)
----------------------------------------
phi x (y' x)

[> Line 1141: by (apply ... ) [goal> lemma forall_exists is proved

lemma [any] forall_exists ['a 'b] :
forall (phi:'a -> 'b -> bool),
(forall (x:'a), exists (y:'b), phi x y) =
exists (y':'a -> 'b), forall (x:'a), phi x (y' x)
Exiting proof mode.

Goal implies_exists :
(phi => exists (j:'a), psi j) = exists (x:'a), phi => psi x
[goal> Focused goal (1/1):
System: any
Type variables: 'a
Variables: phi:bool,psi:'a -> bool
----------------------------------------
(phi => exists (j:'a), psi j) = exists (x:'a), phi => psi x

[> Line 1155: ((rewrite ...);split) [goal> Focused goal (1/2):
System: any
Type variables: 'a
Variables: phi:bool[const],psi:'a -> bool
----------------------------------------
(phi => exists (j:'a), psi j) => exists (x:'a), phi => psi x

[> Line 1157: (intro H) [goal> Focused goal (1/2):
System: any
Type variables: 'a
Variables: phi:bool[const],psi:'a -> bool
H: phi => exists (j:'a), psi j
----------------------------------------
exists (x:'a), phi => psi x

[> Line 1159: (case ..., phi) [goal> Focused goal (1/3):
System: any
Type variables: 'a
Variables: phi:bool[const],psi:'a -> bool
H: phi => exists (j:'a), psi j
----------------------------------------
phi => exists (x:'a), true => psi x

[> Line 1161: (intro phi) [goal> Focused goal (1/3):
System: any
Type variables: 'a
Variables: phi:bool[const],psi:'a -> bool
H: phi => exists (j:'a), psi j
phi: phi
----------------------------------------
exists (x:'a), true => psi x

[> Line 1163: ((have ...); 1: by (apply ... )) [goal> Focused goal (1/3):
System: any
Type variables: 'a
Variables: phi:bool[const],psi:'a -> bool,x:'a
H: phi => exists (j:'a), psi j
_: psi x
phi: phi
----------------------------------------
exists (x:'a), true => psi x

[> Line 1165: by (exists x) [goal> Focused goal (1/2):
System: any
Type variables: 'a
Variables: phi:bool[const],psi:'a -> bool
H: phi => exists (j:'a), psi j
----------------------------------------
not phi => exists (x:'a), false => psi x

[> Line 1167: (intro _) [goal> Focused goal (1/2):
System: any
Type variables: 'a
Variables: phi:bool[const],psi:'a -> bool
H: phi => exists (j:'a), psi j
_: not phi
----------------------------------------
exists (x:'a), false => psi x

[> Line 1169: by (exists (choose (fun (_x : _) => false))) [goal> Focused goal (1/1):
System: any
Type variables: 'a
Variables: phi:bool[const],psi:'a -> bool
----------------------------------------
(exists (x:'a), phi => psi x) => phi => exists (j:'a), psi j

[> Line 1171: (intro [x H] H') [goal> Focused goal (1/1):
System: any
Type variables: 'a
Variables: phi:bool[const],psi:'a -> bool,x:'a
H: phi => psi x
H': phi
----------------------------------------
exists (j:'a), psi j

[> Line 1173: by (exists x) [goal> lemma implies_exists is proved

lemma [any] implies_exists ['a] :
forall (phi:bool,psi:'a -> bool),
(phi => exists (j:'a), psi j) = exists (x:'a), phi => psi x
Exiting proof mode.

axiom [any] le_trans ['a] : forall (x,y,z:'a), x <= y => y <= z => x <= z
axiom [any] lt_trans ['a] : forall (x,y,z:'a), x < y => y < z => x < z
axiom [any] lt_le_trans ['a] : forall (x,y,z:'a), x < y => y <= z => x < z
axiom [any] le_lt_trans ['a] : forall (x,y,z:'a), x <= y => y < z => x < z
axiom [any] lt_charac ['a] : forall (x,y:'a), x < y <=> x <> y && x <= y
axiom [any] le_not_lt_impl_eq ['a] :
forall (x,y:'a), x <= y => not (x < y) => x = y
Goal lt_impl_le :
x < y => x <= y
[goal> Focused goal (1/1):
System: any
Type variables: 'a
Variables: x,y:'a
----------------------------------------
x < y => x <= y

[> Line 1205: by (rewrite ...) [goal> lemma lt_impl_le is proved

lemma [any] lt_impl_le ['a] : forall (x,y:'a), x < y => x <= y
Exiting proof mode.

Goal not_lt_refl :
not (x < x)
[goal> Focused goal (1/1):
System: any
Type variables: 'a
Variables: x:'a
----------------------------------------
not (x < x)

[> Line 1211: (auto ...) [goal> lemma not_lt_refl is proved

lemma [any] not_lt_refl ['a] : forall (x:'a), not (x < x)
Exiting proof mode.

Goal lt_irrefl :
x < x <=> false
[goal> Focused goal (1/1):
System: any
Type variables: 'a
Variables: x:'a
----------------------------------------
x < x <=> false

[> Line 1217: (auto ...) [goal> lemma lt_irrefl is proved

lemma [any] lt_irrefl ['a] : forall (x:'a), x < x <=> false
Exiting proof mode.

axiom [any] le_impl_eq_lt ['a] : forall (x,y:'a), x <= y => x = y || x < y
axiom [any] le_refl_index : forall (x:index), x <= x
Goal le_refl_index_eq :
x <= x = true
[goal> Focused goal (1/1):
System: any
Variables: x:index
----------------------------------------
x <= x = true

[> Line 1241: by (rewrite ...) [goal> lemma le_refl_index_eq is proved

lemma [any] le_refl_index_eq : forall (x:index), x <= x = true
Exiting proof mode.

Goal le_pred_lt :
t <= pred t' = t < t'
[goal> Focused goal (1/1):
System: any
Variables: t,t':timestamp
----------------------------------------
t <= pred t' = t < t'

[> Line 1251: by (rewrite ...) [goal> lemma le_pred_lt is proved

lemma [any] le_pred_lt : forall (t,t':timestamp), t <= pred t' = t < t'
Exiting proof mode.

Goal neq_le_pred_le :
t <> t' => t <= t' = t <= pred t'
[goal> Focused goal (1/1):
System: any
Variables: t,t':timestamp
----------------------------------------
t <> t' => t <= t' = t <= pred t'

[> Line 1259: by (rewrite ...) [goal> lemma neq_le_pred_le is proved

lemma [any] neq_le_pred_le :
forall (t,t':timestamp), t <> t' => t <= t' = t <= pred t'
Exiting proof mode.

axiom [any] le_lt ['a] : forall (x,x':'a), x <> x' => x <= x' = x < x'
axiom [any] empty_set_is_empty : forall (x:message), not (mem x empty_set)
[warning>Loaded "Basic.sp".
<]

Needham-Schroeder-Lowe protocol.

(* ------------------------------------------------------------------------ *)



abstract make1 : message * message -> message.

Constructors and destructors for contents of the three messages. This amounts to minimal assumptions on how messages are formatted, but we make further assumptions about lengths and tags below.


abstract get1_na : message -> message.

abstract get1_id : message -> message.

axiom [any] get1_na (x,y:_) : get1_na(make1(x,y)) = x.
axiom [any] get1_na : forall (x,y:message), get1_na (make1 (x, y)) = x


abstract make2 : message * message * message -> message.

abstract get2_na : message -> message.

abstract get2_nb : message -> message.

abstract get2_id : message -> message.

axiom [any] get2_na (x,y,z:_) : get2_na(make2(x,y,z)) = x.
axiom [any] get2_na : forall (x,y,z:message), get2_na (make2 (x, y, z)) = x

axiom [any] get2_nb (x,y,z:_) : get2_nb(make2(x,y,z)) = y.
axiom [any] get2_nb : forall (x,y,z:message), get2_nb (make2 (x, y, z)) = y

axiom [any] get2_id (x,y,z:_) : get2_id(make2(x,y,z)) = z.
axiom [any] get2_id : forall (x,y,z:message), get2_id (make2 (x, y, z)) = z


abstract make3 : message * message -> message.

abstract get3_na : message -> message.

abstract get3_nb : message -> message.

axiom [any] get3_na (x,y:_) : get3_na(make3(x,y)) = x.
axiom [any] get3_na : forall (x,y:message), get3_na (make3 (x, y)) = x

axiom [any] get3_nb (x,y:_) : get3_nb(make3(x,y)) = y.
axiom [any] get3_nb : forall (x,y:message), get3_nb (make3 (x, y)) = y
(* ------------------------------------------------------------------------ *)



(* We rely on encryption and decryption functions such that,
for any plaintext `m`, encryption key `k` and encryption randomness `r`,
`dec (enc m k r) k = m`.

We assume that encryption is secure against chosen-ciphertext
attacks in the sense of the IND-CCA2 game.
The game expresses the indistinguishability between
two encrypted messages of same length.
The adversary is given access to a challenge oracle `encrypt`
that takes two inputs `m0`,`m1` and (provided they have the same length)
returns:
- in the left-game the encryption of `m0` and
- in the right-game the encryption of `m1`.
Moreover the adversary can also use a decryption oracle
on any message other than the ones outputted by the `encrypt`
oracle. *)

abstract pub : message -> message.

Asymmetric encryption and CCA2 game.


abstract dec : message*message -> message.

abstract enc : message*message*message -> message.


game CCA2 = {
rnd key : message;
var log = empty_set;
oracle pk = {
return (pub key)
}
oracle encrypt (m0,m1 : message) = {
rnd r: message;
var c = enc(diff(m0,m1),r,pub key);
log := add c log ;
return if zeroes m0 = zeroes m1 then c else empty
}
oracle decrypt (c : message) = {
return if not (mem c log) then dec(c,key)
}
}.
game CCA2 = {
rnd key : message;
var log : mset = empty_set;
oracle pk : message = { return pub key}
oracle encrypt (m0,m1:message) : message = {
rnd r : message;
var c : message = enc (diff(m0, m1), r, pub key);
log := add c log;
return if (zeroes m0 = zeroes m1) then c else empty
}
oracle decrypt (c:message) : message = {
return if not (mem c log) then dec (c, key)
}
}
(* ------------------------------------------------------------------------ *)



name ska : message.
global axiom [any] namelength_ska : [len ska = namelength_message]

Protocol description. We consider only one session of each role.


name skb : message.
global axiom [any] namelength_skb : [len skb = namelength_message]


name na : message.
global axiom [any] namelength_na : [len na = namelength_message]

name nb : message.
global axiom [any] namelength_nb : [len nb = namelength_message]

name nb' : message.
global axiom [any] namelength_nb' : [len nb' = namelength_message]

name na' : message.
global axiom [any] namelength_na' : [len na' = namelength_message]

name r1 : message.
global axiom [any] namelength_r1 : [len r1 = namelength_message]

name r1' : message.
global axiom [any] namelength_r1' : [len r1' = namelength_message]

name r2 : message.
global axiom [any] namelength_r2 : [len r2 = namelength_message]

name r2' : message.
global axiom [any] namelength_r2' : [len r2' = namelength_message]

name r3 : message.
global axiom [any] namelength_r3 : [len r3 = namelength_message]

name r3' : message.
global axiom [any] namelength_r3' : [len r3' = namelength_message]


(* Introduce three constants that are assumed to have the same
lengths, respectively, as the three messages.
We also assume that len1 passes the tag verification associated
to the first message, but that len3 and make3 results do not. *)
abstract len1 : message.

abstract len2 : message.

abstract len3 : message.


axiom [any] len1 : zeroes len1 = zeroes(make1(na,pub(ska))).
axiom [any] len1 : zeroes len1 = zeroes (make1 (na, pub ska))

axiom [any] len2 : zeroes len2 = zeroes(make2(na,nb,pub(skb))).
axiom [any] len2 : zeroes len2 = zeroes (make2 (na, nb, pub skb))

axiom [any] len3 : zeroes len3 = zeroes(make3(nb,na)).
axiom [any] len3 : zeroes len3 = zeroes (make3 (nb, na))


abstract check_tag : message -> bool.

axiom [any] check_tag_msg1 (x,y:message) : check_tag (make1(x,y)).
axiom [any] check_tag_msg1 : forall (x,y:message), check_tag (make1 (x, y))

axiom [any] check_tag_msg3 (x,y:message) : not (check_tag (make3(x,y))).
axiom [any] check_tag_msg3 :
forall (x,y:message), not (check_tag (make3 (x, y)))

axiom [any] check_tag_len1 : check_tag len1.
axiom [any] check_tag_len1 : check_tag len1

axiom [any] check_tag_len3 : not (check_tag len3).
axiom [any] check_tag_len3 : not (check_tag len3)


channel c.


(* We define our main bi-system:
- NSL/left is the real protocol;
- NSL/right is the idealized protocol where the contents of encryptions
are changed by zeroes.
Note that NSL/left already "anticipates" the idealization by incorporating
special cases in its logic (e.g. Bob outputs msg2 when msg1 is received)
but this is obviously equivalent to the original specification (modulo
axioms on tag verifications). *)

process Alice =
let msg1 = enc(diff(make1(na,pub(ska)),len1),r1,pub skb) in
let msg2 = enc(diff(make2(na,nb,pub skb),len2),r2,pub ska) in
let msg3 = enc(diff(make3(nb,na),len3),r3,pub skb) in
in(c,pk);
out(c, if pk = pub skb then msg1 else enc(make1(na,pub ska),r1',pk));
in(c,x);
(* Last output of Alice, to which we add <na,nb> to model strong secrecy
when the protocol completes and pk is honest, i.e. pk = pub skb. *)
out(c, (* Cannot decrypt msg2: express result directly. *)
if x = msg2 then (if pk = pub skb then <msg3,<na,nb>>) else
if get2_na(dec(x,ska)) = na && get2_id(dec(x,ska)) = pk then
(* Use alternate randomness for encryption. *)
<enc(make3(get2_nb(dec(x,ska)),na), r3', pk),
if pk = pub skb then <na,nb>>).
process Alice =
let msg1 : message = enc (diff(make1 (na, pub ska), len1), r1, pub skb) in
let msg2 : message =
enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska) in
let msg3 : message = enc (diff(make3 (nb, na), len3), r3, pub skb) in
in(c,pk);
out(c,
if (pk = pub skb) then msg1 else enc (make1 (na, pub ska), r1', pk));
in(c,x);
out(c,
if (x = msg2) then (if (pk = pub skb) then <msg3,<na,nb>>)
else if (get2_na (dec (x, ska)) = na && get2_id (dec (x, ska)) = pk)
then
<enc (make3 (get2_nb (dec (x, ska)), na), r3', pk),
if (pk = pub skb) then <na,nb>>);
null


process Bob =
let msg1 = enc(diff(make1(na,pub(ska)),len1),r1,pub skb) in
let msg2 = enc(diff(make2(na, nb, pub skb),len2),r2,pub ska) in
let msg3 = enc(diff(make3(nb,na), len3), r3, pub skb) in
in(c,x);
out(c, (* Cannot decrypt msg1: express result directly. *)
if x = msg1 then msg2 else
(* Cannot decrypt msg3: directly encode result (failed tag check). *)
if x = msg3 then empty else
if check_tag (dec(x,skb)) then
enc(make2(get1_na(dec(x,skb)),
nb, pub skb),
r2', get1_id(dec(x,skb)))).
process Bob =
let msg1 : message = enc (diff(make1 (na, pub ska), len1), r1, pub skb) in
let msg2 : message =
enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska) in
let msg3 : message = enc (diff(make3 (nb, na), len3), r3, pub skb) in
in(c,x);
out(c,
if (x = msg1) then msg2
else if (x = msg3) then empty
else if check_tag (dec (x, skb)) then
enc
(make2 (get1_na (dec (x, skb)), nb, pub skb),
r2',
get1_id (dec (x, skb))));
null


system [NSL]
(PUB : out(c, <pub(ska),pub(skb)>);
((A : Alice)|(B : Bob))).
Typed-check process:

PUB: out(c,<pub ska,pub skb>); ( A: Alice ) | B: Bob

Added action dependencies lemmas:

axiom [NSL] depends_NSL_A_A1 :
forall (t:timestamp), t = A1 => happens(t) => A < A1
axiom [NSL] depends_NSL_PUB_B :
forall (t:timestamp), t = B => happens(t) => PUB < B
axiom [NSL] depends_NSL_PUB_A1 :
forall (t:timestamp), t = A1 => happens(t) => PUB < A1
axiom [NSL] depends_NSL_PUB_A :
forall (t:timestamp), t = A => happens(t) => PUB < A
axiom [NSL] depends_NSL_init_B :
forall (t:timestamp), t = B => happens(t) => init < B
axiom [NSL] depends_NSL_init_A1 :
forall (t:timestamp), t = A1 => happens(t) => init < A1
axiom [NSL] depends_NSL_init_A :
forall (t:timestamp), t = A => happens(t) => init < A
axiom [NSL] depends_NSL_init_PUB :
forall (t:timestamp), t = PUB => happens(t) => init < PUB

System after processing:

PUB: out(c,<pub ska,pub skb>);
( let msg1 : message =
enc (diff(make1 (na, pub ska), len1), r1, pub skb) in
let msg2 : message =
enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska) in
let msg3 : message = enc (diff(make3 (nb, na), len3), r3, pub skb) in
in(c,pk);
A: out(c,
if (pk = pub skb) then msg1
else enc (make1 (na, pub ska), r1', pk)); in(c,x);
A1: out(c,
if (x = msg2@τ) then
(if (input@A = pub skb) then <msg3@τ,<na,nb>>)
else if (get2_na (dec (x, ska)) = na &&
get2_id (dec (x, ska)) = input@A) then
<enc (make3 (get2_nb (dec (x, ska)), na), r3', input@A),
if (input@A = pub skb) then <na,nb>>); null ) |
let msg1 : message = enc (diff(make1 (na, pub ska), len1), r1, pub skb) in
let msg2 : message =
enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska) in
let msg3 : message = enc (diff(make3 (nb, na), len3), r3, pub skb) in
in(c,x);
B: out(c,
if (x = msg4@τ) then msg5
else if (x = msg6@τ) then empty
else if check_tag (dec (x, skb)) then
enc
(make2 (get1_na (dec (x, skb)), nb, pub skb),
r2',
get1_id (dec (x, skb)))); null

System Empty registered with actions (init).
System NSL registered with actions (init,PUB,A,A1,B).


(* We now explain why observational equivalence of NSL/left and /right
implies the strong secrecy of na and nb: the output of these
two nonces at the end of Alice can be replaced by two fresh names
without the attacker being able to distinguish the two situations.

Note that, in NSL/right, if we exclude the final output of `<na,nb>`:
- assuming `pk = pub skb`,
na only occurs in the last test and encryption of Alice;
- nb only occurs in the last encryption of Bob.

We could then prove, when `pk = pub skb`, the test
`get2_na(dec(input@A1,ska)) = na` is always false by freshness of na
at this point. This allows to prove that the final output of na
is indistinguishable from a fresh name (it is actually a fresh name itself):
thus na is strongly secret in NSL/right. By observational equivalence,
it is also strongly secret in the real protocol NSL/left.

Further, we only output `<na,nb>` at the end of Alice if `pk = pub skb`
and the execution is successful:
`input@A1 = msg2 || get2_na(dec(input@A1,ska)) = na`.
We've seen that the second part is always false. Now, `input@A1 = msg2`
can only hold if Bob sent that message (by IND-CCA2) hence `input@B = msg1`.
Under our condition, we thus have no occurrence of `nb` on Bob's side,
hence `nb` is also indistinguishable from a fresh name in the final output
of `<na,nb>` by Alice. *)

(* It would also be good to model the strong secrecy of `nb` when Bob
believes he's had a honest interaction with Alice -- this property fails in
the original Needham-Schroeder protocol due to the man-in-the-middle attack.
This would be modelled by outputting `nb` at the end of Bob's process when
`get1_id(dec(input@B,skb)) = pub ska`. However, proving that this output
is indistinguishable from a fresh name requires idealizing further the
process, and introduce extra difficulties on Alice's side: we leave this
more complete proof to future work, but note that these aspects are
independent of CCA2 reasoning and bi-deduction. *)

(* ----------------------------------------------------------------------- *)

(* Because we apply CCA2 for each key ska and skb separately,
we need to introduce an intermediate (bi)system:
- NSL_a/left has real messages for outputs of Alice,
but idealized ones for Bob's messages;
- NSL_a/right is the same as NSL/right. *)

process Alice_a =
let msg1 = enc(diff(make1(na,pub(ska)),len1),r1,pub(skb)) in
let msg2 = enc(len2,r2, pub ska) in
let msg3 = enc(diff(make3(nb,na), len3), r3, pub skb) in
in(c,pk);
out(c, if pk = pub skb then msg1 else enc(make1(na,pub ska),r1',pk));
in(c,x);
out(c, if x = msg2 then (if pk = pub skb then <msg3,<na,nb>>) else
if get2_na(dec(x,ska)) = na && get2_id(dec(x,ska)) = pk then
<enc(make3(get2_nb(dec(x,ska)),na), r3', pk),
if pk = pub skb then <na,nb>>).
process Alice_a =
let msg1 : message = enc (diff(make1 (na, pub ska), len1), r1, pub skb) in
let msg2 : message = enc (len2, r2, pub ska) in
let msg3 : message = enc (diff(make3 (nb, na), len3), r3, pub skb) in
in(c,pk);
out(c,
if (pk = pub skb) then msg1 else enc (make1 (na, pub ska), r1', pk));
in(c,x);
out(c,
if (x = msg2) then (if (pk = pub skb) then <msg3,<na,nb>>)
else if (get2_na (dec (x, ska)) = na && get2_id (dec (x, ska)) = pk)
then
<enc (make3 (get2_nb (dec (x, ska)), na), r3', pk),
if (pk = pub skb) then <na,nb>>);
null


process Bob_a =
let msg1 = enc(diff(make1(na,pub(ska)),len1),r1,pub(skb)) in
let msg2 = enc(len2,r2,pub ska) in
let msg3 = enc(diff(make3(nb,na), len3), r3, pub skb) in
in(c,x);
out(c, if x = msg1 then msg2 else
if x = msg3 then empty else
if check_tag (dec(x,skb)) then
enc(make2(get1_na(dec(x,skb)),
nb, pub skb),
r2', get1_id(dec(x,skb)))).
process Bob_a =
let msg1 : message = enc (diff(make1 (na, pub ska), len1), r1, pub skb) in
let msg2 : message = enc (len2, r2, pub ska) in
let msg3 : message = enc (diff(make3 (nb, na), len3), r3, pub skb) in
in(c,x);
out(c,
if (x = msg1) then msg2
else if (x = msg3) then empty
else if check_tag (dec (x, skb)) then
enc
(make2 (get1_na (dec (x, skb)), nb, pub skb),
r2',
get1_id (dec (x, skb))));
null


system [NSL_a]
(PUB : out(c, <pub(ska),pub(skb)>);
((A : Alice_a)|(B : Bob_a))).
Typed-check process:

PUB: out(c,<pub ska,pub skb>); ( A: Alice_a ) | B: Bob_a

Added action dependencies lemmas:

axiom [NSL_a] depends_NSL_a_A_A1 :
forall (t:timestamp), t = A1 => happens(t) => A < A1
axiom [NSL_a] depends_NSL_a_PUB_B :
forall (t:timestamp), t = B => happens(t) => PUB < B
axiom [NSL_a] depends_NSL_a_PUB_A1 :
forall (t:timestamp), t = A1 => happens(t) => PUB < A1
axiom [NSL_a] depends_NSL_a_PUB_A :
forall (t:timestamp), t = A => happens(t) => PUB < A
axiom [NSL_a] depends_NSL_a_init_B :
forall (t:timestamp), t = B => happens(t) => init < B
axiom [NSL_a] depends_NSL_a_init_A1 :
forall (t:timestamp), t = A1 => happens(t) => init < A1
axiom [NSL_a] depends_NSL_a_init_A :
forall (t:timestamp), t = A => happens(t) => init < A
axiom [NSL_a] depends_NSL_a_init_PUB :
forall (t:timestamp), t = PUB => happens(t) => init < PUB

System after processing:

PUB: out(c,<pub ska,pub skb>);
( let msg1 : message =
enc (diff(make1 (na, pub ska), len1), r1, pub skb) in
let msg2 : message = enc (len2, r2, pub ska) in
let msg3 : message = enc (diff(make3 (nb, na), len3), r3, pub skb) in
in(c,pk);
A: out(c,
if (pk = pub skb) then msg7
else enc (make1 (na, pub ska), r1', pk)); in(c,x);
A1: out(c,
if (x = msg8@τ) then
(if (input@A = pub skb) then <msg9@τ,<na,nb>>)
else if (get2_na (dec (x, ska)) = na &&
get2_id (dec (x, ska)) = input@A) then
<enc (make3 (get2_nb (dec (x, ska)), na), r3', input@A),
if (input@A = pub skb) then <na,nb>>); null ) |
let msg1 : message = enc (diff(make1 (na, pub ska), len1), r1, pub skb) in
let msg2 : message = enc (len2, r2, pub ska) in
let msg3 : message = enc (diff(make3 (nb, na), len3), r3, pub skb) in
in(c,x);
B: out(c,
if (x = msg10@τ) then msg11
else if (x = msg12@τ) then empty
else if check_tag (dec (x, skb)) then
enc
(make2 (get1_na (dec (x, skb)), nb, pub skb),
r2',
get1_id (dec (x, skb)))); null

System Empty registered with actions (init).
System NSL registered with actions (init,PUB,A,A1,B).
System NSL_a registered with actions (init,PUB,A,A1,B).
(* ----------------------------------------------------------------------- *)



(* Dependency lemma for all systems. *)
lemma [NSL/left,NSL/right,NSL_a/left,NSL_a/right] depends_A_A1 :
happens(A1) => A < A1.
Goal depends_A_A1 :
happens(A1) => A < A1

Proofs


Proof.
[goal> Focused goal (1/1):
System: 1:NSL/left, 2:NSL/right, 3:NSL_a/left, 4:NSL_a/right
----------------------------------------
happens(A1) => A < A1


intro _.
[> Line 517: (intro _) [goal> Focused goal (1/1):
System: 1:NSL/left, 2:NSL/right, 3:NSL_a/left, 4:NSL_a/right
_: happens(A1)
----------------------------------------
A < A1


project; try
((by use depends_NSL_A_A1 with A1) +
(by use depends_NSL_a_A_A1 with A1)).
[> Line 523: (project;(try (by (have ...)+by (have ...)))) [goal> lemma depends_A_A1 is proved


Qed.
lemma [1:NSL/left, 2:NSL/right, 3:NSL_a/left, 4:NSL_a/right] depends_A_A1 :
happens(A1) => A < A1
Exiting proof mode.



(* Our current implementation of proof-search for bi-deduction cannot
prove that `(frame@t,exec@t)` is bi-deducible (considering e.g.
`NSL_a/left` and `NSL/right` on the right). We expect that this
will be improved in the near future, by improving the inductive
proof heuristic or allowing user control on it.

For now we work around the limitation by proving the following technical
lemma. It encodes a weak form of bi-deducibility as the existence of
an adversarial function to which we explicitly pass the useful outputs
of the CCA oracles. This simple (yet tedious) approach is only possible
because we are in a simple situation where oracle calls can be
performed at the beginning on data that is known in advance. *)
global lemma
[NSL_a/left,NSL/right] deduction_right (t:timestamp[const])
:
Let msg1 = enc(diff(make1(na,pub(ska)),len1),r1,pub skb) in
Let msg2 = enc(len2,r2,pub ska) in
Let msg3 = enc(diff(make3(nb,na),len3),r3,pub skb) in
Let fr =
fun (f: _ -> _ -> _ -> _ -> _ -> _ -> _ ->_ -> message*bool*message) =>
(f (pub skb) msg1 msg2 msg3 ska na nb r3')#1
in
Let ex =
fun (f: _ -> _ -> _ -> _ -> _ -> _ -> _ -> _ -> message*bool*message) =>
(f (pub skb) msg1 msg2 msg3 ska na nb r3')#2
in
Let pk =
fun (f: _ -> _ -> _ -> _ -> _ -> _ -> _ -> _ -> message*bool*message) =>
(f (pub skb) msg1 msg2 msg3 ska na nb r3')#3
in
[happens(t)] -> [t < B] ->
Exists (f:_[adv]),
[f (pub skb) msg1 msg2 msg3 ska na nb r3' =
(frame@t,exec@t,if A<=t then input@A)].
Goal deduction_right :
forall t:timestamp[const, glob],
Let msg1 = enc (diff(make1 (na, pub ska), len1), r1, pub skb) in
Let msg2 = enc (len2, r2, pub ska) in
Let msg3 = enc (diff(make3 (nb, na), len3), r3, pub skb) in
Let fr =
fun (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub skb) msg1 msg2 msg3 ska na nb r3'#1 in
Let ex =
fun (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub skb) msg1 msg2 msg3 ska na nb r3'#2 in
Let pk =
fun (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub skb) msg1 msg2 msg3 ska na nb r3'#3 in
[happens(t)] ->
[t < B] ->
Exists (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message
[adv, glob]),
[f (pub skb) msg1 msg2 msg3 ska na nb r3' =
(frame@t, exec@t, if (A <= t) then input@A)]

Proof.
[goal> Focused goal (1/1):
Systems: left:NSL_a/left, right:NSL/right (same for equivalences)
Variables: t:timestamp[const, glob]
----------------------------------------
Let msg1 = enc (diff(make1 (na, pub ska), len1), r1, pub skb) in
Let msg2 = enc (len2, r2, pub ska) in
Let msg3 = enc (diff(make3 (nb, na), len3), r3, pub skb) in
Let fr =
fun (f:message ->
message ->
message ->
message ->
message -> message -> message -> message -> message * bool * message) =>
f (pub skb) msg1 msg2 msg3 ska na nb r3'#1 in
Let ex =
fun (f:message ->
message ->
message ->
message ->
message -> message -> message -> message -> message * bool * message) =>
f (pub skb) msg1 msg2 msg3 ska na nb r3'#2 in
Let pk =
fun (f:message ->
message ->
message ->
message ->
message -> message -> message -> message -> message * bool * message) =>
f (pub skb) msg1 msg2 msg3 ska na nb r3'#3 in
[happens(t)] ->
[t < B] ->
Exists (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message[adv, glob]),
[f (pub skb) msg1 msg2 msg3 ska na nb r3' =
(frame@t, exec@t, if (A <= t) then input@A)]



intro *.
[> Line 599: (intro *) [goal> Focused goal (1/1):
Systems: left:NSL_a/left, right:NSL/right (same for equivalences)
Variables: t:timestamp[const, glob]
H: [happens(t)]
H0: [t < B]
ex := fun (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub skb) msg1 msg2 msg3 ska na nb r3'#2
fr := fun (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub skb) msg1 msg2 msg3 ska na nb r3'#1
msg1 := enc (diff(make1 (na, pub ska), len1), r1, pub skb)
msg2 := enc (len2, r2, pub ska)
msg3 := enc (diff(make3 (nb, na), len3), r3, pub skb)
pk := fun (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub skb) msg1 msg2 msg3 ska na nb r3'#3
----------------------------------------
Exists (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message[adv, glob]),
[f (pub skb) msg1 msg2 msg3 ska na nb r3' =
(frame@t, exec@t, if (A <= t) then input@A)]



induction t.
[> Line 601: (induction t) [goal> Focused goal (1/5):
Systems: left:NSL_a/left, right:NSL/right (same for equivalences)
Variables:
H: [happens(init)]
H0: [init < B]
ex := fun (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub skb) msg1 msg2 msg3 ska na nb r3'#2
fr := fun (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub skb) msg1 msg2 msg3 ska na nb r3'#1
msg1 := enc (diff(make1 (na, pub ska), len1), r1, pub skb)
msg2 := enc (len2, r2, pub ska)
msg3 := enc (diff(make3 (nb, na), len3), r3, pub skb)
pk := fun (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub skb) msg1 msg2 msg3 ska na nb r3'#3
----------------------------------------
Exists (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message[adv, glob]),
[f (pub skb) msg1 msg2 msg3 ska na nb r3' =
(frame@init, exec@init, if (A <= init) then input@A)]



+ rewrite /frame /exec.
[> Line 603: (rewrite ... ...) [goal> Focused goal (1/5):
Systems: left:NSL_a/left, right:NSL/right (same for equivalences)
Variables:
H: [happens(init)]
H0: [init < B]
ex := fun (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub skb) msg1 msg2 msg3 ska na nb r3'#2
fr := fun (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub skb) msg1 msg2 msg3 ska na nb r3'#1
msg1 := enc (diff(make1 (na, pub ska), len1), r1, pub skb)
msg2 := enc (len2, r2, pub ska)
msg3 := enc (diff(make3 (nb, na), len3), r3, pub skb)
pk := fun (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub skb) msg1 msg2 msg3 ska na nb r3'#3
----------------------------------------
Exists (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message[adv, glob]),
[f (pub skb) msg1 msg2 msg3 ska na nb r3' =
(zero, true, if (A <= init) then input@A)]



exists (fun (a,b,c,d,e,f,g,h:message) => (zero,true,zero)).
[> Line 605: (exists
(fun (a : message, b : message, c : message, d : message,
e : message, f : message, g : message, h : message) =>
(zero, true, zero)))
[goal> Focused goal (1/5):
System: left:NSL_a/left, right:NSL/right (same for equivalences)
Variables:
H: [happens(init)]
H0: [init < B]
ex := fun (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub skb) msg1 msg2 msg3 ska na nb r3'#2
fr := fun (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub skb) msg1 msg2 msg3 ska na nb r3'#1
msg1 := enc (diff(make1 (na, pub ska), len1), r1, pub skb)
msg2 := enc (len2, r2, pub ska)
msg3 := enc (diff(make3 (nb, na), len3), r3, pub skb)
pk := fun (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub skb) msg1 msg2 msg3 ska na nb r3'#3
----------------------------------------
(fun (a,b,c,d,e,f,g,h:message) => (zero, true, zero))
(pub skb)
msg1
msg2
msg3
ska
na
nb
r3' =
(zero, true, if (A <= init) then input@A)


by rewrite if_false.
[> Line 607: by (rewrite ...) [goal> Focused goal (1/4):
Systems: left:NSL_a/left, right:NSL/right (same for equivalences)
Variables:
H: [happens(PUB)]
H0: [PUB < B]
IH: Exists (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message
[adv, glob]),
[f (pub skb) msg1 msg2 msg3 ska na nb r3' =
(frame@pred PUB, exec@pred PUB, if (A <= pred PUB) then input@A)]
ex := fun (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub skb) msg1 msg2 msg3 ska na nb r3'#2
fr := fun (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub skb) msg1 msg2 msg3 ska na nb r3'#1
msg1 := enc (diff(make1 (na, pub ska), len1), r1, pub skb)
msg2 := enc (len2, r2, pub ska)
msg3 := enc (diff(make3 (nb, na), len3), r3, pub skb)
pk := fun (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub skb) msg1 msg2 msg3 ska na nb r3'#3
----------------------------------------
Exists (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message[adv, glob]),
[f (pub skb) msg1 msg2 msg3 ska na nb r3' =
(frame@PUB, exec@PUB, if (A <= PUB) then input@A)]



+ destruct IH.
[> Line 609: (destruct IH) [goal> Focused goal (1/4):
Systems: left:NSL_a/left, right:NSL/right (same for equivalences)
Variables:
f:message ->
message ->
message ->
message ->
message -> message -> message -> message -> message * bool * message
[adv, glob]
H: [happens(PUB)]
H0: [PUB < B]
H1: [f (pub skb) msg1 msg2 msg3 ska na nb r3' =
(frame@pred PUB, exec@pred PUB, if (A <= pred PUB) then input@A)]
ex := fun (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub skb) msg1 msg2 msg3 ska na nb r3'#2
fr := fun (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub skb) msg1 msg2 msg3 ska na nb r3'#1
msg1 := enc (diff(make1 (na, pub ska), len1), r1, pub skb)
msg2 := enc (len2, r2, pub ska)
msg3 := enc (diff(make3 (nb, na), len3), r3, pub skb)
pk := fun (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub skb) msg1 msg2 msg3 ska na nb r3'#3
----------------------------------------
Exists (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message[adv, glob]),
[f (pub skb) msg1 msg2 msg3 ska na nb r3' =
(frame@PUB, exec@PUB, if (A <= PUB) then input@A)]



rewrite /*.
[> Line 611: (rewrite ...) [goal> Focused goal (1/4):
Systems: left:NSL_a/left, right:NSL/right (same for equivalences)
Variables:
f:message ->
message ->
message ->
message ->
message -> message -> message -> message -> message * bool * message
[adv, glob]
H: [happens(PUB)]
H0: [PUB < B]
H1: [f (pub skb) msg1 msg2 msg3 ska na nb r3' =
(frame@pred PUB, exec@pred PUB, if (A <= pred PUB) then input@A)]
ex := fun (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub skb) msg1 msg2 msg3 ska na nb r3'#2
fr := fun (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub skb) msg1 msg2 msg3 ska na nb r3'#1
msg1 := enc (diff(make1 (na, pub ska), len1), r1, pub skb)
msg2 := enc (len2, r2, pub ska)
msg3 := enc (diff(make3 (nb, na), len3), r3, pub skb)
pk := fun (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub skb) msg1 msg2 msg3 ska na nb r3'#3
----------------------------------------
Exists (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message[adv, glob]),
[f
(pub skb)
(enc (diff(make1 (na, pub ska), len1), r1, pub skb))
(enc (len2, r2, pub ska))
(enc (diff(make3 (nb, na), len3), r3, pub skb))
ska
na
nb
r3' =
(<frame@pred PUB,
<of_bool (exec@pred PUB && true),
if (exec@pred PUB && true) then <pub ska,pub skb>>>,
exec@pred PUB && true,
if (A <= PUB) then att (frame@pred A))]



rewrite and_true_r.
[> Line 613: (rewrite ...) [goal> Focused goal (1/4):
Systems: left:NSL_a/left, right:NSL/right (same for equivalences)
Variables:
f:message ->
message ->
message ->
message ->
message -> message -> message -> message -> message * bool * message
[adv, glob]
H: [happens(PUB)]
H0: [PUB < B]
H1: [f (pub skb) msg1 msg2 msg3 ska na nb r3' =
(frame@pred PUB, exec@pred PUB, if (A <= pred PUB) then input@A)]
ex := fun (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub skb) msg1 msg2 msg3 ska na nb r3'#2
fr := fun (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub skb) msg1 msg2 msg3 ska na nb r3'#1
msg1 := enc (diff(make1 (na, pub ska), len1), r1, pub skb)
msg2 := enc (len2, r2, pub ska)
msg3 := enc (diff(make3 (nb, na), len3), r3, pub skb)
pk := fun (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub skb) msg1 msg2 msg3 ska na nb r3'#3
----------------------------------------
Exists (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message[adv, glob]),
[f
(pub skb)
(enc (diff(make1 (na, pub ska), len1), r1, pub skb))
(enc (len2, r2, pub ska))
(enc (diff(make3 (nb, na), len3), r3, pub skb))
ska
na
nb
r3' =
(<frame@pred PUB,
<of_bool (exec@pred PUB),if exec@pred PUB then <pub ska,pub skb>>>,
exec@pred PUB,
if (A <= PUB) then att (frame@pred A))]



exists (fun (p,m1,m2,m3,ka,na,nb,rand3:message) =>
(<fr f, <of_bool (ex f), if ex f then <pub ka, p>>>,
ex f,
pk f)).
[> Line 621: (exists
(fun (p : message, m1 : message, m2 : message, m3 : message,
ka : message, na : message, nb : message, rand3 : message) =>
((pair (fr f) (pair (of_bool (ex f)) (if (ex f) (pair (pub ka)
p) zero))), (ex f), (pk f))))
[goal> Focused goal (1/4):
System: left:NSL_a/left, right:NSL/right (same for equivalences)
Variables:
f:message ->
message ->
message ->
message ->
message -> message -> message -> message -> message * bool * message
[adv, glob]
H: [happens(PUB)]
H0: [PUB < B]
H1: [f (pub skb) msg1 msg2 msg3 ska na nb r3' =
(frame@pred PUB, exec@pred PUB, if (A <= pred PUB) then input@A)]
ex := fun (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub skb) msg1 msg2 msg3 ska na nb r3'#2
fr := fun (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub skb) msg1 msg2 msg3 ska na nb r3'#1
msg1 := enc (diff(make1 (na, pub ska), len1), r1, pub skb)
msg2 := enc (len2, r2, pub ska)
msg3 := enc (diff(make3 (nb, na), len3), r3, pub skb)
pk := fun (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub skb) msg1 msg2 msg3 ska na nb r3'#3
----------------------------------------
(fun (p,m1,m2,m3,ka,na,nb,rand3:message) =>
(<fr f,<of_bool (ex f),if ex f then <pub ka,p>>>, ex f, pk f))
(pub skb)
(enc (diff(make1 (na, pub ska), len1), r1, pub skb))
(enc (len2, r2, pub ska))
(enc (diff(make3 (nb, na), len3), r3, pub skb))
ska
na
nb
r3' =
(<frame@pred PUB,
<of_bool (exec@pred PUB),if exec@pred PUB then <pub ska,pub skb>>>,
exec@pred PUB,
if (A <= PUB) then att (frame@pred A))



assert ((A <= PUB) <=> (A <= pred PUB)) as -> by auto.
[> Line 623: ((have ...); 1: by (auto ...)) [goal> Focused goal (1/4):
System: left:NSL_a/left, right:NSL/right (same for equivalences)
Variables:
f:message ->
message ->
message ->
message ->
message -> message -> message -> message -> message * bool * message
[adv, glob]
H: [happens(PUB)]
H0: [PUB < B]
H1: [f (pub skb) msg1 msg2 msg3 ska na nb r3' =
(frame@pred PUB, exec@pred PUB, if (A <= pred PUB) then input@A)]
ex := fun (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub skb) msg1 msg2 msg3 ska na nb r3'#2
fr := fun (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub skb) msg1 msg2 msg3 ska na nb r3'#1
msg1 := enc (diff(make1 (na, pub ska), len1), r1, pub skb)
msg2 := enc (len2, r2, pub ska)
msg3 := enc (diff(make3 (nb, na), len3), r3, pub skb)
pk := fun (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub skb) msg1 msg2 msg3 ska na nb r3'#3
----------------------------------------
(fun (p,m1,m2,m3,ka,na,nb,rand3:message) =>
(<fr f,<of_bool (ex f),if ex f then <pub ka,p>>>, ex f, pk f))
(pub skb)
(enc (diff(make1 (na, pub ska), len1), r1, pub skb))
(enc (len2, r2, pub ska))
(enc (diff(make3 (nb, na), len3), r3, pub skb))
ska
na
nb
r3' =
(<frame@pred PUB,
<of_bool (exec@pred PUB),if exec@pred PUB then <pub ska,pub skb>>>,
exec@pred PUB,
if (A <= pred PUB) then att (frame@pred A))



reduce.
[> Line 625: (reduce ...) [goal> Focused goal (1/4):
System: left:NSL_a/left, right:NSL/right (same for equivalences)
Variables:
f:message ->
message ->
message ->
message ->
message -> message -> message -> message -> message * bool * message
[adv, glob]
H: [happens(PUB)]
H0: [PUB < B]
H1: [f (pub skb) msg1 msg2 msg3 ska na nb r3' =
(frame@pred PUB, exec@pred PUB, if (A <= pred PUB) then input@A)]
ex := fun (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub skb) msg1 msg2 msg3 ska na nb r3'#2
fr := fun (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub skb) msg1 msg2 msg3 ska na nb r3'#1
msg1 := enc (diff(make1 (na, pub ska), len1), r1, pub skb)
msg2 := enc (len2, r2, pub ska)
msg3 := enc (diff(make3 (nb, na), len3), r3, pub skb)
pk := fun (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub skb) msg1 msg2 msg3 ska na nb r3'#3
----------------------------------------
(<fr f,<of_bool (ex f),if ex f then <pub ska,pub skb>>>, ex f, pk f) =
(<frame@pred PUB,
<of_bool (exec@pred PUB),if exec@pred PUB then <pub ska,pub skb>>>,
exec@pred PUB,
if (A <= pred PUB) then att (frame@pred A))



rewrite /fr /ex /pk /=.
[> Line 627: (rewrite ... ... ... /=) [goal> Focused goal (1/4):
System: left:NSL_a/left, right:NSL/right (same for equivalences)
Variables:
f:message ->
message ->
message ->
message ->
message -> message -> message -> message -> message * bool * message
[adv, glob]
H: [happens(PUB)]
H0: [PUB < B]
H1: [f (pub skb) msg1 msg2 msg3 ska na nb r3' =
(frame@pred PUB, exec@pred PUB, if (A <= pred PUB) then input@A)]
ex := fun (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub skb) msg1 msg2 msg3 ska na nb r3'#2
fr := fun (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub skb) msg1 msg2 msg3 ska na nb r3'#1
msg1 := enc (diff(make1 (na, pub ska), len1), r1, pub skb)
msg2 := enc (len2, r2, pub ska)
msg3 := enc (diff(make3 (nb, na), len3), r3, pub skb)
pk := fun (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub skb) msg1 msg2 msg3 ska na nb r3'#3
----------------------------------------
(<f (pub skb) msg1 msg2 msg3 ska na nb r3'#1,
<of_bool (f (pub skb) msg1 msg2 msg3 ska na nb r3'#2),
if f (pub skb) msg1 msg2 msg3 ska na nb r3'#2 then <pub ska,pub skb>>>,
f (pub skb) msg1 msg2 msg3 ska na nb r3'#2,
f (pub skb) msg1 msg2 msg3 ska na nb r3'#3) =
(<frame@pred PUB,
<of_bool (exec@pred PUB),if exec@pred PUB then <pub ska,pub skb>>>,
exec@pred PUB,
if (A <= pred PUB) then att (frame@pred A))



rewrite H1.
[> Line 629: (rewrite ...) [goal> Focused goal (1/4):
System: left:NSL_a/left, right:NSL/right (same for equivalences)
Variables:
f:message ->
message ->
message ->
message ->
message -> message -> message -> message -> message * bool * message
[adv, glob]
H: [happens(PUB)]
H0: [PUB < B]
H1: [f (pub skb) msg1 msg2 msg3 ska na nb r3' =
(frame@pred PUB, exec@pred PUB, if (A <= pred PUB) then input@A)]
ex := fun (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub skb) msg1 msg2 msg3 ska na nb r3'#2
fr := fun (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub skb) msg1 msg2 msg3 ska na nb r3'#1
msg1 := enc (diff(make1 (na, pub ska), len1), r1, pub skb)
msg2 := enc (len2, r2, pub ska)
msg3 := enc (diff(make3 (nb, na), len3), r3, pub skb)
pk := fun (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub skb) msg1 msg2 msg3 ska na nb r3'#3
----------------------------------------
(<(frame@pred PUB, exec@pred PUB, if (A <= pred PUB) then input@A)#1,
<of_bool
((frame@pred PUB, exec@pred PUB, if (A <= pred PUB) then input@A)#2),
if (frame@pred PUB, exec@pred PUB, if (A <= pred PUB) then input@A)#2 then
<pub ska,pub skb>>>,
(frame@pred PUB, exec@pred PUB, if (A <= pred PUB) then input@A)#2,
(frame@pred PUB, exec@pred PUB, if (A <= pred PUB) then input@A)#3) =
(<frame@pred PUB,
<of_bool (exec@pred PUB),if exec@pred PUB then <pub ska,pub skb>>>,
exec@pred PUB,
if (A <= pred PUB) then att (frame@pred A))



by reduce.
[> Line 631: by (reduce ...) [goal> Focused goal (1/3):
Systems: left:NSL_a/left, right:NSL/right (same for equivalences)
Variables:
H: [happens(A)]
H0: [A < B]
IH: Exists (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message
[adv, glob]),
[f (pub skb) msg1 msg2 msg3 ska na nb r3' =
(frame@pred A, exec@pred A, if (A <= pred A) then input@A)]
ex := fun (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub skb) msg1 msg2 msg3 ska na nb r3'#2
fr := fun (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub skb) msg1 msg2 msg3 ska na nb r3'#1
msg1 := enc (diff(make1 (na, pub ska), len1), r1, pub skb)
msg2 := enc (len2, r2, pub ska)
msg3 := enc (diff(make3 (nb, na), len3), r3, pub skb)
pk := fun (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub skb) msg1 msg2 msg3 ska na nb r3'#3
----------------------------------------
Exists (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message[adv, glob]),
[f (pub skb) msg1 msg2 msg3 ska na nb r3' =
(frame@A, exec@A, if (A <= A) then input@A)]



+ destruct IH.
[> Line 633: (destruct IH) [goal> Focused goal (1/3):
Systems: left:NSL_a/left, right:NSL/right (same for equivalences)
Variables:
f:message ->
message ->
message ->
message ->
message -> message -> message -> message -> message * bool * message
[adv, glob]
H: [happens(A)]
H0: [A < B]
H1: [f (pub skb) msg1 msg2 msg3 ska na nb r3' =
(frame@pred A, exec@pred A, if (A <= pred A) then input@A)]
ex := fun (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub skb) msg1 msg2 msg3 ska na nb r3'#2
fr := fun (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub skb) msg1 msg2 msg3 ska na nb r3'#1
msg1 := enc (diff(make1 (na, pub ska), len1), r1, pub skb)
msg2 := enc (len2, r2, pub ska)
msg3 := enc (diff(make3 (nb, na), len3), r3, pub skb)
pk := fun (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub skb) msg1 msg2 msg3 ska na nb r3'#3
----------------------------------------
Exists (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message[adv, glob]),
[f (pub skb) msg1 msg2 msg3 ska na nb r3' =
(frame@A, exec@A, if (A <= A) then input@A)]



rewrite /frame /exec /output /cond /msg1 /msg3 /input.
[> Line 635: (rewrite ... ... ... ... ... ... ...) [goal> Focused goal (1/3):
Systems: left:NSL_a/left, right:NSL/right (same for equivalences)
Variables:
f:message ->
message ->
message ->
message ->
message -> message -> message -> message -> message * bool * message
[adv, glob]
H: [happens(A)]
H0: [A < B]
H1: [f (pub skb) msg1 msg2 msg3 ska na nb r3' =
(frame@pred A, exec@pred A, if (A <= pred A) then input@A)]
ex := fun (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub skb) msg1 msg2 msg3 ska na nb r3'#2
fr := fun (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub skb) msg1 msg2 msg3 ska na nb r3'#1
msg1 := enc (diff(make1 (na, pub ska), len1), r1, pub skb)
msg2 := enc (len2, r2, pub ska)
msg3 := enc (diff(make3 (nb, na), len3), r3, pub skb)
pk := fun (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub skb) msg1 msg2 msg3 ska na nb r3'#3
----------------------------------------
Exists (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message[adv, glob]),
[f
(pub skb)
(enc (diff(make1 (na, pub ska), len1), r1, pub skb))
msg2
(enc (diff(make3 (nb, na), len3), r3, pub skb))
ska
na
nb
r3' =
(<frame@pred A,
<of_bool (exec@pred A && true),
if (exec@pred A && true) then
(if (att (frame@pred A) = pub skb) then
diff(msg7@A, enc (len1, r1, pub skb))
else enc (make1 (na, pub ska), r1', att (frame@pred A)))>>,
exec@pred A && true,
if (A <= A) then att (frame@pred A))]



rewrite and_true_r.
[> Line 637: (rewrite ...) [goal> Focused goal (1/3):
Systems: left:NSL_a/left, right:NSL/right (same for equivalences)
Variables:
f:message ->
message ->
message ->
message ->
message -> message -> message -> message -> message * bool * message
[adv, glob]
H: [happens(A)]
H0: [A < B]
H1: [f (pub skb) msg1 msg2 msg3 ska na nb r3' =
(frame@pred A, exec@pred A, if (A <= pred A) then input@A)]
ex := fun (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub skb) msg1 msg2 msg3 ska na nb r3'#2
fr := fun (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub skb) msg1 msg2 msg3 ska na nb r3'#1
msg1 := enc (diff(make1 (na, pub ska), len1), r1, pub skb)
msg2 := enc (len2, r2, pub ska)
msg3 := enc (diff(make3 (nb, na), len3), r3, pub skb)
pk := fun (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub skb) msg1 msg2 msg3 ska na nb r3'#3
----------------------------------------
Exists (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message[adv, glob]),
[f
(pub skb)
(enc (diff(make1 (na, pub ska), len1), r1, pub skb))
msg2
(enc (diff(make3 (nb, na), len3), r3, pub skb))
ska
na
nb
r3' =
(<frame@pred A,
<of_bool (exec@pred A),
if exec@pred A then
(if (att (frame@pred A) = pub skb) then
diff(msg7@A, enc (len1, r1, pub skb))
else enc (make1 (na, pub ska), r1', att (frame@pred A)))>>,
exec@pred A,
if (A <= A) then att (frame@pred A))]



exists (fun (p,m1,m2,m3,ka,na,nb,rand3:message) =>
(<fr f,
<of_bool (ex f),
if ex f then
if att (fr f) = pub skb then m1 else
enc(make1(na,pub ska),r1',att (fr f))>>,
ex f,
att (fr f))).
[> Line 653: (exists
(fun (p : message, m1 : message, m2 : message, m3 : message,
ka : message, na : message, nb : message, rand3 : message) =>
((pair (fr f) (pair (of_bool (ex f)) (if (ex f)
(if (= (att (fr f)) (pub skb)) m1
(enc ((make1 (na, (pub ska))), r1', (att (fr f))))) zero))),
(ex f), (att (fr f)))))
[goal> Focused goal (1/3):
System: left:NSL_a/left, right:NSL/right (same for equivalences)
Variables:
f:message ->
message ->
message ->
message ->
message -> message -> message -> message -> message * bool * message
[adv, glob]
H: [happens(A)]
H0: [A < B]
H1: [f (pub skb) msg1 msg2 msg3 ska na nb r3' =
(frame@pred A, exec@pred A, if (A <= pred A) then input@A)]
ex := fun (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub skb) msg1 msg2 msg3 ska na nb r3'#2
fr := fun (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub skb) msg1 msg2 msg3 ska na nb r3'#1
msg1 := enc (diff(make1 (na, pub ska), len1), r1, pub skb)
msg2 := enc (len2, r2, pub ska)
msg3 := enc (diff(make3 (nb, na), len3), r3, pub skb)
pk := fun (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub skb) msg1 msg2 msg3 ska na nb r3'#3
----------------------------------------
(fun (p,m1,m2,m3,ka,na,nb,rand3:message) =>
(<fr f,
<of_bool (ex f),
if ex f then
(if (att (fr f) = pub skb) then m1
else enc (make1 (na, pub ska), r1', att (fr f)))>>,
ex f,
att (fr f)))
(pub skb)
(enc (diff(make1 (na, pub ska), len1), r1, pub skb))
msg2
(enc (diff(make3 (nb, na), len3), r3, pub skb))
ska
na
nb
r3' =
(<frame@pred A,
<of_bool (exec@pred A),
if exec@pred A then
(if (att (frame@pred A) = pub skb) then
diff(msg7@A, enc (len1, r1, pub skb))
else enc (make1 (na, pub ska), r1', att (frame@pred A)))>>,
exec@pred A,
if (A <= A) then att (frame@pred A))



rewrite (if_true (A <= A)); 1: auto.
[> Line 655: ((rewrite ...); 1: (auto ...)) [goal> Focused goal (1/3):
System: left:NSL_a/left, right:NSL/right (same for equivalences)
Variables:
f:message ->
message ->
message ->
message ->
message -> message -> message -> message -> message * bool * message
[adv, glob]
H: [happens(A)]
H0: [A < B]
H1: [f (pub skb) msg1 msg2 msg3 ska na nb r3' =
(frame@pred A, exec@pred A, if (A <= pred A) then input@A)]
ex := fun (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub skb) msg1 msg2 msg3 ska na nb r3'#2
fr := fun (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub skb) msg1 msg2 msg3 ska na nb r3'#1
msg1 := enc (diff(make1 (na, pub ska), len1), r1, pub skb)
msg2 := enc (len2, r2, pub ska)
msg3 := enc (diff(make3 (nb, na), len3), r3, pub skb)
pk := fun (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub skb) msg1 msg2 msg3 ska na nb r3'#3
----------------------------------------
(fun (p,m1,m2,m3,ka,na,nb,rand3:message) =>
(<fr f,
<of_bool (ex f),
if ex f then
(if (att (fr f) = pub skb) then m1
else enc (make1 (na, pub ska), r1', att (fr f)))>>,
ex f,
att (fr f)))
(pub skb)
(enc (diff(make1 (na, pub ska), len1), r1, pub skb))
msg2
(enc (diff(make3 (nb, na), len3), r3, pub skb))
ska
na
nb
r3' =
(<frame@pred A,
<of_bool (exec@pred A),
if exec@pred A then
(if (att (frame@pred A) = pub skb) then
diff(msg7@A, enc (len1, r1, pub skb))
else enc (make1 (na, pub ska), r1', att (frame@pred A)))>>,
exec@pred A,
att (frame@pred A))



rewrite /fr /ex /= H1.
[> Line 657: (rewrite ... ... /= ...) [goal> Focused goal (1/3):
System: left:NSL_a/left, right:NSL/right (same for equivalences)
Variables:
f:message ->
message ->
message ->
message ->
message -> message -> message -> message -> message * bool * message
[adv, glob]
H: [happens(A)]
H0: [A < B]
H1: [f (pub skb) msg1 msg2 msg3 ska na nb r3' =
(frame@pred A, exec@pred A, if (A <= pred A) then input@A)]
ex := fun (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub skb) msg1 msg2 msg3 ska na nb r3'#2
fr := fun (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub skb) msg1 msg2 msg3 ska na nb r3'#1
msg1 := enc (diff(make1 (na, pub ska), len1), r1, pub skb)
msg2 := enc (len2, r2, pub ska)
msg3 := enc (diff(make3 (nb, na), len3), r3, pub skb)
pk := fun (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub skb) msg1 msg2 msg3 ska na nb r3'#3
----------------------------------------
(<(frame@pred A, exec@pred A, if (A <= pred A) then input@A)#1,
<of_bool ((frame@pred A, exec@pred A, if (A <= pred A) then input@A)#2),
if (frame@pred A, exec@pred A, if (A <= pred A) then input@A)#2 then
(if (att ((frame@pred A, exec@pred A, if (A <= pred A) then input@A)#1) =
pub skb) then enc (diff(make1 (na, pub ska), len1), r1, pub skb)
else
enc
(make1 (na, pub ska),
r1',
att ((frame@pred A, exec@pred A, if (A <= pred A) then input@A)#1)))>>,
(frame@pred A, exec@pred A, if (A <= pred A) then input@A)#2,
att ((frame@pred A, exec@pred A, if (A <= pred A) then input@A)#1)) =
(<frame@pred A,
<of_bool (exec@pred A),
if exec@pred A then
(if (att (frame@pred A) = pub skb) then
diff(msg7@A, enc (len1, r1, pub skb))
else enc (make1 (na, pub ska), r1', att (frame@pred A)))>>,
exec@pred A,
att (frame@pred A))



rewrite (if_false (A <= pred A)); 1: auto.
[> Line 659: ((rewrite ...); 1: (auto ...)) [goal> Focused goal (1/3):
System: left:NSL_a/left, right:NSL/right (same for equivalences)
Variables:
f:message ->
message ->
message ->
message ->
message -> message -> message -> message -> message * bool * message
[adv, glob]
H: [happens(A)]
H0: [A < B]
H1: [f (pub skb) msg1 msg2 msg3 ska na nb r3' =
(frame@pred A, exec@pred A, if (A <= pred A) then input@A)]
ex := fun (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub skb) msg1 msg2 msg3 ska na nb r3'#2
fr := fun (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub skb) msg1 msg2 msg3 ska na nb r3'#1
msg1 := enc (diff(make1 (na, pub ska), len1), r1, pub skb)
msg2 := enc (len2, r2, pub ska)
msg3 := enc (diff(make3 (nb, na), len3), r3, pub skb)
pk := fun (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub skb) msg1 msg2 msg3 ska na nb r3'#3
----------------------------------------
(<(frame@pred A, exec@pred A, zero)#1,
<of_bool ((frame@pred A, exec@pred A, zero)#2),
if (frame@pred A, exec@pred A, zero)#2 then
(if (att ((frame@pred A, exec@pred A, zero)#1) = pub skb) then
enc (diff(make1 (na, pub ska), len1), r1, pub skb)
else
enc
(make1 (na, pub ska),
r1',
att ((frame@pred A, exec@pred A, zero)#1)))>>,
(frame@pred A, exec@pred A, zero)#2,
att ((frame@pred A, exec@pred A, zero)#1)) =
(<frame@pred A,
<of_bool (exec@pred A),
if exec@pred A then
(if (att (frame@pred A) = pub skb) then
diff(msg7@A, enc (len1, r1, pub skb))
else enc (make1 (na, pub ska), r1', att (frame@pred A)))>>,
exec@pred A,
att (frame@pred A))



by reduce.
[> Line 661: by (reduce ...) [goal> Focused goal (1/2):
Systems: left:NSL_a/left, right:NSL/right (same for equivalences)
Variables:
H: [happens(A1)]
H0: [A1 < B]
IH: Exists (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message
[adv, glob]),
[f (pub skb) msg1 msg2 msg3 ska na nb r3' =
(frame@pred A1, exec@pred A1, if (A <= pred A1) then input@A)]
ex := fun (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub skb) msg1 msg2 msg3 ska na nb r3'#2
fr := fun (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub skb) msg1 msg2 msg3 ska na nb r3'#1
msg1 := enc (diff(make1 (na, pub ska), len1), r1, pub skb)
msg2 := enc (len2, r2, pub ska)
msg3 := enc (diff(make3 (nb, na), len3), r3, pub skb)
pk := fun (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub skb) msg1 msg2 msg3 ska na nb r3'#3
----------------------------------------
Exists (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message[adv, glob]),
[f (pub skb) msg1 msg2 msg3 ska na nb r3' =
(frame@A1, exec@A1, if (A <= A1) then input@A)]



+ destruct IH.
[> Line 663: (destruct IH) [goal> Focused goal (1/2):
Systems: left:NSL_a/left, right:NSL/right (same for equivalences)
Variables:
f:message ->
message ->
message ->
message ->
message -> message -> message -> message -> message * bool * message
[adv, glob]
H: [happens(A1)]
H0: [A1 < B]
H1: [f (pub skb) msg1 msg2 msg3 ska na nb r3' =
(frame@pred A1, exec@pred A1, if (A <= pred A1) then input@A)]
ex := fun (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub skb) msg1 msg2 msg3 ska na nb r3'#2
fr := fun (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub skb) msg1 msg2 msg3 ska na nb r3'#1
msg1 := enc (diff(make1 (na, pub ska), len1), r1, pub skb)
msg2 := enc (len2, r2, pub ska)
msg3 := enc (diff(make3 (nb, na), len3), r3, pub skb)
pk := fun (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub skb) msg1 msg2 msg3 ska na nb r3'#3
----------------------------------------
Exists (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message[adv, glob]),
[f (pub skb) msg1 msg2 msg3 ska na nb r3' =
(frame@A1, exec@A1, if (A <= A1) then input@A)]



rewrite /frame /exec /output /cond /input /msg8 /msg2 /msg9 /msg3.
[> Line 665: (rewrite ... ... ... ... ... ... ... ... ...) [goal> Focused goal (1/2):
Systems: left:NSL_a/left, right:NSL/right (same for equivalences)
Variables:
f:message ->
message ->
message ->
message ->
message -> message -> message -> message -> message * bool * message
[adv, glob]
H: [happens(A1)]
H0: [A1 < B]
H1: [f (pub skb) msg1 msg2 msg3 ska na nb r3' =
(frame@pred A1, exec@pred A1, if (A <= pred A1) then input@A)]
ex := fun (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub skb) msg1 msg2 msg3 ska na nb r3'#2
fr := fun (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub skb) msg1 msg2 msg3 ska na nb r3'#1
msg1 := enc (diff(make1 (na, pub ska), len1), r1, pub skb)
msg2 := enc (len2, r2, pub ska)
msg3 := enc (diff(make3 (nb, na), len3), r3, pub skb)
pk := fun (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub skb) msg1 msg2 msg3 ska na nb r3'#3
----------------------------------------
Exists (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message[adv, glob]),
[f
(pub skb)
msg1
(enc (len2, r2, pub ska))
(enc (diff(make3 (nb, na), len3), r3, pub skb))
ska
na
nb
r3' =
(<frame@pred A1,
<of_bool (exec@pred A1 && true),
if (exec@pred A1 && true) then
(if (att (frame@pred A1) =
diff(enc (len2, r2, pub ska), enc (len2, r2, pub ska))) then
(if (input@A = pub skb) then
<diff(enc (make3 (nb, na), r3, pub skb),
enc (len3, r3, pub skb)),<na,nb>>)
else if (get2_na (dec (att (frame@pred A1), ska)) = na &&
get2_id (dec (att (frame@pred A1), ska)) = input@A) then
<enc
(make3 (get2_nb (dec (att (frame@pred A1), ska)), na),
r3',
input@A),if (input@A = pub skb) then <na,nb>>)>>,
exec@pred A1 && true,
if (A <= A1) then att (frame@pred A))]



rewrite and_true_r.
[> Line 667: (rewrite ...) [goal> Focused goal (1/2):
Systems: left:NSL_a/left, right:NSL/right (same for equivalences)
Variables:
f:message ->
message ->
message ->
message ->
message -> message -> message -> message -> message * bool * message
[adv, glob]
H: [happens(A1)]
H0: [A1 < B]
H1: [f (pub skb) msg1 msg2 msg3 ska na nb r3' =
(frame@pred A1, exec@pred A1, if (A <= pred A1) then input@A)]
ex := fun (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub skb) msg1 msg2 msg3 ska na nb r3'#2
fr := fun (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub skb) msg1 msg2 msg3 ska na nb r3'#1
msg1 := enc (diff(make1 (na, pub ska), len1), r1, pub skb)
msg2 := enc (len2, r2, pub ska)
msg3 := enc (diff(make3 (nb, na), len3), r3, pub skb)
pk := fun (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub skb) msg1 msg2 msg3 ska na nb r3'#3
----------------------------------------
Exists (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message[adv, glob]),
[f
(pub skb)
msg1
(enc (len2, r2, pub ska))
(enc (diff(make3 (nb, na), len3), r3, pub skb))
ska
na
nb
r3' =
(<frame@pred A1,
<of_bool (exec@pred A1),
if exec@pred A1 then
(if (att (frame@pred A1) =
diff(enc (len2, r2, pub ska), enc (len2, r2, pub ska))) then
(if (input@A = pub skb) then
<diff(enc (make3 (nb, na), r3, pub skb),
enc (len3, r3, pub skb)),<na,nb>>)
else if (get2_na (dec (att (frame@pred A1), ska)) = na &&
get2_id (dec (att (frame@pred A1), ska)) = input@A) then
<enc
(make3 (get2_nb (dec (att (frame@pred A1), ska)), na),
r3',
input@A),if (input@A = pub skb) then <na,nb>>)>>,
exec@pred A1,
if (A <= A1) then att (frame@pred A))]



exists (fun (p,m1,m2,m3,ka,na,nb,rand3:message) =>
(<fr f, <of_bool (ex f), if ex f then
(if att (fr f) = m2 then (if pk f = pub skb then <m3,<na,nb>>) else
if get2_na (dec (att (fr f), ka)) = na &&
get2_id (dec (att (fr f), ka)) = pk f then
<enc
(make3 (get2_nb (dec (att (fr f), ka)), na),
rand3,
pk f),
if pk f = pub skb then <na,nb>>)>>,
ex f,
pk f)).
[> Line 691: (exists
(fun (p : message, m1 : message, m2 : message, m3 : message,
ka : message, na : message, nb : message, rand3 : message) =>
((pair (fr f) (pair (of_bool (ex f)) (if (ex f)
(if (= (att (fr f)) m2) (if (= (pk f) (pub skb)) (pair m3
(pair na nb)) zero)
(if (&& (= (get2_na (dec ((att (fr f)), ka))) na)
(= (get2_id (dec ((att (fr f)), ka))) (pk f)))
(pair (enc ((make3 ((get2_nb (dec ((att (fr f)), ka))), na)),
rand3, (pk f)))
(if (= (pk f) (pub skb)) (pair na nb) zero)) zero)) zero))),
(ex f), (pk f))))
[goal> Focused goal (1/2):
System: left:NSL_a/left, right:NSL/right (same for equivalences)
Variables:
f:message ->
message ->
message ->
message ->
message -> message -> message -> message -> message * bool * message
[adv, glob]
H: [happens(A1)]
H0: [A1 < B]
H1: [f (pub skb) msg1 msg2 msg3 ska na nb r3' =
(frame@pred A1, exec@pred A1, if (A <= pred A1) then input@A)]
ex := fun (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub skb) msg1 msg2 msg3 ska na nb r3'#2
fr := fun (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub skb) msg1 msg2 msg3 ska na nb r3'#1
msg1 := enc (diff(make1 (na, pub ska), len1), r1, pub skb)
msg2 := enc (len2, r2, pub ska)
msg3 := enc (diff(make3 (nb, na), len3), r3, pub skb)
pk := fun (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub skb) msg1 msg2 msg3 ska na nb r3'#3
----------------------------------------
(fun (p,m1,m2,m3,ka,na,nb,rand3:message) =>
(<fr f,
<of_bool (ex f),
if ex f then
(if (att (fr f) = m2) then (if (pk f = pub skb) then <m3,<na,nb>>)
else if (get2_na (dec (att (fr f), ka)) = na &&
get2_id (dec (att (fr f), ka)) = pk f) then
<enc (make3 (get2_nb (dec (att (fr f), ka)), na), rand3, pk f),
if (pk f = pub skb) then <na,nb>>)>>,
ex f,
pk f))
(pub skb)
msg1
(enc (len2, r2, pub ska))
(enc (diff(make3 (nb, na), len3), r3, pub skb))
ska
na
nb
r3' =
(<frame@pred A1,
<of_bool (exec@pred A1),
if exec@pred A1 then
(if (att (frame@pred A1) =
diff(enc (len2, r2, pub ska), enc (len2, r2, pub ska))) then
(if (input@A = pub skb) then
<diff(enc (make3 (nb, na), r3, pub skb), enc (len3, r3, pub skb)),
<na,nb>>)
else if (get2_na (dec (att (frame@pred A1), ska)) = na &&
get2_id (dec (att (frame@pred A1), ska)) = input@A) then
<enc
(make3 (get2_nb (dec (att (frame@pred A1), ska)), na),
r3',
input@A),if (input@A = pub skb) then <na,nb>>)>>,
exec@pred A1,
if (A <= A1) then att (frame@pred A))



assert A < A1 by use depends_A_A1.
[> Line 693: ((have ...); 1: by (have ...)) [goal> Focused goal (1/2):
System: left:NSL_a/left, right:NSL/right (same for equivalences)
Variables:
f:message ->
message ->
message ->
message ->
message -> message -> message -> message -> message * bool * message
[adv, glob]
Clt: A < A1
H: [happens(A1)]
H0: [A1 < B]
H1: [f (pub skb) msg1 msg2 msg3 ska na nb r3' =
(frame@pred A1, exec@pred A1, if (A <= pred A1) then input@A)]
ex := fun (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub skb) msg1 msg2 msg3 ska na nb r3'#2
fr := fun (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub skb) msg1 msg2 msg3 ska na nb r3'#1
msg1 := enc (diff(make1 (na, pub ska), len1), r1, pub skb)
msg2 := enc (len2, r2, pub ska)
msg3 := enc (diff(make3 (nb, na), len3), r3, pub skb)
pk := fun (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub skb) msg1 msg2 msg3 ska na nb r3'#3
----------------------------------------
(fun (p,m1,m2,m3,ka,na,nb,rand3:message) =>
(<fr f,
<of_bool (ex f),
if ex f then
(if (att (fr f) = m2) then (if (pk f = pub skb) then <m3,<na,nb>>)
else if (get2_na (dec (att (fr f), ka)) = na &&
get2_id (dec (att (fr f), ka)) = pk f) then
<enc (make3 (get2_nb (dec (att (fr f), ka)), na), rand3, pk f),
if (pk f = pub skb) then <na,nb>>)>>,
ex f,
pk f))
(pub skb)
msg1
(enc (len2, r2, pub ska))
(enc (diff(make3 (nb, na), len3), r3, pub skb))
ska
na
nb
r3' =
(<frame@pred A1,
<of_bool (exec@pred A1),
if exec@pred A1 then
(if (att (frame@pred A1) =
diff(enc (len2, r2, pub ska), enc (len2, r2, pub ska))) then
(if (input@A = pub skb) then
<diff(enc (make3 (nb, na), r3, pub skb), enc (len3, r3, pub skb)),
<na,nb>>)
else if (get2_na (dec (att (frame@pred A1), ska)) = na &&
get2_id (dec (att (frame@pred A1), ska)) = input@A) then
<enc
(make3 (get2_nb (dec (att (frame@pred A1), ska)), na),
r3',
input@A),if (input@A = pub skb) then <na,nb>>)>>,
exec@pred A1,
if (A <= A1) then att (frame@pred A))



assert (A <= A1) <=> (A <= pred A1) as -> by auto.
[> Line 695: ((have ...); 1: by (auto ...)) [goal> Focused goal (1/2):
System: left:NSL_a/left, right:NSL/right (same for equivalences)
Variables:
f:message ->
message ->
message ->
message ->
message -> message -> message -> message -> message * bool * message
[adv, glob]
Clt: A < A1
H: [happens(A1)]
H0: [A1 < B]
H1: [f (pub skb) msg1 msg2 msg3 ska na nb r3' =
(frame@pred A1, exec@pred A1, if (A <= pred A1) then input@A)]
ex := fun (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub skb) msg1 msg2 msg3 ska na nb r3'#2
fr := fun (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub skb) msg1 msg2 msg3 ska na nb r3'#1
msg1 := enc (diff(make1 (na, pub ska), len1), r1, pub skb)
msg2 := enc (len2, r2, pub ska)
msg3 := enc (diff(make3 (nb, na), len3), r3, pub skb)
pk := fun (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub skb) msg1 msg2 msg3 ska na nb r3'#3
----------------------------------------
(fun (p,m1,m2,m3,ka,na,nb,rand3:message) =>
(<fr f,
<of_bool (ex f),
if ex f then
(if (att (fr f) = m2) then (if (pk f = pub skb) then <m3,<na,nb>>)
else if (get2_na (dec (att (fr f), ka)) = na &&
get2_id (dec (att (fr f), ka)) = pk f) then
<enc (make3 (get2_nb (dec (att (fr f), ka)), na), rand3, pk f),
if (pk f = pub skb) then <na,nb>>)>>,
ex f,
pk f))
(pub skb)
msg1
(enc (len2, r2, pub ska))
(enc (diff(make3 (nb, na), len3), r3, pub skb))
ska
na
nb
r3' =
(<frame@pred A1,
<of_bool (exec@pred A1),
if exec@pred A1 then
(if (att (frame@pred A1) =
diff(enc (len2, r2, pub ska), enc (len2, r2, pub ska))) then
(if (input@A = pub skb) then
<diff(enc (make3 (nb, na), r3, pub skb), enc (len3, r3, pub skb)),
<na,nb>>)
else if (get2_na (dec (att (frame@pred A1), ska)) = na &&
get2_id (dec (att (frame@pred A1), ska)) = input@A) then
<enc
(make3 (get2_nb (dec (att (frame@pred A1), ska)), na),
r3',
input@A),if (input@A = pub skb) then <na,nb>>)>>,
exec@pred A1,
if (A <= pred A1) then att (frame@pred A))



rewrite /fr /ex /pk /= H1 /input.
[> Line 697: (rewrite ... ... ... /= ... ...) [goal> Focused goal (1/2):
System: left:NSL_a/left, right:NSL/right (same for equivalences)
Variables:
f:message ->
message ->
message ->
message ->
message -> message -> message -> message -> message * bool * message
[adv, glob]
Clt: A < A1
H: [happens(A1)]
H0: [A1 < B]
H1: [f (pub skb) msg1 msg2 msg3 ska na nb r3' =
(frame@pred A1, exec@pred A1, if (A <= pred A1) then input@A)]
ex := fun (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub skb) msg1 msg2 msg3 ska na nb r3'#2
fr := fun (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub skb) msg1 msg2 msg3 ska na nb r3'#1
msg1 := enc (diff(make1 (na, pub ska), len1), r1, pub skb)
msg2 := enc (len2, r2, pub ska)
msg3 := enc (diff(make3 (nb, na), len3), r3, pub skb)
pk := fun (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub skb) msg1 msg2 msg3 ska na nb r3'#3
----------------------------------------
(<(frame@pred A1, exec@pred A1, if (A <= pred A1) then att (frame@pred A))#1,
<of_bool
((frame@pred A1,
exec@pred A1,
if (A <= pred A1) then att (frame@pred A))#2),
if (frame@pred A1,
exec@pred A1,
if (A <= pred A1) then att (frame@pred A))#2 then
(if (att
((frame@pred A1,
exec@pred A1,
if (A <= pred A1) then att (frame@pred A))#1) =
enc (len2, r2, pub ska)) then
(if ((frame@pred A1,
exec@pred A1,
if (A <= pred A1) then att (frame@pred A))#3 =
pub skb) then
<enc (diff(make3 (nb, na), len3), r3, pub skb),<na,nb>>)
else if (get2_na
(dec
(att
((frame@pred A1,
exec@pred A1,
if (A <= pred A1) then att (frame@pred A))#1),
ska)) =
na &&
get2_id
(dec
(att
((frame@pred A1,
exec@pred A1,
if (A <= pred A1) then att (frame@pred A))#1),
ska)) =
(frame@pred A1,
exec@pred A1,
if (A <= pred A1) then att (frame@pred A))#3) then
<enc
(make3
(get2_nb
(dec
(att
((frame@pred A1,
exec@pred A1,
if (A <= pred A1) then att (frame@pred A))#1),
ska)),
na),
r3',
(frame@pred A1,
exec@pred A1,
if (A <= pred A1) then att (frame@pred A))#3),
if ((frame@pred A1,
exec@pred A1,
if (A <= pred A1) then att (frame@pred A))#3 =
pub skb) then <na,nb>>)>>,
(frame@pred A1, exec@pred A1, if (A <= pred A1) then att (frame@pred A))#2,
(frame@pred A1, exec@pred A1, if (A <= pred A1) then att (frame@pred A))#3) =
(<frame@pred A1,
<of_bool (exec@pred A1),
if exec@pred A1 then
(if (att (frame@pred A1) =
diff(enc (len2, r2, pub ska), enc (len2, r2, pub ska))) then
(if (att (frame@pred A) = pub skb) then
<diff(enc (make3 (nb, na), r3, pub skb), enc (len3, r3, pub skb)),
<na,nb>>)
else if (get2_na (dec (att (frame@pred A1), ska)) = na &&
get2_id (dec (att (frame@pred A1), ska)) = att (frame@pred A))
then
<enc
(make3 (get2_nb (dec (att (frame@pred A1), ska)), na),
r3',
att (frame@pred A)),
if (att (frame@pred A) = pub skb) then <na,nb>>)>>,
exec@pred A1,
if (A <= pred A1) then att (frame@pred A))


reduce. [> Line 697: (reduce ...) [goal> Focused goal (1/2):
System: left:NSL_a/left, right:NSL/right (same for equivalences)
Variables:
f:message ->
message ->
message ->
message ->
message -> message -> message -> message -> message * bool * message
[adv, glob]
Clt: A < A1
H: [happens(A1)]
H0: [A1 < B]
H1: [f (pub skb) msg1 msg2 msg3 ska na nb r3' =
(frame@pred A1, exec@pred A1, if (A <= pred A1) then input@A)]
ex := fun (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub skb) msg1 msg2 msg3 ska na nb r3'#2
fr := fun (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub skb) msg1 msg2 msg3 ska na nb r3'#1
msg1 := enc (diff(make1 (na, pub ska), len1), r1, pub skb)
msg2 := enc (len2, r2, pub ska)
msg3 := enc (diff(make3 (nb, na), len3), r3, pub skb)
pk := fun (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub skb) msg1 msg2 msg3 ska na nb r3'#3
----------------------------------------
(<frame@pred A1,
<of_bool (exec@pred A1),
if exec@pred A1 then
(if (att (frame@pred A1) = enc (len2, r2, pub ska)) then
(if (if (A <= pred A1) then att (frame@pred A) = pub skb) then
<enc (diff(make3 (nb, na), len3), r3, pub skb),<na,nb>>)
else if (get2_na (dec (att (frame@pred A1), ska)) = na &&
get2_id (dec (att (frame@pred A1), ska)) =
if (A <= pred A1) then att (frame@pred A)) then
<enc
(make3 (get2_nb (dec (att (frame@pred A1), ska)), na),
r3',
if (A <= pred A1) then att (frame@pred A)),
if (if (A <= pred A1) then att (frame@pred A) = pub skb) then
<na,nb>>)>>,
exec@pred A1,
if (A <= pred A1) then att (frame@pred A)) =
(<frame@pred A1,
<of_bool (exec@pred A1),
if exec@pred A1 then
(if (att (frame@pred A1) =
diff(enc (len2, r2, pub ska), enc (len2, r2, pub ska))) then
(if (att (frame@pred A) = pub skb) then
<diff(enc (make3 (nb, na), r3, pub skb), enc (len3, r3, pub skb)),
<na,nb>>)
else if (get2_na (dec (att (frame@pred A1), ska)) = na &&
get2_id (dec (att (frame@pred A1), ska)) = att (frame@pred A))
then
<enc
(make3 (get2_nb (dec (att (frame@pred A1), ska)), na),
r3',
att (frame@pred A)),
if (att (frame@pred A) = pub skb) then <na,nb>>)>>,
exec@pred A1,
if (A <= pred A1) then att (frame@pred A))


reduce ~flags:[diffr]. [> Line 697: (reduce ...) [goal> Focused goal (1/2):
System: left:NSL_a/left, right:NSL/right (same for equivalences)
Variables:
f:message ->
message ->
message ->
message ->
message -> message -> message -> message -> message * bool * message
[adv, glob]
Clt: A < A1
H: [happens(A1)]
H0: [A1 < B]
H1: [f (pub skb) msg1 msg2 msg3 ska na nb r3' =
(frame@pred A1, exec@pred A1, if (A <= pred A1) then input@A)]
ex := fun (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub skb) msg1 msg2 msg3 ska na nb r3'#2
fr := fun (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub skb) msg1 msg2 msg3 ska na nb r3'#1
msg1 := enc (diff(make1 (na, pub ska), len1), r1, pub skb)
msg2 := enc (len2, r2, pub ska)
msg3 := enc (diff(make3 (nb, na), len3), r3, pub skb)
pk := fun (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub skb) msg1 msg2 msg3 ska na nb r3'#3
----------------------------------------
(<frame@pred A1,
<of_bool (exec@pred A1),
if exec@pred A1 then
(if (att (frame@pred A1) = enc (len2, r2, pub ska)) then
(if (if (A <= pred A1) then att (frame@pred A) = pub skb) then
<enc (diff(make3 (nb, na), len3), r3, pub skb),<na,nb>>)
else if (get2_na (dec (att (frame@pred A1), ska)) = na &&
get2_id (dec (att (frame@pred A1), ska)) =
if (A <= pred A1) then att (frame@pred A)) then
<enc
(make3 (get2_nb (dec (att (frame@pred A1), ska)), na),
r3',
if (A <= pred A1) then att (frame@pred A)),
if (if (A <= pred A1) then att (frame@pred A) = pub skb) then
<na,nb>>)>>,
exec@pred A1,
if (A <= pred A1) then att (frame@pred A)) =
(<frame@pred A1,
<of_bool (exec@pred A1),
if exec@pred A1 then
(if (att (frame@pred A1) = enc (len2, r2, pub ska)) then
(if (att (frame@pred A) = pub skb) then
<enc (diff(make3 (nb, na), len3), r3, pub skb),<na,nb>>)
else if (get2_na (dec (att (frame@pred A1), ska)) = na &&
get2_id (dec (att (frame@pred A1), ska)) = att (frame@pred A))
then
<enc
(make3 (get2_nb (dec (att (frame@pred A1), ska)), na),
r3',
att (frame@pred A)),
if (att (frame@pred A) = pub skb) then <na,nb>>)>>,
exec@pred A1,
if (A <= pred A1) then att (frame@pred A))



by rewrite (if_true (A <= pred A1)).
[> Line 699: by (rewrite ...) [goal> Focused goal (1/1):
Systems: left:NSL_a/left, right:NSL/right (same for equivalences)
Variables:
H: [happens(B)]
H0: [B < B]
IH: Exists (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message
[adv, glob]),
[f (pub skb) msg1 msg2 msg3 ska na nb r3' =
(frame@pred B, exec@pred B, if (A <= pred B) then input@A)]
ex := fun (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub skb) msg1 msg2 msg3 ska na nb r3'#2
fr := fun (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub skb) msg1 msg2 msg3 ska na nb r3'#1
msg1 := enc (diff(make1 (na, pub ska), len1), r1, pub skb)
msg2 := enc (len2, r2, pub ska)
msg3 := enc (diff(make3 (nb, na), len3), r3, pub skb)
pk := fun (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub skb) msg1 msg2 msg3 ska na nb r3'#3
----------------------------------------
Exists (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message[adv, glob]),
[f (pub skb) msg1 msg2 msg3 ska na nb r3' =
(frame@B, exec@B, if (A <= B) then input@A)]



+ by rewrite lt_irrefl in H0.
[> Line 701: by (rewrite ... in H0) [goal> lemma deduction_right is proved


Qed.
global lemma [left:NSL_a/left, right:NSL/right (same for equivalences)] deduction_right :
Forall (t:timestamp[const, glob]),
Let msg1 = enc (diff(make1 (na, pub ska), len1), r1, pub skb) in
Let msg2 = enc (len2, r2, pub ska) in
Let msg3 = enc (diff(make3 (nb, na), len3), r3, pub skb) in
Let fr =
fun (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub skb) msg1 msg2 msg3 ska na nb r3'#1 in
Let ex =
fun (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub skb) msg1 msg2 msg3 ska na nb r3'#2 in
Let pk =
fun (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub skb) msg1 msg2 msg3 ska na nb r3'#3 in
[happens(t)] ->
[t < B] ->
Exists (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message
[adv, glob]),
[f (pub skb) msg1 msg2 msg3 ska na nb r3' =
(frame@t, exec@t, if (A <= t) then input@A)]
Exiting proof mode.



(* Similar to deduction_right but for NSL/left and NSLFixedka/left.
Better multi-system reasoning in Squirrel should allow to
merge the two lemmas. *)
global lemma [NSL/left,NSL_a/left] deduction_left (t:timestamp[const]) :
Let msg1 = enc(make1(na,pub(ska)),r1,pub skb) in
Let msg2 = enc(diff((make2(na, nb, pub skb)),len2),r2,pub ska) in
Let msg3 = enc(make3(nb,na),r3,pub skb) in
Let fr =
fun (f: _ -> _ -> _ -> _ -> _ -> _ -> _ -> message*bool*message) =>
(f (pub ska) msg1 msg2 msg3 skb nb r2')#1
in
Let ex =
fun (f: _ -> _ -> _ -> _ -> _ -> _ -> _ -> message*bool*message) =>
(f (pub ska) msg1 msg2 msg3 skb nb r2')#2
in
Let pk =
fun (f: _ -> _ -> _ -> _ -> _ -> _ -> _ -> message*bool*message) =>
(f (pub ska) msg1 msg2 msg3 skb nb r2')#3
in
[happens(t)] -> [t < A1] ->
Exists (f:_[adv]),
[f (pub ska) msg1 msg2 msg3 skb nb r2' =
(frame@t,exec@t,if A<=t then input@A)].
Goal deduction_left :
forall t:timestamp[const, glob],
Let msg1 = enc (make1 (na, pub ska), r1, pub skb) in
Let msg2 = enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska) in
Let msg3 = enc (make3 (nb, na), r3, pub skb) in
Let fr =
fun (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub ska) msg1 msg2 msg3 skb nb r2'#1 in
Let ex =
fun (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub ska) msg1 msg2 msg3 skb nb r2'#2 in
Let pk =
fun (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub ska) msg1 msg2 msg3 skb nb r2'#3 in
[happens(t)] ->
[t < A1] ->
Exists (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message
[adv, glob]),
[f (pub ska) msg1 msg2 msg3 skb nb r2' =
(frame@t, exec@t, if (A <= t) then input@A)]

Proof.
[goal> Focused goal (1/1):
Systems: left:NSL/left, right:NSL_a/left (same for equivalences)
Variables: t:timestamp[const, glob]
----------------------------------------
Let msg1 = enc (make1 (na, pub ska), r1, pub skb) in
Let msg2 = enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska) in
Let msg3 = enc (make3 (nb, na), r3, pub skb) in
Let fr =
fun (f:message ->
message ->
message ->
message -> message -> message -> message -> message * bool * message) =>
f (pub ska) msg1 msg2 msg3 skb nb r2'#1 in
Let ex =
fun (f:message ->
message ->
message ->
message -> message -> message -> message -> message * bool * message) =>
f (pub ska) msg1 msg2 msg3 skb nb r2'#2 in
Let pk =
fun (f:message ->
message ->
message ->
message -> message -> message -> message -> message * bool * message) =>
f (pub ska) msg1 msg2 msg3 skb nb r2'#3 in
[happens(t)] ->
[t < A1] ->
Exists (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message[adv, glob]),
[f (pub ska) msg1 msg2 msg3 skb nb r2' =
(frame@t, exec@t, if (A <= t) then input@A)]



intro *.
[> Line 755: (intro *) [goal> Focused goal (1/1):
Systems: left:NSL/left, right:NSL_a/left (same for equivalences)
Variables: t:timestamp[const, glob]
H: [happens(t)]
H0: [t < A1]
ex := fun (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub ska) msg1 msg2 msg3 skb nb r2'#2
fr := fun (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub ska) msg1 msg2 msg3 skb nb r2'#1
msg1 := enc (make1 (na, pub ska), r1, pub skb)
msg2 := enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska)
msg3 := enc (make3 (nb, na), r3, pub skb)
pk := fun (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub ska) msg1 msg2 msg3 skb nb r2'#3
----------------------------------------
Exists (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message[adv, glob]),
[f (pub ska) msg1 msg2 msg3 skb nb r2' =
(frame@t, exec@t, if (A <= t) then input@A)]



induction t.
[> Line 757: (induction t) [goal> Focused goal (1/5):
Systems: left:NSL/left, right:NSL_a/left (same for equivalences)
Variables:
H: [happens(init)]
H0: [init < A1]
ex := fun (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub ska) msg1 msg2 msg3 skb nb r2'#2
fr := fun (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub ska) msg1 msg2 msg3 skb nb r2'#1
msg1 := enc (make1 (na, pub ska), r1, pub skb)
msg2 := enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska)
msg3 := enc (make3 (nb, na), r3, pub skb)
pk := fun (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub ska) msg1 msg2 msg3 skb nb r2'#3
----------------------------------------
Exists (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message[adv, glob]),
[f (pub ska) msg1 msg2 msg3 skb nb r2' =
(frame@init, exec@init, if (A <= init) then input@A)]



+ rewrite /frame /exec.
[> Line 759: (rewrite ... ...) [goal> Focused goal (1/5):
Systems: left:NSL/left, right:NSL_a/left (same for equivalences)
Variables:
H: [happens(init)]
H0: [init < A1]
ex := fun (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub ska) msg1 msg2 msg3 skb nb r2'#2
fr := fun (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub ska) msg1 msg2 msg3 skb nb r2'#1
msg1 := enc (make1 (na, pub ska), r1, pub skb)
msg2 := enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska)
msg3 := enc (make3 (nb, na), r3, pub skb)
pk := fun (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub ska) msg1 msg2 msg3 skb nb r2'#3
----------------------------------------
Exists (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message[adv, glob]),
[f (pub ska) msg1 msg2 msg3 skb nb r2' =
(zero, true, if (A <= init) then input@A)]



exists (fun (a,b,c,d,e,f,g:message) => (zero,true,zero)).
[> Line 761: (exists
(fun (a : message, b : message, c : message, d : message,
e : message, f : message, g : message) =>
(zero, true, zero)))
[goal> Focused goal (1/5):
System: left:NSL/left, right:NSL_a/left (same for equivalences)
Variables:
H: [happens(init)]
H0: [init < A1]
ex := fun (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub ska) msg1 msg2 msg3 skb nb r2'#2
fr := fun (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub ska) msg1 msg2 msg3 skb nb r2'#1
msg1 := enc (make1 (na, pub ska), r1, pub skb)
msg2 := enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska)
msg3 := enc (make3 (nb, na), r3, pub skb)
pk := fun (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub ska) msg1 msg2 msg3 skb nb r2'#3
----------------------------------------
(fun (a,b,c,d,e,f,g:message) => (zero, true, zero))
(pub ska)
msg1
msg2
msg3
skb
nb
r2' =
(zero, true, if (A <= init) then input@A)


by rewrite if_false.
[> Line 763: by (rewrite ...) [goal> Focused goal (1/4):
Systems: left:NSL/left, right:NSL_a/left (same for equivalences)
Variables:
H: [happens(PUB)]
H0: [PUB < A1]
IH: Exists (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message
[adv, glob]),
[f (pub ska) msg1 msg2 msg3 skb nb r2' =
(frame@pred PUB, exec@pred PUB, if (A <= pred PUB) then input@A)]
ex := fun (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub ska) msg1 msg2 msg3 skb nb r2'#2
fr := fun (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub ska) msg1 msg2 msg3 skb nb r2'#1
msg1 := enc (make1 (na, pub ska), r1, pub skb)
msg2 := enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska)
msg3 := enc (make3 (nb, na), r3, pub skb)
pk := fun (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub ska) msg1 msg2 msg3 skb nb r2'#3
----------------------------------------
Exists (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message[adv, glob]),
[f (pub ska) msg1 msg2 msg3 skb nb r2' =
(frame@PUB, exec@PUB, if (A <= PUB) then input@A)]



+ destruct IH.
[> Line 765: (destruct IH) [goal> Focused goal (1/4):
Systems: left:NSL/left, right:NSL_a/left (same for equivalences)
Variables:
f:message ->
message ->
message ->
message -> message -> message -> message -> message * bool * message
[adv, glob]
H: [happens(PUB)]
H0: [PUB < A1]
H1: [f (pub ska) msg1 msg2 msg3 skb nb r2' =
(frame@pred PUB, exec@pred PUB, if (A <= pred PUB) then input@A)]
ex := fun (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub ska) msg1 msg2 msg3 skb nb r2'#2
fr := fun (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub ska) msg1 msg2 msg3 skb nb r2'#1
msg1 := enc (make1 (na, pub ska), r1, pub skb)
msg2 := enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska)
msg3 := enc (make3 (nb, na), r3, pub skb)
pk := fun (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub ska) msg1 msg2 msg3 skb nb r2'#3
----------------------------------------
Exists (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message[adv, glob]),
[f (pub ska) msg1 msg2 msg3 skb nb r2' =
(frame@PUB, exec@PUB, if (A <= PUB) then input@A)]



rewrite /*.
[> Line 767: (rewrite ...) [goal> Focused goal (1/4):
Systems: left:NSL/left, right:NSL_a/left (same for equivalences)
Variables:
f:message ->
message ->
message ->
message -> message -> message -> message -> message * bool * message
[adv, glob]
H: [happens(PUB)]
H0: [PUB < A1]
H1: [f (pub ska) msg1 msg2 msg3 skb nb r2' =
(frame@pred PUB, exec@pred PUB, if (A <= pred PUB) then input@A)]
ex := fun (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub ska) msg1 msg2 msg3 skb nb r2'#2
fr := fun (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub ska) msg1 msg2 msg3 skb nb r2'#1
msg1 := enc (make1 (na, pub ska), r1, pub skb)
msg2 := enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska)
msg3 := enc (make3 (nb, na), r3, pub skb)
pk := fun (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub ska) msg1 msg2 msg3 skb nb r2'#3
----------------------------------------
Exists (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message[adv, glob]),
[f
(pub ska)
(enc (make1 (na, pub ska), r1, pub skb))
(enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska))
(enc (make3 (nb, na), r3, pub skb))
skb
nb
r2' =
(<frame@pred PUB,
<of_bool (exec@pred PUB && true),
if (exec@pred PUB && true) then <pub ska,pub skb>>>,
exec@pred PUB && true,
if (A <= PUB) then att (frame@pred A))]



rewrite and_true_r.
[> Line 769: (rewrite ...) [goal> Focused goal (1/4):
Systems: left:NSL/left, right:NSL_a/left (same for equivalences)
Variables:
f:message ->
message ->
message ->
message -> message -> message -> message -> message * bool * message
[adv, glob]
H: [happens(PUB)]
H0: [PUB < A1]
H1: [f (pub ska) msg1 msg2 msg3 skb nb r2' =
(frame@pred PUB, exec@pred PUB, if (A <= pred PUB) then input@A)]
ex := fun (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub ska) msg1 msg2 msg3 skb nb r2'#2
fr := fun (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub ska) msg1 msg2 msg3 skb nb r2'#1
msg1 := enc (make1 (na, pub ska), r1, pub skb)
msg2 := enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska)
msg3 := enc (make3 (nb, na), r3, pub skb)
pk := fun (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub ska) msg1 msg2 msg3 skb nb r2'#3
----------------------------------------
Exists (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message[adv, glob]),
[f
(pub ska)
(enc (make1 (na, pub ska), r1, pub skb))
(enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska))
(enc (make3 (nb, na), r3, pub skb))
skb
nb
r2' =
(<frame@pred PUB,
<of_bool (exec@pred PUB),if exec@pred PUB then <pub ska,pub skb>>>,
exec@pred PUB,
if (A <= PUB) then att (frame@pred A))]



exists (fun (p,m1,m2,m3,kb,nonceb,rand2:message) =>
(<fr f, <of_bool (ex f), if ex f then <p, pub kb>>>, ex f, pk f)).
[> Line 773: (exists
(fun (p : message, m1 : message, m2 : message, m3 : message,
kb : message, nonceb : message, rand2 : message) =>
((pair (fr f) (pair (of_bool (ex f)) (if (ex f) (pair p
(pub kb)) zero))), (ex f), (pk f))))
[goal> Focused goal (1/4):
System: left:NSL/left, right:NSL_a/left (same for equivalences)
Variables:
f:message ->
message ->
message ->
message -> message -> message -> message -> message * bool * message
[adv, glob]
H: [happens(PUB)]
H0: [PUB < A1]
H1: [f (pub ska) msg1 msg2 msg3 skb nb r2' =
(frame@pred PUB, exec@pred PUB, if (A <= pred PUB) then input@A)]
ex := fun (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub ska) msg1 msg2 msg3 skb nb r2'#2
fr := fun (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub ska) msg1 msg2 msg3 skb nb r2'#1
msg1 := enc (make1 (na, pub ska), r1, pub skb)
msg2 := enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska)
msg3 := enc (make3 (nb, na), r3, pub skb)
pk := fun (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub ska) msg1 msg2 msg3 skb nb r2'#3
----------------------------------------
(fun (p,m1,m2,m3,kb,nonceb,rand2:message) =>
(<fr f,<of_bool (ex f),if ex f then <p,pub kb>>>, ex f, pk f))
(pub ska)
(enc (make1 (na, pub ska), r1, pub skb))
(enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska))
(enc (make3 (nb, na), r3, pub skb))
skb
nb
r2' =
(<frame@pred PUB,
<of_bool (exec@pred PUB),if exec@pred PUB then <pub ska,pub skb>>>,
exec@pred PUB,
if (A <= PUB) then att (frame@pred A))



assert (A <= PUB) <=> (A <= pred PUB) as -> by auto.
[> Line 775: ((have ...); 1: by (auto ...)) [goal> Focused goal (1/4):
System: left:NSL/left, right:NSL_a/left (same for equivalences)
Variables:
f:message ->
message ->
message ->
message -> message -> message -> message -> message * bool * message
[adv, glob]
H: [happens(PUB)]
H0: [PUB < A1]
H1: [f (pub ska) msg1 msg2 msg3 skb nb r2' =
(frame@pred PUB, exec@pred PUB, if (A <= pred PUB) then input@A)]
ex := fun (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub ska) msg1 msg2 msg3 skb nb r2'#2
fr := fun (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub ska) msg1 msg2 msg3 skb nb r2'#1
msg1 := enc (make1 (na, pub ska), r1, pub skb)
msg2 := enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska)
msg3 := enc (make3 (nb, na), r3, pub skb)
pk := fun (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub ska) msg1 msg2 msg3 skb nb r2'#3
----------------------------------------
(fun (p,m1,m2,m3,kb,nonceb,rand2:message) =>
(<fr f,<of_bool (ex f),if ex f then <p,pub kb>>>, ex f, pk f))
(pub ska)
(enc (make1 (na, pub ska), r1, pub skb))
(enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska))
(enc (make3 (nb, na), r3, pub skb))
skb
nb
r2' =
(<frame@pred PUB,
<of_bool (exec@pred PUB),if exec@pred PUB then <pub ska,pub skb>>>,
exec@pred PUB,
if (A <= pred PUB) then att (frame@pred A))



by rewrite /fr /ex /pk /= H1.
[> Line 777: by (rewrite ... ... ... /= ...) [goal> Focused goal (1/3):
Systems: left:NSL/left, right:NSL_a/left (same for equivalences)
Variables:
H: [happens(A)]
H0: [A < A1]
IH: Exists (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message
[adv, glob]),
[f (pub ska) msg1 msg2 msg3 skb nb r2' =
(frame@pred A, exec@pred A, if (A <= pred A) then input@A)]
ex := fun (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub ska) msg1 msg2 msg3 skb nb r2'#2
fr := fun (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub ska) msg1 msg2 msg3 skb nb r2'#1
msg1 := enc (make1 (na, pub ska), r1, pub skb)
msg2 := enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska)
msg3 := enc (make3 (nb, na), r3, pub skb)
pk := fun (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub ska) msg1 msg2 msg3 skb nb r2'#3
----------------------------------------
Exists (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message[adv, glob]),
[f (pub ska) msg1 msg2 msg3 skb nb r2' =
(frame@A, exec@A, if (A <= A) then input@A)]



+ destruct IH.
[> Line 779: (destruct IH) [goal> Focused goal (1/3):
Systems: left:NSL/left, right:NSL_a/left (same for equivalences)
Variables:
f:message ->
message ->
message ->
message -> message -> message -> message -> message * bool * message
[adv, glob]
H: [happens(A)]
H0: [A < A1]
H1: [f (pub ska) msg1 msg2 msg3 skb nb r2' =
(frame@pred A, exec@pred A, if (A <= pred A) then input@A)]
ex := fun (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub ska) msg1 msg2 msg3 skb nb r2'#2
fr := fun (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub ska) msg1 msg2 msg3 skb nb r2'#1
msg1 := enc (make1 (na, pub ska), r1, pub skb)
msg2 := enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska)
msg3 := enc (make3 (nb, na), r3, pub skb)
pk := fun (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub ska) msg1 msg2 msg3 skb nb r2'#3
----------------------------------------
Exists (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message[adv, glob]),
[f (pub ska) msg1 msg2 msg3 skb nb r2' =
(frame@A, exec@A, if (A <= A) then input@A)]



rewrite /frame /exec /output /cond /msg1 /msg3.
[> Line 781: (rewrite ... ... ... ... ... ...) [goal> Focused goal (1/3):
Systems: left:NSL/left, right:NSL_a/left (same for equivalences)
Variables:
f:message ->
message ->
message ->
message -> message -> message -> message -> message * bool * message
[adv, glob]
H: [happens(A)]
H0: [A < A1]
H1: [f (pub ska) msg1 msg2 msg3 skb nb r2' =
(frame@pred A, exec@pred A, if (A <= pred A) then input@A)]
ex := fun (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub ska) msg1 msg2 msg3 skb nb r2'#2
fr := fun (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub ska) msg1 msg2 msg3 skb nb r2'#1
msg1 := enc (make1 (na, pub ska), r1, pub skb)
msg2 := enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska)
msg3 := enc (make3 (nb, na), r3, pub skb)
pk := fun (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub ska) msg1 msg2 msg3 skb nb r2'#3
----------------------------------------
Exists (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message[adv, glob]),
[f
(pub ska)
(enc (make1 (na, pub ska), r1, pub skb))
msg2
(enc (make3 (nb, na), r3, pub skb))
skb
nb
r2' =
(<frame@pred A,
<of_bool (exec@pred A && true),
if (exec@pred A && true) then
(if (input@A = pub skb) then
diff(enc (make1 (na, pub ska), r1, pub skb), msg7@A)
else enc (make1 (na, pub ska), r1', input@A))>>,
exec@pred A && true,
if (A <= A) then input@A)]



rewrite and_true_r.
[> Line 783: (rewrite ...) [goal> Focused goal (1/3):
Systems: left:NSL/left, right:NSL_a/left (same for equivalences)
Variables:
f:message ->
message ->
message ->
message -> message -> message -> message -> message * bool * message
[adv, glob]
H: [happens(A)]
H0: [A < A1]
H1: [f (pub ska) msg1 msg2 msg3 skb nb r2' =
(frame@pred A, exec@pred A, if (A <= pred A) then input@A)]
ex := fun (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub ska) msg1 msg2 msg3 skb nb r2'#2
fr := fun (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub ska) msg1 msg2 msg3 skb nb r2'#1
msg1 := enc (make1 (na, pub ska), r1, pub skb)
msg2 := enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska)
msg3 := enc (make3 (nb, na), r3, pub skb)
pk := fun (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub ska) msg1 msg2 msg3 skb nb r2'#3
----------------------------------------
Exists (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message[adv, glob]),
[f
(pub ska)
(enc (make1 (na, pub ska), r1, pub skb))
msg2
(enc (make3 (nb, na), r3, pub skb))
skb
nb
r2' =
(<frame@pred A,
<of_bool (exec@pred A),
if exec@pred A then
(if (input@A = pub skb) then
diff(enc (make1 (na, pub ska), r1, pub skb), msg7@A)
else enc (make1 (na, pub ska), r1', input@A))>>,
exec@pred A,
if (A <= A) then input@A)]



exists (fun (p,m1,m2,m3,kb,nonceb,rand2:message) =>
(<fr f,
<of_bool (ex f),
if ex f then
if att (fr f) = pub skb then m1 else
enc(make1(na,pub ska),r1',att (fr f))>>,
ex f,
att (fr f))).
[> Line 799: (exists
(fun (p : message, m1 : message, m2 : message, m3 : message,
kb : message, nonceb : message, rand2 : message) =>
((pair (fr f) (pair (of_bool (ex f)) (if (ex f)
(if (= (att (fr f)) (pub skb)) m1
(enc ((make1 (na, (pub ska))), r1', (att (fr f))))) zero))),
(ex f), (att (fr f)))))
[goal> Focused goal (1/3):
System: left:NSL/left, right:NSL_a/left (same for equivalences)
Variables:
f:message ->
message ->
message ->
message -> message -> message -> message -> message * bool * message
[adv, glob]
H: [happens(A)]
H0: [A < A1]
H1: [f (pub ska) msg1 msg2 msg3 skb nb r2' =
(frame@pred A, exec@pred A, if (A <= pred A) then input@A)]
ex := fun (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub ska) msg1 msg2 msg3 skb nb r2'#2
fr := fun (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub ska) msg1 msg2 msg3 skb nb r2'#1
msg1 := enc (make1 (na, pub ska), r1, pub skb)
msg2 := enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska)
msg3 := enc (make3 (nb, na), r3, pub skb)
pk := fun (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub ska) msg1 msg2 msg3 skb nb r2'#3
----------------------------------------
(fun (p,m1,m2,m3,kb,nonceb,rand2:message) =>
(<fr f,
<of_bool (ex f),
if ex f then
(if (att (fr f) = pub skb) then m1
else enc (make1 (na, pub ska), r1', att (fr f)))>>,
ex f,
att (fr f)))
(pub ska)
(enc (make1 (na, pub ska), r1, pub skb))
msg2
(enc (make3 (nb, na), r3, pub skb))
skb
nb
r2' =
(<frame@pred A,
<of_bool (exec@pred A),
if exec@pred A then
(if (input@A = pub skb) then
diff(enc (make1 (na, pub ska), r1, pub skb), msg7@A)
else enc (make1 (na, pub ska), r1', input@A))>>,
exec@pred A,
if (A <= A) then input@A)



rewrite /* in *.
[> Line 801: (rewrite ... in *) [goal> Focused goal (1/3):
System: left:NSL/left, right:NSL_a/left (same for equivalences)
Variables:
f:message ->
message ->
message ->
message -> message -> message -> message -> message * bool * message
[adv, glob]
H: [happens(A)]
H0: [A < A1]
H1: [f
(pub ska)
(enc (make1 (na, pub ska), r1, pub skb))
(enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska))
(enc (make3 (nb, na), r3, pub skb))
skb
nb
r2' =
(frame@pred A, exec@pred A, if (A <= pred A) then att (frame@pred A))]
ex := fun (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub ska) msg1 msg2 msg3 skb nb r2'#2
fr := fun (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub ska) msg1 msg2 msg3 skb nb r2'#1
msg1 := enc (make1 (na, pub ska), r1, pub skb)
msg2 := enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska)
msg3 := enc (make3 (nb, na), r3, pub skb)
pk := fun (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub ska) msg1 msg2 msg3 skb nb r2'#3
----------------------------------------
(fun (p,m1,m2,m3,kb,nonceb,rand2:message) =>
(<(fun (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f
(pub ska)
(enc (make1 (na, pub ska), r1, pub skb))
(enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska))
(enc (make3 (nb, na), r3, pub skb))
skb
nb
r2'#1)
f,
<of_bool
((fun (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f
(pub ska)
(enc (make1 (na, pub ska), r1, pub skb))
(enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska))
(enc (make3 (nb, na), r3, pub skb))
skb
nb
r2'#2)
f),
if (fun (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f
(pub ska)
(enc (make1 (na, pub ska), r1, pub skb))
(enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska))
(enc (make3 (nb, na), r3, pub skb))
skb
nb
r2'#2)
f then
(if (att
((fun (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message * bool * message) =>
f
(pub ska)
(enc (make1 (na, pub ska), r1, pub skb))
(enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska))
(enc (make3 (nb, na), r3, pub skb))
skb
nb
r2'#1)
f) =
pub skb) then m1
else
enc
(make1 (na, pub ska),
r1',
att
((fun (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message * bool * message) =>
f
(pub ska)
(enc (make1 (na, pub ska), r1, pub skb))
(enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska))
(enc (make3 (nb, na), r3, pub skb))
skb
nb
r2'#1)
f)))>>,
(fun (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f
(pub ska)
(enc (make1 (na, pub ska), r1, pub skb))
(enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska))
(enc (make3 (nb, na), r3, pub skb))
skb
nb
r2'#2)
f,
att
((fun (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f
(pub ska)
(enc (make1 (na, pub ska), r1, pub skb))
(enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska))
(enc (make3 (nb, na), r3, pub skb))
skb
nb
r2'#1)
f)))
(pub ska)
(enc (make1 (na, pub ska), r1, pub skb))
(enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska))
(enc (make3 (nb, na), r3, pub skb))
skb
nb
r2' =
(<frame@pred A,
<of_bool (exec@pred A),
if exec@pred A then
(if (att (frame@pred A) = pub skb) then
diff(enc (make1 (na, pub ska), r1, pub skb),
enc (make1 (na, pub ska), r1, pub skb))
else enc (make1 (na, pub ska), r1', att (frame@pred A)))>>,
exec@pred A,
if (A <= A) then att (frame@pred A))



rewrite /= H1; reduce.
[> Line 803: ((rewrite /= ...);(reduce ...)) [goal> Focused goal (1/3):
System: left:NSL/left, right:NSL_a/left (same for equivalences)
Variables:
f:message ->
message ->
message ->
message -> message -> message -> message -> message * bool * message
[adv, glob]
H: [happens(A)]
H0: [A < A1]
H1: [f
(pub ska)
(enc (make1 (na, pub ska), r1, pub skb))
(enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska))
(enc (make3 (nb, na), r3, pub skb))
skb
nb
r2' =
(frame@pred A, exec@pred A, if (A <= pred A) then att (frame@pred A))]
ex := fun (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub ska) msg1 msg2 msg3 skb nb r2'#2
fr := fun (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub ska) msg1 msg2 msg3 skb nb r2'#1
msg1 := enc (make1 (na, pub ska), r1, pub skb)
msg2 := enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska)
msg3 := enc (make3 (nb, na), r3, pub skb)
pk := fun (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub ska) msg1 msg2 msg3 skb nb r2'#3
----------------------------------------
(<frame@pred A,
<of_bool (exec@pred A),
if exec@pred A then
(if (att (frame@pred A) = pub skb) then
enc (make1 (na, pub ska), r1, pub skb)
else enc (make1 (na, pub ska), r1', att (frame@pred A)))>>,
exec@pred A,
att (frame@pred A)) =
(<frame@pred A,
<of_bool (exec@pred A),
if exec@pred A then
(if (att (frame@pred A) = pub skb) then
diff(enc (make1 (na, pub ska), r1, pub skb),
enc (make1 (na, pub ska), r1, pub skb))
else enc (make1 (na, pub ska), r1', att (frame@pred A)))>>,
exec@pred A,
if (A <= A) then att (frame@pred A))



by rewrite (if_true (A <= A)).
[> Line 805: by (rewrite ...) [goal> Focused goal (1/2):
Systems: left:NSL/left, right:NSL_a/left (same for equivalences)
Variables:
H: [happens(A1)]
H0: [A1 < A1]
IH: Exists (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message
[adv, glob]),
[f (pub ska) msg1 msg2 msg3 skb nb r2' =
(frame@pred A1, exec@pred A1, if (A <= pred A1) then input@A)]
ex := fun (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub ska) msg1 msg2 msg3 skb nb r2'#2
fr := fun (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub ska) msg1 msg2 msg3 skb nb r2'#1
msg1 := enc (make1 (na, pub ska), r1, pub skb)
msg2 := enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska)
msg3 := enc (make3 (nb, na), r3, pub skb)
pk := fun (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub ska) msg1 msg2 msg3 skb nb r2'#3
----------------------------------------
Exists (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message[adv, glob]),
[f (pub ska) msg1 msg2 msg3 skb nb r2' =
(frame@A1, exec@A1, if (A <= A1) then input@A)]



+ by rewrite lt_irrefl in H0.
[> Line 807: by (rewrite ... in H0) [goal> Focused goal (1/1):
Systems: left:NSL/left, right:NSL_a/left (same for equivalences)
Variables:
H: [happens(B)]
H0: [B < A1]
IH: Exists (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message
[adv, glob]),
[f (pub ska) msg1 msg2 msg3 skb nb r2' =
(frame@pred B, exec@pred B, if (A <= pred B) then input@A)]
ex := fun (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub ska) msg1 msg2 msg3 skb nb r2'#2
fr := fun (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub ska) msg1 msg2 msg3 skb nb r2'#1
msg1 := enc (make1 (na, pub ska), r1, pub skb)
msg2 := enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska)
msg3 := enc (make3 (nb, na), r3, pub skb)
pk := fun (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub ska) msg1 msg2 msg3 skb nb r2'#3
----------------------------------------
Exists (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message[adv, glob]),
[f (pub ska) msg1 msg2 msg3 skb nb r2' =
(frame@B, exec@B, if (A <= B) then input@A)]



+ destruct IH.
[> Line 809: (destruct IH) [goal> Focused goal (1/1):
Systems: left:NSL/left, right:NSL_a/left (same for equivalences)
Variables:
f:message ->
message ->
message ->
message -> message -> message -> message -> message * bool * message
[adv, glob]
H: [happens(B)]
H0: [B < A1]
H1: [f (pub ska) msg1 msg2 msg3 skb nb r2' =
(frame@pred B, exec@pred B, if (A <= pred B) then input@A)]
ex := fun (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub ska) msg1 msg2 msg3 skb nb r2'#2
fr := fun (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub ska) msg1 msg2 msg3 skb nb r2'#1
msg1 := enc (make1 (na, pub ska), r1, pub skb)
msg2 := enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska)
msg3 := enc (make3 (nb, na), r3, pub skb)
pk := fun (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub ska) msg1 msg2 msg3 skb nb r2'#3
----------------------------------------
Exists (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message[adv, glob]),
[f (pub ska) msg1 msg2 msg3 skb nb r2' =
(frame@B, exec@B, if (A <= B) then input@A)]



rewrite /*.
[> Line 811: (rewrite ...) [goal> Focused goal (1/1):
Systems: left:NSL/left, right:NSL_a/left (same for equivalences)
Variables:
f:message ->
message ->
message ->
message -> message -> message -> message -> message * bool * message
[adv, glob]
H: [happens(B)]
H0: [B < A1]
H1: [f (pub ska) msg1 msg2 msg3 skb nb r2' =
(frame@pred B, exec@pred B, if (A <= pred B) then input@A)]
ex := fun (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub ska) msg1 msg2 msg3 skb nb r2'#2
fr := fun (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub ska) msg1 msg2 msg3 skb nb r2'#1
msg1 := enc (make1 (na, pub ska), r1, pub skb)
msg2 := enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska)
msg3 := enc (make3 (nb, na), r3, pub skb)
pk := fun (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub ska) msg1 msg2 msg3 skb nb r2'#3
----------------------------------------
Exists (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message[adv, glob]),
[f
(pub ska)
(enc (make1 (na, pub ska), r1, pub skb))
(enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska))
(enc (make3 (nb, na), r3, pub skb))
skb
nb
r2' =
(<frame@pred B,
<of_bool (exec@pred B && true),
if (exec@pred B && true) then
(if (att (frame@pred B) =
diff(enc (make1 (na, pub ska), r1, pub skb),
enc (make1 (na, pub ska), r1, pub skb))) then
diff(enc (make2 (na, nb, pub skb), r2, pub ska),
enc (len2, r2, pub ska))
else if (att (frame@pred B) =
diff(enc (make3 (nb, na), r3, pub skb),
enc (make3 (nb, na), r3, pub skb))) then empty
else if check_tag (dec (att (frame@pred B), skb)) then
enc
(make2 (get1_na (dec (att (frame@pred B), skb)), nb, pub skb),
r2',
get1_id (dec (att (frame@pred B), skb))))>>,
exec@pred B && true,
if (A <= B) then att (frame@pred A))]



rewrite and_true_r.
[> Line 813: (rewrite ...) [goal> Focused goal (1/1):
Systems: left:NSL/left, right:NSL_a/left (same for equivalences)
Variables:
f:message ->
message ->
message ->
message -> message -> message -> message -> message * bool * message
[adv, glob]
H: [happens(B)]
H0: [B < A1]
H1: [f (pub ska) msg1 msg2 msg3 skb nb r2' =
(frame@pred B, exec@pred B, if (A <= pred B) then input@A)]
ex := fun (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub ska) msg1 msg2 msg3 skb nb r2'#2
fr := fun (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub ska) msg1 msg2 msg3 skb nb r2'#1
msg1 := enc (make1 (na, pub ska), r1, pub skb)
msg2 := enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska)
msg3 := enc (make3 (nb, na), r3, pub skb)
pk := fun (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub ska) msg1 msg2 msg3 skb nb r2'#3
----------------------------------------
Exists (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message[adv, glob]),
[f
(pub ska)
(enc (make1 (na, pub ska), r1, pub skb))
(enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska))
(enc (make3 (nb, na), r3, pub skb))
skb
nb
r2' =
(<frame@pred B,
<of_bool (exec@pred B),
if exec@pred B then
(if (att (frame@pred B) =
diff(enc (make1 (na, pub ska), r1, pub skb),
enc (make1 (na, pub ska), r1, pub skb))) then
diff(enc (make2 (na, nb, pub skb), r2, pub ska),
enc (len2, r2, pub ska))
else if (att (frame@pred B) =
diff(enc (make3 (nb, na), r3, pub skb),
enc (make3 (nb, na), r3, pub skb))) then empty
else if check_tag (dec (att (frame@pred B), skb)) then
enc
(make2 (get1_na (dec (att (frame@pred B), skb)), nb, pub skb),
r2',
get1_id (dec (att (frame@pred B), skb))))>>,
exec@pred B,
if (A <= B) then att (frame@pred A))]



exists (fun (p,m1,m2,m3,kb,nonceb,rand2:message) =>
(<fr f, <of_bool (ex f), if ex f then
if att (fr f) = m1 then m2 else
if att (fr f) = m3 then empty else
if check_tag (dec (att (fr f), skb)) then
enc (make2
(get1_na (dec (att (fr f), kb)),
nonceb, pub kb),
rand2,
get1_id (dec (att (fr f), kb)))
>>, ex f, pk f)).
[> Line 835: (exists
(fun (p : message, m1 : message, m2 : message, m3 : message,
kb : message, nonceb : message, rand2 : message) =>
((pair (fr f) (pair (of_bool (ex f)) (if (ex f)
(if (= (att (fr f)) m1) m2 (if (= (att (fr f)) m3) empty
(if (check_tag (dec ((att (fr f)), skb)))
(enc ((make2 ((get1_na (dec ((att (fr f)), kb))), nonceb,
(pub kb))),
rand2, (get1_id (dec ((att (fr f)), kb)))))
zero))) zero))), (ex f), (pk f))))
[goal> Focused goal (1/1):
System: left:NSL/left, right:NSL_a/left (same for equivalences)
Variables:
f:message ->
message ->
message ->
message -> message -> message -> message -> message * bool * message
[adv, glob]
H: [happens(B)]
H0: [B < A1]
H1: [f (pub ska) msg1 msg2 msg3 skb nb r2' =
(frame@pred B, exec@pred B, if (A <= pred B) then input@A)]
ex := fun (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub ska) msg1 msg2 msg3 skb nb r2'#2
fr := fun (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub ska) msg1 msg2 msg3 skb nb r2'#1
msg1 := enc (make1 (na, pub ska), r1, pub skb)
msg2 := enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska)
msg3 := enc (make3 (nb, na), r3, pub skb)
pk := fun (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub ska) msg1 msg2 msg3 skb nb r2'#3
----------------------------------------
(fun (p,m1,m2,m3,kb,nonceb,rand2:message) =>
(<fr f,
<of_bool (ex f),
if ex f then
(if (att (fr f) = m1) then m2
else if (att (fr f) = m3) then empty
else if check_tag (dec (att (fr f), skb)) then
enc
(make2 (get1_na (dec (att (fr f), kb)), nonceb, pub kb),
rand2,
get1_id (dec (att (fr f), kb))))>>,
ex f,
pk f))
(pub ska)
(enc (make1 (na, pub ska), r1, pub skb))
(enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska))
(enc (make3 (nb, na), r3, pub skb))
skb
nb
r2' =
(<frame@pred B,
<of_bool (exec@pred B),
if exec@pred B then
(if (att (frame@pred B) =
diff(enc (make1 (na, pub ska), r1, pub skb),
enc (make1 (na, pub ska), r1, pub skb))) then
diff(enc (make2 (na, nb, pub skb), r2, pub ska),
enc (len2, r2, pub ska))
else if (att (frame@pred B) =
diff(enc (make3 (nb, na), r3, pub skb),
enc (make3 (nb, na), r3, pub skb))) then empty
else if check_tag (dec (att (frame@pred B), skb)) then
enc
(make2 (get1_na (dec (att (frame@pred B), skb)), nb, pub skb),
r2',
get1_id (dec (att (frame@pred B), skb))))>>,
exec@pred B,
if (A <= B) then att (frame@pred A))



rewrite /* in *.
[> Line 837: (rewrite ... in *) [goal> Focused goal (1/1):
System: left:NSL/left, right:NSL_a/left (same for equivalences)
Variables:
f:message ->
message ->
message ->
message -> message -> message -> message -> message * bool * message
[adv, glob]
H: [happens(B)]
H0: [B < A1]
H1: [f
(pub ska)
(enc (make1 (na, pub ska), r1, pub skb))
(enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska))
(enc (make3 (nb, na), r3, pub skb))
skb
nb
r2' =
(frame@pred B, exec@pred B, if (A <= pred B) then att (frame@pred A))]
ex := fun (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub ska) msg1 msg2 msg3 skb nb r2'#2
fr := fun (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub ska) msg1 msg2 msg3 skb nb r2'#1
msg1 := enc (make1 (na, pub ska), r1, pub skb)
msg2 := enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska)
msg3 := enc (make3 (nb, na), r3, pub skb)
pk := fun (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub ska) msg1 msg2 msg3 skb nb r2'#3
----------------------------------------
(fun (p,m1,m2,m3,kb,nonceb,rand2:message) =>
(<(fun (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f
(pub ska)
(enc (make1 (na, pub ska), r1, pub skb))
(enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska))
(enc (make3 (nb, na), r3, pub skb))
skb
nb
r2'#1)
f,
<of_bool
((fun (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f
(pub ska)
(enc (make1 (na, pub ska), r1, pub skb))
(enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska))
(enc (make3 (nb, na), r3, pub skb))
skb
nb
r2'#2)
f),
if (fun (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f
(pub ska)
(enc (make1 (na, pub ska), r1, pub skb))
(enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska))
(enc (make3 (nb, na), r3, pub skb))
skb
nb
r2'#2)
f then
(if (att
((fun (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message * bool * message) =>
f
(pub ska)
(enc (make1 (na, pub ska), r1, pub skb))
(enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska))
(enc (make3 (nb, na), r3, pub skb))
skb
nb
r2'#1)
f) =
m1) then m2
else if (att
((fun (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message * bool * message) =>
f
(pub ska)
(enc (make1 (na, pub ska), r1, pub skb))
(enc
(diff(make2 (na, nb, pub skb), len2),
r2,
pub ska))
(enc (make3 (nb, na), r3, pub skb))
skb
nb
r2'#1)
f) =
m3) then empty
else if check_tag
(dec
(att
((fun (f:message ->
message ->
message ->
message ->
message ->
message ->
message -> message * bool * message) =>
f
(pub ska)
(enc (make1 (na, pub ska), r1, pub skb))
(enc
(diff(make2 (na, nb, pub skb), len2),
r2,
pub ska))
(enc (make3 (nb, na), r3, pub skb))
skb
nb
r2'#1)
f),
skb)) then
enc
(make2
(get1_na
(dec
(att
((fun (f:message ->
message ->
message ->
message ->
message ->
message ->
message -> message * bool * message) =>
f
(pub ska)
(enc (make1 (na, pub ska), r1, pub skb))
(enc
(diff(make2 (na, nb, pub skb), len2),
r2,
pub ska))
(enc (make3 (nb, na), r3, pub skb))
skb
nb
r2'#1)
f),
kb)),
nonceb,
pub kb),
rand2,
get1_id
(dec
(att
((fun (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message * bool * message) =>
f
(pub ska)
(enc (make1 (na, pub ska), r1, pub skb))
(enc
(diff(make2 (na, nb, pub skb), len2),
r2,
pub ska))
(enc (make3 (nb, na), r3, pub skb))
skb
nb
r2'#1)
f),
kb))))>>,
(fun (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f
(pub ska)
(enc (make1 (na, pub ska), r1, pub skb))
(enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska))
(enc (make3 (nb, na), r3, pub skb))
skb
nb
r2'#2)
f,
(fun (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f
(pub ska)
(enc (make1 (na, pub ska), r1, pub skb))
(enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska))
(enc (make3 (nb, na), r3, pub skb))
skb
nb
r2'#3)
f))
(pub ska)
(enc (make1 (na, pub ska), r1, pub skb))
(enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska))
(enc (make3 (nb, na), r3, pub skb))
skb
nb
r2' =
(<frame@pred B,
<of_bool (exec@pred B),
if exec@pred B then
(if (att (frame@pred B) =
diff(enc (make1 (na, pub ska), r1, pub skb),
enc (make1 (na, pub ska), r1, pub skb))) then
diff(enc (make2 (na, nb, pub skb), r2, pub ska),
enc (len2, r2, pub ska))
else if (att (frame@pred B) =
diff(enc (make3 (nb, na), r3, pub skb),
enc (make3 (nb, na), r3, pub skb))) then empty
else if check_tag (dec (att (frame@pred B), skb)) then
enc
(make2 (get1_na (dec (att (frame@pred B), skb)), nb, pub skb),
r2',
get1_id (dec (att (frame@pred B), skb))))>>,
exec@pred B,
if (A <= B) then att (frame@pred A))


simpl. [> Line 837: (simpl ...) [goal> Focused goal (1/1):
System: left:NSL/left, right:NSL_a/left (same for equivalences)
Variables:
f:message ->
message ->
message ->
message -> message -> message -> message -> message * bool * message
[adv, glob]
H: [happens(B)]
H0: [B < A1]
H1: [f
(pub ska)
(enc (make1 (na, pub ska), r1, pub skb))
(enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska))
(enc (make3 (nb, na), r3, pub skb))
skb
nb
r2' =
(frame@pred B, exec@pred B, if (A <= pred B) then att (frame@pred A))]
ex := fun (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub ska) msg1 msg2 msg3 skb nb r2'#2
fr := fun (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub ska) msg1 msg2 msg3 skb nb r2'#1
msg1 := enc (make1 (na, pub ska), r1, pub skb)
msg2 := enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska)
msg3 := enc (make3 (nb, na), r3, pub skb)
pk := fun (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub ska) msg1 msg2 msg3 skb nb r2'#3
----------------------------------------
(<f
(pub ska)
(enc (make1 (na, pub ska), r1, pub skb))
(enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska))
(enc (make3 (nb, na), r3, pub skb))
skb
nb
r2'#1,
<of_bool
(f
(pub ska)
(enc (make1 (na, pub ska), r1, pub skb))
(enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska))
(enc (make3 (nb, na), r3, pub skb))
skb
nb
r2'#2),
if f
(pub ska)
(enc (make1 (na, pub ska), r1, pub skb))
(enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska))
(enc (make3 (nb, na), r3, pub skb))
skb
nb
r2'#2 then
(if (att
(f
(pub ska)
(enc (make1 (na, pub ska), r1, pub skb))
(enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska))
(enc (make3 (nb, na), r3, pub skb))
skb
nb
r2'#1) =
enc (make1 (na, pub ska), r1, pub skb)) then
enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska)
else if (att
(f
(pub ska)
(enc (make1 (na, pub ska), r1, pub skb))
(enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska))
(enc (make3 (nb, na), r3, pub skb))
skb
nb
r2'#1) =
enc (make3 (nb, na), r3, pub skb)) then empty
else if check_tag
(dec
(att
(f
(pub ska)
(enc (make1 (na, pub ska), r1, pub skb))
(enc
(diff(make2 (na, nb, pub skb), len2),
r2,
pub ska))
(enc (make3 (nb, na), r3, pub skb))
skb
nb
r2'#1),
skb)) then
enc
(make2
(get1_na
(dec
(att
(f
(pub ska)
(enc (make1 (na, pub ska), r1, pub skb))
(enc
(diff(make2 (na, nb, pub skb), len2),
r2,
pub ska))
(enc (make3 (nb, na), r3, pub skb))
skb
nb
r2'#1),
skb)),
nb,
pub skb),
r2',
get1_id
(dec
(att
(f
(pub ska)
(enc (make1 (na, pub ska), r1, pub skb))
(enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska))
(enc (make3 (nb, na), r3, pub skb))
skb
nb
r2'#1),
skb))))>>,
f
(pub ska)
(enc (make1 (na, pub ska), r1, pub skb))
(enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska))
(enc (make3 (nb, na), r3, pub skb))
skb
nb
r2'#2,
f
(pub ska)
(enc (make1 (na, pub ska), r1, pub skb))
(enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska))
(enc (make3 (nb, na), r3, pub skb))
skb
nb
r2'#3) =
(<frame@pred B,
<of_bool (exec@pred B),
if exec@pred B then
(if (att (frame@pred B) =
diff(enc (make1 (na, pub ska), r1, pub skb),
enc (make1 (na, pub ska), r1, pub skb))) then
diff(enc (make2 (na, nb, pub skb), r2, pub ska),
enc (len2, r2, pub ska))
else if (att (frame@pred B) =
diff(enc (make3 (nb, na), r3, pub skb),
enc (make3 (nb, na), r3, pub skb))) then empty
else if check_tag (dec (att (frame@pred B), skb)) then
enc
(make2 (get1_na (dec (att (frame@pred B), skb)), nb, pub skb),
r2',
get1_id (dec (att (frame@pred B), skb))))>>,
exec@pred B,
if (A <= B) then att (frame@pred A))



assert (A <= B) <=> (A <= pred B) as -> by auto.
[> Line 839: ((have ...); 1: by (auto ...)) [goal> Focused goal (1/1):
System: left:NSL/left, right:NSL_a/left (same for equivalences)
Variables:
f:message ->
message ->
message ->
message -> message -> message -> message -> message * bool * message
[adv, glob]
H: [happens(B)]
H0: [B < A1]
H1: [f
(pub ska)
(enc (make1 (na, pub ska), r1, pub skb))
(enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska))
(enc (make3 (nb, na), r3, pub skb))
skb
nb
r2' =
(frame@pred B, exec@pred B, if (A <= pred B) then att (frame@pred A))]
ex := fun (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub ska) msg1 msg2 msg3 skb nb r2'#2
fr := fun (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub ska) msg1 msg2 msg3 skb nb r2'#1
msg1 := enc (make1 (na, pub ska), r1, pub skb)
msg2 := enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska)
msg3 := enc (make3 (nb, na), r3, pub skb)
pk := fun (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub ska) msg1 msg2 msg3 skb nb r2'#3
----------------------------------------
(<f
(pub ska)
(enc (make1 (na, pub ska), r1, pub skb))
(enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska))
(enc (make3 (nb, na), r3, pub skb))
skb
nb
r2'#1,
<of_bool
(f
(pub ska)
(enc (make1 (na, pub ska), r1, pub skb))
(enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska))
(enc (make3 (nb, na), r3, pub skb))
skb
nb
r2'#2),
if f
(pub ska)
(enc (make1 (na, pub ska), r1, pub skb))
(enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska))
(enc (make3 (nb, na), r3, pub skb))
skb
nb
r2'#2 then
(if (att
(f
(pub ska)
(enc (make1 (na, pub ska), r1, pub skb))
(enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska))
(enc (make3 (nb, na), r3, pub skb))
skb
nb
r2'#1) =
enc (make1 (na, pub ska), r1, pub skb)) then
enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska)
else if (att
(f
(pub ska)
(enc (make1 (na, pub ska), r1, pub skb))
(enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska))
(enc (make3 (nb, na), r3, pub skb))
skb
nb
r2'#1) =
enc (make3 (nb, na), r3, pub skb)) then empty
else if check_tag
(dec
(att
(f
(pub ska)
(enc (make1 (na, pub ska), r1, pub skb))
(enc
(diff(make2 (na, nb, pub skb), len2),
r2,
pub ska))
(enc (make3 (nb, na), r3, pub skb))
skb
nb
r2'#1),
skb)) then
enc
(make2
(get1_na
(dec
(att
(f
(pub ska)
(enc (make1 (na, pub ska), r1, pub skb))
(enc
(diff(make2 (na, nb, pub skb), len2),
r2,
pub ska))
(enc (make3 (nb, na), r3, pub skb))
skb
nb
r2'#1),
skb)),
nb,
pub skb),
r2',
get1_id
(dec
(att
(f
(pub ska)
(enc (make1 (na, pub ska), r1, pub skb))
(enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska))
(enc (make3 (nb, na), r3, pub skb))
skb
nb
r2'#1),
skb))))>>,
f
(pub ska)
(enc (make1 (na, pub ska), r1, pub skb))
(enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska))
(enc (make3 (nb, na), r3, pub skb))
skb
nb
r2'#2,
f
(pub ska)
(enc (make1 (na, pub ska), r1, pub skb))
(enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska))
(enc (make3 (nb, na), r3, pub skb))
skb
nb
r2'#3) =
(<frame@pred B,
<of_bool (exec@pred B),
if exec@pred B then
(if (att (frame@pred B) =
diff(enc (make1 (na, pub ska), r1, pub skb),
enc (make1 (na, pub ska), r1, pub skb))) then
diff(enc (make2 (na, nb, pub skb), r2, pub ska),
enc (len2, r2, pub ska))
else if (att (frame@pred B) =
diff(enc (make3 (nb, na), r3, pub skb),
enc (make3 (nb, na), r3, pub skb))) then empty
else if check_tag (dec (att (frame@pred B), skb)) then
enc
(make2 (get1_na (dec (att (frame@pred B), skb)), nb, pub skb),
r2',
get1_id (dec (att (frame@pred B), skb))))>>,
exec@pred B,
if (A <= pred B) then att (frame@pred A))



by rewrite H1.
[> Line 841: by (rewrite ...) [goal> lemma deduction_left is proved


Qed.
global lemma [left:NSL/left, right:NSL_a/left (same for equivalences)] deduction_left :
Forall (t:timestamp[const, glob]),
Let msg1 = enc (make1 (na, pub ska), r1, pub skb) in
Let msg2 = enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska) in
Let msg3 = enc (make3 (nb, na), r3, pub skb) in
Let fr =
fun (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub ska) msg1 msg2 msg3 skb nb r2'#1 in
Let ex =
fun (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub ska) msg1 msg2 msg3 skb nb r2'#2 in
Let pk =
fun (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub ska) msg1 msg2 msg3 skb nb r2'#3 in
[happens(t)] ->
[t < A1] ->
Exists (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message
[adv, glob]),
[f (pub ska) msg1 msg2 msg3 skb nb r2' =
(frame@t, exec@t, if (A <= t) then input@A)]
Exiting proof mode.



(* ----------------------------------------------------------------------- *)

(* Prove a (strengthened form of) observational indistinguishability
between NSL_a/left and NSL/right (= NSL_a/right).
Note that we can reveal na and nb as we are only working
wrt a CCA2 attacker. *)
global lemma [NSL_a/left,NSL/right] equiv_right (t:timestamp[const]) :
Let msg1 = enc( diff(make1(na,pub(ska)),len1),r1,pub(skb)) in
Let msg2 = enc(len2, r2, pub ska) in
Let msg3 = enc(diff(make3(nb,na), len3), r3, pub skb) in
[happens(t)] ->
equiv(msg1,msg2,msg3,pub skb,
ska, na, nb, r1', r3',
frame@t).
Goal equiv_right :
forall t:timestamp[const, glob],
Let msg1 = enc (diff(make1 (na, pub ska), len1), r1, pub skb) in
Let msg2 = enc (len2, r2, pub ska) in
Let msg3 = enc (diff(make3 (nb, na), len3), r3, pub skb) in
[happens(t)] ->
equiv(msg1, msg2, msg3, pub skb, ska, na, nb, r1', r3', frame@t)

Proof.
[goal> Focused goal (1/1):
Systems: left:NSL_a/left, right:NSL/right (same for equivalences)
Variables: t:timestamp[const, glob]
----------------------------------------
Let msg1 = enc (diff(make1 (na, pub ska), len1), r1, pub skb) in
Let msg2 = enc (len2, r2, pub ska) in
Let msg3 = enc (diff(make3 (nb, na), len3), r3, pub skb) in
[happens(t)] ->
equiv(msg1, msg2, msg3, pub skb, ska, na, nb, r1', r3', frame@t)


intro *.
[> Line 877: (intro *) [goal> Focused goal (1/1):
Systems: left:NSL_a/left, right:NSL/right (same for equivalences)
Variables: t:timestamp[const, glob]
H: [happens(t)]
msg1 := enc (diff(make1 (na, pub ska), len1), r1, pub skb)
msg2 := enc (len2, r2, pub ska)
msg3 := enc (diff(make3 (nb, na), len3), r3, pub skb)
----------------------------------------
0: msg1
1: msg2
2: msg3
3: pub skb
4: ska
5: na
6: nb
7: r1'
8: r3'
9: frame@t



induction t.
[> Line 879: (induction t) [goal> Focused goal (1/5):
Systems: left:NSL_a/left, right:NSL/right (same for equivalences)
Variables:
H: [happens(init)]
msg1 := enc (diff(make1 (na, pub ska), len1), r1, pub skb)
msg2 := enc (len2, r2, pub ska)
msg3 := enc (diff(make3 (nb, na), len3), r3, pub skb)
----------------------------------------
0: msg1
1: msg2
2: msg3
3: pub skb
4: ska
5: na
6: nb
7: r1'
8: r3'
9: frame@init



+ rewrite /*.
[> Line 881: (rewrite ...) [goal> Focused goal (1/5):
Systems: left:NSL_a/left, right:NSL/right (same for equivalences)
Variables:
H: [happens(init)]
msg1 := enc (diff(make1 (na, pub ska), len1), r1, pub skb)
msg2 := enc (len2, r2, pub ska)
msg3 := enc (diff(make3 (nb, na), len3), r3, pub skb)
----------------------------------------
0: enc (diff(make1 (na, pub ska), len1), r1, pub skb)
1: enc (len2, r2, pub ska)
2: enc (diff(make3 (nb, na), len3), r3, pub skb)
3: pub skb
4: ska
5: na
6: nb
7: r1'
8: r3'



crypto CCA2 (key :skb).
[> Line 883: (crypto ...) Direct bi-deduction sub-goal (assuming recursive calls are bi-deducible):


(enc (diff(make1 (na, pub ska), len1), r1, pub skb),
enc (len2, r2, pub ska),
enc (diff(make3 (nb, na), len3), r3, pub skb),
pub skb,
ska,
na,
nb,
r1',
r3')

Bi-deduction sub-goals for recursive calls:


Constraints are:
{ r1 , L }
{ r3 , L }
{ r3' , A }
{ r1' , A }
{ nb , A }
{ r2 , A }
{ ska , A }
{ na , A }
{ skb , Gkey }
Constraints subgoals are:
Oracle subgoals are: zeroes (make3 (nb, na)) = zeroes len3
zeroes (make1 (na, pub ska)) = zeroes len1
Final memory is:
{log -> [{ enc (diff(make3 (nb, na), len3), r3, pub skb) | true },
{ enc (diff(make1 (na, pub ska), len1), r1, pub skb) | true } ] }
[goal> Focused goal (1/6):
System: left:NSL_a/left, right:NSL/right (same for equivalences)
Variables:
H: [happens(init)]
msg1 := enc (diff(make1 (na, pub ska), len1), r1, pub skb)
msg2 := enc (len2, r2, pub ska)
msg3 := enc (diff(make3 (nb, na), len3), r3, pub skb)
----------------------------------------
zeroes (make3 (nb, na)) = zeroes len3


by rewrite len3.
[> Line 885: by (rewrite ...) [goal> Focused goal (1/5):
System: left:NSL_a/left, right:NSL/right (same for equivalences)
Variables:
H: [happens(init)]
msg1 := enc (diff(make1 (na, pub ska), len1), r1, pub skb)
msg2 := enc (len2, r2, pub ska)
msg3 := enc (diff(make3 (nb, na), len3), r3, pub skb)
----------------------------------------
zeroes (make1 (na, pub ska)) = zeroes len1


by rewrite len1.
[> Line 887: by (rewrite ...) [goal> Focused goal (1/4):
Systems: left:NSL_a/left, right:NSL/right (same for equivalences)
Variables:
H: [happens(PUB)]
IH: equiv(msg1, msg2, msg3, pub skb, ska, na, nb, r1', r3', frame@pred PUB)
msg1 := enc (diff(make1 (na, pub ska), len1), r1, pub skb)
msg2 := enc (len2, r2, pub ska)
msg3 := enc (diff(make3 (nb, na), len3), r3, pub skb)
----------------------------------------
0: msg1
1: msg2
2: msg3
3: pub skb
4: ska
5: na
6: nb
7: r1'
8: r3'
9: frame@PUB



+ rewrite /*in *.
[> Line 889: (rewrite ... in *) [goal> Focused goal (1/4):
Systems: left:NSL_a/left, right:NSL/right (same for equivalences)
Variables:
H: [happens(PUB)]
IH: equiv(enc (diff(make1 (na, pub ska), len1), r1, pub skb),
enc (len2, r2, pub ska),
enc (diff(make3 (nb, na), len3), r3, pub skb), pub skb, ska, na,
nb, r1', r3', frame@pred PUB)
msg1 := enc (diff(make1 (na, pub ska), len1), r1, pub skb)
msg2 := enc (len2, r2, pub ska)
msg3 := enc (diff(make3 (nb, na), len3), r3, pub skb)
----------------------------------------
0: enc (diff(make1 (na, pub ska), len1), r1, pub skb)
1: enc (len2, r2, pub ska)
2: enc (diff(make3 (nb, na), len3), r3, pub skb)
3: pub skb
4: ska
5: na
6: nb
7: r1'
8: r3'
9: <frame@pred PUB,
<of_bool (exec@pred PUB && true),
if (exec@pred PUB && true) then <pub ska,pub skb>>>



apply IH.
[> Line 891: (apply ... ) [goal> Focused goal (1/3):
Systems: left:NSL_a/left, right:NSL/right (same for equivalences)
Variables:
H: [happens(A)]
IH: equiv(msg1, msg2, msg3, pub skb, ska, na, nb, r1', r3', frame@pred A)
msg1 := enc (diff(make1 (na, pub ska), len1), r1, pub skb)
msg2 := enc (len2, r2, pub ska)
msg3 := enc (diff(make3 (nb, na), len3), r3, pub skb)
----------------------------------------
0: msg1
1: msg2
2: msg3
3: pub skb
4: ska
5: na
6: nb
7: r1'
8: r3'
9: frame@A



+ rewrite /* in *.
[> Line 893: (rewrite ... in *) [goal> Focused goal (1/3):
Systems: left:NSL_a/left, right:NSL/right (same for equivalences)
Variables:
H: [happens(A)]
IH: equiv(enc (diff(make1 (na, pub ska), len1), r1, pub skb),
enc (len2, r2, pub ska),
enc (diff(make3 (nb, na), len3), r3, pub skb), pub skb, ska, na,
nb, r1', r3', frame@pred A)
msg1 := enc (diff(make1 (na, pub ska), len1), r1, pub skb)
msg2 := enc (len2, r2, pub ska)
msg3 := enc (diff(make3 (nb, na), len3), r3, pub skb)
----------------------------------------
0: enc (diff(make1 (na, pub ska), len1), r1, pub skb)
1: enc (len2, r2, pub ska)
2: enc (diff(make3 (nb, na), len3), r3, pub skb)
3: pub skb
4: ska
5: na
6: nb
7: r1'
8: r3'
9: <frame@pred A,
<of_bool (exec@pred A && true),
if (exec@pred A && true) then
(if (att (frame@pred A) = pub skb) then
diff(enc (make1 (na, pub ska), r1, pub skb),
enc (len1, r1, pub skb))
else enc (make1 (na, pub ska), r1', att (frame@pred A)))>>



apply IH.
[> Line 895: (apply ... ) [goal> Focused goal (1/2):
Systems: left:NSL_a/left, right:NSL/right (same for equivalences)
Variables:
H: [happens(A1)]
IH: equiv(msg1, msg2, msg3, pub skb, ska, na, nb, r1', r3', frame@pred A1)
msg1 := enc (diff(make1 (na, pub ska), len1), r1, pub skb)
msg2 := enc (len2, r2, pub ska)
msg3 := enc (diff(make3 (nb, na), len3), r3, pub skb)
----------------------------------------
0: msg1
1: msg2
2: msg3
3: pub skb
4: ska
5: na
6: nb
7: r1'
8: r3'
9: frame@A1



+ rewrite /* in *.
[> Line 897: (rewrite ... in *) [goal> Focused goal (1/2):
Systems: left:NSL_a/left, right:NSL/right (same for equivalences)
Variables:
H: [happens(A1)]
IH: equiv(enc (diff(make1 (na, pub ska), len1), r1, pub skb),
enc (len2, r2, pub ska),
enc (diff(make3 (nb, na), len3), r3, pub skb), pub skb, ska, na,
nb, r1', r3', frame@pred A1)
msg1 := enc (diff(make1 (na, pub ska), len1), r1, pub skb)
msg2 := enc (len2, r2, pub ska)
msg3 := enc (diff(make3 (nb, na), len3), r3, pub skb)
----------------------------------------
0: enc (diff(make1 (na, pub ska), len1), r1, pub skb)
1: enc (len2, r2, pub ska)
2: enc (diff(make3 (nb, na), len3), r3, pub skb)
3: pub skb
4: ska
5: na
6: nb
7: r1'
8: r3'
9: <frame@pred A1,
<of_bool (exec@pred A1 && true),
if (exec@pred A1 && true) then
(if (att (frame@pred A1) =
diff(enc (len2, r2, pub ska), enc (len2, r2, pub ska))) then
(if (input@A = pub skb) then
<diff(enc (make3 (nb, na), r3, pub skb),
enc (len3, r3, pub skb)),<na,nb>>)
else if (get2_na (dec (att (frame@pred A1), ska)) = na &&
get2_id (dec (att (frame@pred A1), ska)) = input@A) then
<enc
(make3 (get2_nb (dec (att (frame@pred A1), ska)), na),
r3',
input@A),if (input@A = pub skb) then <na,nb>>)>>



fa !<_,_>.
[> Line 899: (fa !(pair _ _)) [goal> Focused goal (1/2):
Systems: left:NSL_a/left, right:NSL/right (same for equivalences)
Variables:
H: [happens(A1)]
IH: equiv(enc (diff(make1 (na, pub ska), len1), r1, pub skb),
enc (len2, r2, pub ska),
enc (diff(make3 (nb, na), len3), r3, pub skb), pub skb, ska, na,
nb, r1', r3', frame@pred A1)
msg1 := enc (diff(make1 (na, pub ska), len1), r1, pub skb)
msg2 := enc (len2, r2, pub ska)
msg3 := enc (diff(make3 (nb, na), len3), r3, pub skb)
----------------------------------------
0: enc (diff(make1 (na, pub ska), len1), r1, pub skb)
1: enc (len2, r2, pub ska)
2: enc (diff(make3 (nb, na), len3), r3, pub skb)
3: pub skb
4: ska
5: na
6: nb
7: r1'
8: r3'
9: frame@pred A1
10: if (exec@pred A1 && true) then
(if (att (frame@pred A1) =
diff(enc (len2, r2, pub ska), enc (len2, r2, pub ska))) then
(if (input@A = pub skb) then
<diff(enc (make3 (nb, na), r3, pub skb), enc (len3, r3, pub skb)),
<na,nb>>)
else if (get2_na (dec (att (frame@pred A1), ska)) = na &&
get2_id (dec (att (frame@pred A1), ska)) = input@A) then
<enc
(make3 (get2_nb (dec (att (frame@pred A1), ska)), na),
r3',
input@A),if (input@A = pub skb) then <na,nb>>)



apply IH.
[> Line 901: (apply ... ) [goal> Focused goal (1/1):
Systems: left:NSL_a/left, right:NSL/right (same for equivalences)
Variables:
H: [happens(B)]
IH: equiv(msg1, msg2, msg3, pub skb, ska, na, nb, r1', r3', frame@pred B)
msg1 := enc (diff(make1 (na, pub ska), len1), r1, pub skb)
msg2 := enc (len2, r2, pub ska)
msg3 := enc (diff(make3 (nb, na), len3), r3, pub skb)
----------------------------------------
0: msg1
1: msg2
2: msg3
3: pub skb
4: ska
5: na
6: nb
7: r1'
8: r3'
9: frame@B



+ rewrite /*.
[> Line 903: (rewrite ...) [goal> Focused goal (1/1):
Systems: left:NSL_a/left, right:NSL/right (same for equivalences)
Variables:
H: [happens(B)]
IH: equiv(msg1, msg2, msg3, pub skb, ska, na, nb, r1', r3', frame@pred B)
msg1 := enc (diff(make1 (na, pub ska), len1), r1, pub skb)
msg2 := enc (len2, r2, pub ska)
msg3 := enc (diff(make3 (nb, na), len3), r3, pub skb)
----------------------------------------
0: enc (diff(make1 (na, pub ska), len1), r1, pub skb)
1: enc (len2, r2, pub ska)
2: enc (diff(make3 (nb, na), len3), r3, pub skb)
3: pub skb
4: ska
5: na
6: nb
7: r1'
8: r3'
9: <frame@pred B,
<of_bool (exec@pred B && true),
if (exec@pred B && true) then
(if (att (frame@pred B) =
diff(enc (make1 (na, pub ska), r1, pub skb),
enc (len1, r1, pub skb))) then
diff(enc (len2, r2, pub ska), enc (len2, r2, pub ska))
else if (att (frame@pred B) =
diff(enc (make3 (nb, na), r3, pub skb),
enc (len3, r3, pub skb))) then empty
else if check_tag (dec (att (frame@pred B), skb)) then
enc
(make2 (get1_na (dec (att (frame@pred B), skb)), nb, pub skb),
r2',
get1_id (dec (att (frame@pred B), skb))))>>



fa !<_,_>.
[> Line 905: (fa !(pair _ _)) [goal> Focused goal (1/1):
Systems: left:NSL_a/left, right:NSL/right (same for equivalences)
Variables:
H: [happens(B)]
IH: equiv(msg1, msg2, msg3, pub skb, ska, na, nb, r1', r3', frame@pred B)
msg1 := enc (diff(make1 (na, pub ska), len1), r1, pub skb)
msg2 := enc (len2, r2, pub ska)
msg3 := enc (diff(make3 (nb, na), len3), r3, pub skb)
----------------------------------------
0: enc (diff(make1 (na, pub ska), len1), r1, pub skb)
1: enc (len2, r2, pub ska)
2: enc (diff(make3 (nb, na), len3), r3, pub skb)
3: pub skb
4: ska
5: na
6: nb
7: r1'
8: r3'
9: frame@pred B
10: if (exec@pred B && true) then
(if (att (frame@pred B) =
diff(enc (make1 (na, pub ska), r1, pub skb),
enc (len1, r1, pub skb))) then
diff(enc (len2, r2, pub ska), enc (len2, r2, pub ska))
else if (att (frame@pred B) =
diff(enc (make3 (nb, na), r3, pub skb),
enc (len3, r3, pub skb))) then empty
else if check_tag (dec (att (frame@pred B), skb)) then
enc
(make2 (get1_na (dec (att (frame@pred B), skb)), nb, pub skb),
r2',
get1_id (dec (att (frame@pred B), skb))))



fa if _ then _.
[> Line 907: (fa (if _ _ zero)) [goal> Focused goal (1/1):
Systems: left:NSL_a/left, right:NSL/right (same for equivalences)
Variables:
H: [happens(B)]
IH: equiv(msg1, msg2, msg3, pub skb, ska, na, nb, r1', r3', frame@pred B)
msg1 := enc (diff(make1 (na, pub ska), len1), r1, pub skb)
msg2 := enc (len2, r2, pub ska)
msg3 := enc (diff(make3 (nb, na), len3), r3, pub skb)
----------------------------------------
0: enc (diff(make1 (na, pub ska), len1), r1, pub skb)
1: enc (len2, r2, pub ska)
2: enc (diff(make3 (nb, na), len3), r3, pub skb)
3: pub skb
4: ska
5: na
6: nb
7: r1'
8: r3'
9: frame@pred B
10: if (att (frame@pred B) =
diff(enc (make1 (na, pub ska), r1, pub skb), enc (len1, r1, pub skb)))
then diff(enc (len2, r2, pub ska), enc (len2, r2, pub ska))
else if (att (frame@pred B) =
diff(enc (make3 (nb, na), r3, pub skb), enc (len3, r3, pub skb)))
then empty
else if check_tag (dec (att (frame@pred B), skb)) then
enc
(make2 (get1_na (dec (att (frame@pred B), skb)), nb, pub skb),
r2',
get1_id (dec (att (frame@pred B), skb)))



have Hf := deduction_right (pred B).
[> Line 909: (have (.. := ...)) [goal> Focused goal (1/1):
Systems: left:NSL_a/left, right:NSL/right (same for equivalences)
Variables:
H: [happens(B)]
Hf: Let msg1 = enc (diff(make1 (na, pub ska), len1), r1, pub skb) in
Let msg2 = enc (len2, r2, pub ska) in
Let msg3 = enc (diff(make3 (nb, na), len3), r3, pub skb) in
Let fr =
fun (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub skb) msg1 msg2 msg3 ska na nb r3'#1 in
Let ex =
fun (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub skb) msg1 msg2 msg3 ska na nb r3'#2 in
Let pk =
fun (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub skb) msg1 msg2 msg3 ska na nb r3'#3 in
[happens(pred B)] ->
[pred B < B] ->
Exists (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message
[adv, glob]),
[f (pub skb) msg1 msg2 msg3 ska na nb r3' =
(frame@pred B, exec@pred B, if (A <= pred B) then input@A)]
IH: equiv(msg1, msg2, msg3, pub skb, ska, na, nb, r1', r3', frame@pred B)
msg1 := enc (diff(make1 (na, pub ska), len1), r1, pub skb)
msg2 := enc (len2, r2, pub ska)
msg3 := enc (diff(make3 (nb, na), len3), r3, pub skb)
----------------------------------------
0: enc (diff(make1 (na, pub ska), len1), r1, pub skb)
1: enc (len2, r2, pub ska)
2: enc (diff(make3 (nb, na), len3), r3, pub skb)
3: pub skb
4: ska
5: na
6: nb
7: r1'
8: r3'
9: frame@pred B
10: if (att (frame@pred B) =
diff(enc (make1 (na, pub ska), r1, pub skb), enc (len1, r1, pub skb)))
then diff(enc (len2, r2, pub ska), enc (len2, r2, pub ska))
else if (att (frame@pred B) =
diff(enc (make3 (nb, na), r3, pub skb), enc (len3, r3, pub skb)))
then empty
else if check_tag (dec (att (frame@pred B), skb)) then
enc
(make2 (get1_na (dec (att (frame@pred B), skb)), nb, pub skb),
r2',
get1_id (dec (att (frame@pred B), skb)))



simpl ~zeta.
[> Line 911: (simpl ...) [goal> Focused goal (1/1):
Systems: left:NSL_a/left, right:NSL/right (same for equivalences)
Variables:
H: [happens(B)]
Hf: [happens(pred B)] ->
[pred B < B] ->
Exists (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message
[adv, glob]),
[f
(pub skb)
(enc (diff(make1 (na, pub ska), len1), r1, pub skb))
(enc (len2, r2, pub ska))
(enc (diff(make3 (nb, na), len3), r3, pub skb))
ska
na
nb
r3' =
(frame@pred B, exec@pred B, if (A <= pred B) then input@A)]
IH: equiv(msg1, msg2, msg3, pub skb, ska, na, nb, r1', r3', frame@pred B)
msg1 := enc (diff(make1 (na, pub ska), len1), r1, pub skb)
msg2 := enc (len2, r2, pub ska)
msg3 := enc (diff(make3 (nb, na), len3), r3, pub skb)
----------------------------------------
0: enc (diff(make1 (na, pub ska), len1), r1, pub skb)
1: enc (len2, r2, pub ska)
2: enc (diff(make3 (nb, na), len3), r3, pub skb)
3: pub skb
4: ska
5: na
6: nb
7: r1'
8: r3'
9: frame@pred B
10: if (att (frame@pred B) =
diff(enc (make1 (na, pub ska), r1, pub skb), enc (len1, r1, pub skb)))
then diff(enc (len2, r2, pub ska), enc (len2, r2, pub ska))
else if (att (frame@pred B) =
diff(enc (make3 (nb, na), r3, pub skb), enc (len3, r3, pub skb)))
then empty
else if check_tag (dec (att (frame@pred B), skb)) then
enc
(make2 (get1_na (dec (att (frame@pred B), skb)), nb, pub skb),
r2',
get1_id (dec (att (frame@pred B), skb)))



have Hap : happens(pred B) by auto.
[> Line 913: ((have ...); 1: by (auto ...)) [goal> Focused goal (1/1):
Systems: left:NSL_a/left, right:NSL/right (same for equivalences)
Variables:
H: [happens(B)]
Hap: [happens(pred B)]
Hf: [happens(pred B)] ->
[pred B < B] ->
Exists (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message
[adv, glob]),
[f
(pub skb)
(enc (diff(make1 (na, pub ska), len1), r1, pub skb))
(enc (len2, r2, pub ska))
(enc (diff(make3 (nb, na), len3), r3, pub skb))
ska
na
nb
r3' =
(frame@pred B, exec@pred B, if (A <= pred B) then input@A)]
IH: equiv(msg1, msg2, msg3, pub skb, ska, na, nb, r1', r3', frame@pred B)
msg1 := enc (diff(make1 (na, pub ska), len1), r1, pub skb)
msg2 := enc (len2, r2, pub ska)
msg3 := enc (diff(make3 (nb, na), len3), r3, pub skb)
----------------------------------------
0: enc (diff(make1 (na, pub ska), len1), r1, pub skb)
1: enc (len2, r2, pub ska)
2: enc (diff(make3 (nb, na), len3), r3, pub skb)
3: pub skb
4: ska
5: na
6: nb
7: r1'
8: r3'
9: frame@pred B
10: if (att (frame@pred B) =
diff(enc (make1 (na, pub ska), r1, pub skb), enc (len1, r1, pub skb)))
then diff(enc (len2, r2, pub ska), enc (len2, r2, pub ska))
else if (att (frame@pred B) =
diff(enc (make3 (nb, na), r3, pub skb), enc (len3, r3, pub skb)))
then empty
else if check_tag (dec (att (frame@pred B), skb)) then
enc
(make2 (get1_na (dec (att (frame@pred B), skb)), nb, pub skb),
r2',
get1_id (dec (att (frame@pred B), skb)))



apply Hf in Hap; 1: auto.
[> Line 915: ((apply ... in Hap); 1: (auto ...)) [goal> Focused goal (1/1):
Systems: left:NSL_a/left, right:NSL/right (same for equivalences)
Variables:
H: [happens(B)]
Hap: Exists (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message
[adv, glob]),
[f
(pub skb)
(enc (diff(make1 (na, pub ska), len1), r1, pub skb))
(enc (len2, r2, pub ska))
(enc (diff(make3 (nb, na), len3), r3, pub skb))
ska
na
nb
r3' =
(frame@pred B, exec@pred B, if (A <= pred B) then input@A)]
Hf: [happens(pred B)] ->
[pred B < B] ->
Exists (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message
[adv, glob]),
[f
(pub skb)
(enc (diff(make1 (na, pub ska), len1), r1, pub skb))
(enc (len2, r2, pub ska))
(enc (diff(make3 (nb, na), len3), r3, pub skb))
ska
na
nb
r3' =
(frame@pred B, exec@pred B, if (A <= pred B) then input@A)]
IH: equiv(msg1, msg2, msg3, pub skb, ska, na, nb, r1', r3', frame@pred B)
msg1 := enc (diff(make1 (na, pub ska), len1), r1, pub skb)
msg2 := enc (len2, r2, pub ska)
msg3 := enc (diff(make3 (nb, na), len3), r3, pub skb)
----------------------------------------
0: enc (diff(make1 (na, pub ska), len1), r1, pub skb)
1: enc (len2, r2, pub ska)
2: enc (diff(make3 (nb, na), len3), r3, pub skb)
3: pub skb
4: ska
5: na
6: nb
7: r1'
8: r3'
9: frame@pred B
10: if (att (frame@pred B) =
diff(enc (make1 (na, pub ska), r1, pub skb), enc (len1, r1, pub skb)))
then diff(enc (len2, r2, pub ska), enc (len2, r2, pub ska))
else if (att (frame@pred B) =
diff(enc (make3 (nb, na), r3, pub skb), enc (len3, r3, pub skb)))
then empty
else if check_tag (dec (att (frame@pred B), skb)) then
enc
(make2 (get1_na (dec (att (frame@pred B), skb)), nb, pub skb),
r2',
get1_id (dec (att (frame@pred B), skb)))



clear Hf.
[> Line 917: (clear Hf) [goal> Focused goal (1/1):
Systems: left:NSL_a/left, right:NSL/right (same for equivalences)
Variables:
H: [happens(B)]
Hap: Exists (f:message ->
message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message
[adv, glob]),
[f
(pub skb)
(enc (diff(make1 (na, pub ska), len1), r1, pub skb))
(enc (len2, r2, pub ska))
(enc (diff(make3 (nb, na), len3), r3, pub skb))
ska
na
nb
r3' =
(frame@pred B, exec@pred B, if (A <= pred B) then input@A)]
IH: equiv(msg1, msg2, msg3, pub skb, ska, na, nb, r1', r3', frame@pred B)
msg1 := enc (diff(make1 (na, pub ska), len1), r1, pub skb)
msg2 := enc (len2, r2, pub ska)
msg3 := enc (diff(make3 (nb, na), len3), r3, pub skb)
----------------------------------------
0: enc (diff(make1 (na, pub ska), len1), r1, pub skb)
1: enc (len2, r2, pub ska)
2: enc (diff(make3 (nb, na), len3), r3, pub skb)
3: pub skb
4: ska
5: na
6: nb
7: r1'
8: r3'
9: frame@pred B
10: if (att (frame@pred B) =
diff(enc (make1 (na, pub ska), r1, pub skb), enc (len1, r1, pub skb)))
then diff(enc (len2, r2, pub ska), enc (len2, r2, pub ska))
else if (att (frame@pred B) =
diff(enc (make3 (nb, na), r3, pub skb), enc (len3, r3, pub skb)))
then empty
else if check_tag (dec (att (frame@pred B), skb)) then
enc
(make2 (get1_na (dec (att (frame@pred B), skb)), nb, pub skb),
r2',
get1_id (dec (att (frame@pred B), skb)))



destruct Hap as [f Hf].
[> Line 919: (destruct Hap, [f Hf]) [goal> Focused goal (1/1):
Systems: left:NSL_a/left, right:NSL/right (same for equivalences)
Variables:
f:message ->
message ->
message ->
message ->
message -> message -> message -> message -> message * bool * message
[adv, glob]
H: [happens(B)]
Hf: [f
(pub skb)
(enc (diff(make1 (na, pub ska), len1), r1, pub skb))
(enc (len2, r2, pub ska))
(enc (diff(make3 (nb, na), len3), r3, pub skb))
ska
na
nb
r3' =
(frame@pred B, exec@pred B, if (A <= pred B) then input@A)]
IH: equiv(msg1, msg2, msg3, pub skb, ska, na, nb, r1', r3', frame@pred B)
msg1 := enc (diff(make1 (na, pub ska), len1), r1, pub skb)
msg2 := enc (len2, r2, pub ska)
msg3 := enc (diff(make3 (nb, na), len3), r3, pub skb)
----------------------------------------
0: enc (diff(make1 (na, pub ska), len1), r1, pub skb)
1: enc (len2, r2, pub ska)
2: enc (diff(make3 (nb, na), len3), r3, pub skb)
3: pub skb
4: ska
5: na
6: nb
7: r1'
8: r3'
9: frame@pred B
10: if (att (frame@pred B) =
diff(enc (make1 (na, pub ska), r1, pub skb), enc (len1, r1, pub skb)))
then diff(enc (len2, r2, pub ska), enc (len2, r2, pub ska))
else if (att (frame@pred B) =
diff(enc (make3 (nb, na), r3, pub skb), enc (len3, r3, pub skb)))
then empty
else if check_tag (dec (att (frame@pred B), skb)) then
enc
(make2 (get1_na (dec (att (frame@pred B), skb)), nb, pub skb),
r2',
get1_id (dec (att (frame@pred B), skb)))



assert frame@pred B = (f (pub skb) msg1 msg2 msg3 ska na nb r3')#1 as ->
by rewrite Hf.
[> Line 923: ((have ...); 1: by (rewrite ...)) [goal> Focused goal (1/1):
Systems: left:NSL_a/left, right:NSL/right (same for equivalences)
Variables:
f:message ->
message ->
message ->
message ->
message -> message -> message -> message -> message * bool * message
[adv, glob]
H: [happens(B)]
Hf: [f
(pub skb)
(enc (diff(make1 (na, pub ska), len1), r1, pub skb))
(enc (len2, r2, pub ska))
(enc (diff(make3 (nb, na), len3), r3, pub skb))
ska
na
nb
r3' =
(frame@pred B, exec@pred B, if (A <= pred B) then input@A)]
IH: equiv(msg1, msg2, msg3, pub skb, ska, na, nb, r1', r3', frame@pred B)
msg1 := enc (diff(make1 (na, pub ska), len1), r1, pub skb)
msg2 := enc (len2, r2, pub ska)
msg3 := enc (diff(make3 (nb, na), len3), r3, pub skb)
----------------------------------------
0: enc (diff(make1 (na, pub ska), len1), r1, pub skb)
1: enc (len2, r2, pub ska)
2: enc (diff(make3 (nb, na), len3), r3, pub skb)
3: pub skb
4: ska
5: na
6: nb
7: r1'
8: r3'
9: f (pub skb) msg1 msg2 msg3 ska na nb r3'#1
10: if (att (f (pub skb) msg1 msg2 msg3 ska na nb r3'#1) =
diff(enc (make1 (na, pub ska), r1, pub skb), enc (len1, r1, pub skb)))
then diff(enc (len2, r2, pub ska), enc (len2, r2, pub ska))
else if (att (f (pub skb) msg1 msg2 msg3 ska na nb r3'#1) =
diff(enc (make3 (nb, na), r3, pub skb), enc (len3, r3, pub skb)))
then empty
else if check_tag
(dec (att (f (pub skb) msg1 msg2 msg3 ska na nb r3'#1), skb))
then
enc
(make2
(get1_na
(dec (att (f (pub skb) msg1 msg2 msg3 ska na nb r3'#1), skb)),
nb,
pub skb),
r2',
get1_id
(dec (att (f (pub skb) msg1 msg2 msg3 ska na nb r3'#1), skb)))



rewrite /msg1 /msg2 /msg3.
[> Line 925: (rewrite ... ... ...) [goal> Focused goal (1/1):
Systems: left:NSL_a/left, right:NSL/right (same for equivalences)
Variables:
f:message ->
message ->
message ->
message ->
message -> message -> message -> message -> message * bool * message
[adv, glob]
H: [happens(B)]
Hf: [f
(pub skb)
(enc (diff(make1 (na, pub ska), len1), r1, pub skb))
(enc (len2, r2, pub ska))
(enc (diff(make3 (nb, na), len3), r3, pub skb))
ska
na
nb
r3' =
(frame@pred B, exec@pred B, if (A <= pred B) then input@A)]
IH: equiv(msg1, msg2, msg3, pub skb, ska, na, nb, r1', r3', frame@pred B)
msg1 := enc (diff(make1 (na, pub ska), len1), r1, pub skb)
msg2 := enc (len2, r2, pub ska)
msg3 := enc (diff(make3 (nb, na), len3), r3, pub skb)
----------------------------------------
0: enc (diff(make1 (na, pub ska), len1), r1, pub skb)
1: enc (len2, r2, pub ska)
2: enc (diff(make3 (nb, na), len3), r3, pub skb)
3: pub skb
4: ska
5: na
6: nb
7: r1'
8: r3'
9: f
(pub skb)
(enc (diff(make1 (na, pub ska), len1), r1, pub skb))
(enc (len2, r2, pub ska))
(enc (diff(make3 (nb, na), len3), r3, pub skb))
ska
na
nb
r3'#1
10: if (att
(f
(pub skb)
(enc (diff(make1 (na, pub ska), len1), r1, pub skb))
(enc (len2, r2, pub ska))
(enc (diff(make3 (nb, na), len3), r3, pub skb))
ska
na
nb
r3'#1) =
diff(enc (make1 (na, pub ska), r1, pub skb), enc (len1, r1, pub skb)))
then diff(enc (len2, r2, pub ska), enc (len2, r2, pub ska))
else if (att
(f
(pub skb)
(enc (diff(make1 (na, pub ska), len1), r1, pub skb))
(enc (len2, r2, pub ska))
(enc (diff(make3 (nb, na), len3), r3, pub skb))
ska
na
nb
r3'#1) =
diff(enc (make3 (nb, na), r3, pub skb), enc (len3, r3, pub skb)))
then empty
else if check_tag
(dec
(att
(f
(pub skb)
(enc (diff(make1 (na, pub ska), len1), r1, pub skb))
(enc (len2, r2, pub ska))
(enc (diff(make3 (nb, na), len3), r3, pub skb))
ska
na
nb
r3'#1),
skb)) then
enc
(make2
(get1_na
(dec
(att
(f
(pub skb)
(enc (diff(make1 (na, pub ska), len1), r1, pub skb))
(enc (len2, r2, pub ska))
(enc (diff(make3 (nb, na), len3), r3, pub skb))
ska
na
nb
r3'#1),
skb)),
nb,
pub skb),
r2',
get1_id
(dec
(att
(f
(pub skb)
(enc (diff(make1 (na, pub ska), len1), r1, pub skb))
(enc (len2, r2, pub ska))
(enc (diff(make3 (nb, na), len3), r3, pub skb))
ska
na
nb
r3'#1),
skb)))



crypto CCA2 (key:skb) => //.
[> Line 927: ((crypto ...);(intro //)) Direct bi-deduction sub-goal (assuming recursive calls are bi-deducible):


(enc (diff(make1 (na, pub ska), len1), r1, pub skb),
enc (len2, r2, pub ska),
enc (diff(make3 (nb, na), len3), r3, pub skb),
pub skb,
ska,
na,
nb,
r1',
r3',
f
(pub skb)
(enc (diff(make1 (na, pub ska), len1), r1, pub skb))
(enc (len2, r2, pub ska))
(enc (diff(make3 (nb, na), len3), r3, pub skb))
ska
na
nb
r3'#1,
if (att
(f
(pub skb)
(enc (diff(make1 (na, pub ska), len1), r1, pub skb))
(enc (len2, r2, pub ska))
(enc (diff(make3 (nb, na), len3), r3, pub skb))
ska
na
nb
r3'#1) =
diff(enc (make1 (na, pub ska), r1, pub skb), enc (len1, r1, pub skb)))
then diff(enc (len2, r2, pub ska), enc (len2, r2, pub ska))
else if (att
(f
(pub skb)
(enc (diff(make1 (na, pub ska), len1), r1, pub skb))
(enc (len2, r2, pub ska))
(enc (diff(make3 (nb, na), len3), r3, pub skb))
ska
na
nb
r3'#1) =
diff(enc (make3 (nb, na), r3, pub skb), enc (len3, r3, pub skb)))
then empty
else if check_tag
(dec
(att
(f
(pub skb)
(enc (diff(make1 (na, pub ska), len1), r1, pub skb))
(enc (len2, r2, pub ska))
(enc (diff(make3 (nb, na), len3), r3, pub skb))
ska
na
nb
r3'#1),
skb)) then
enc
(make2
(get1_na
(dec
(att
(f
(pub skb)
(enc (diff(make1 (na, pub ska), len1), r1, pub skb))
(enc (len2, r2, pub ska))
(enc (diff(make3 (nb, na), len3), r3, pub skb))
ska
na
nb
r3'#1),
skb)),
nb,
pub skb),
r2',
get1_id
(dec
(att
(f
(pub skb)
(enc (diff(make1 (na, pub ska), len1), r1, pub skb))
(enc (len2, r2, pub ska))
(enc (diff(make3 (nb, na), len3), r3, pub skb))
ska
na
nb
r3'#1),
skb))))

Bi-deduction sub-goals for recursive calls:


Constraints are:
{ r1 , L }
{ r3 , L }
{ r2' , A |
check_tag
(dec
(att
(f
(pub skb)
(enc (diff(make1 (na, pub ska), len1), r1, pub skb))
(enc (len2, r2, pub ska))
(enc (diff(make3 (nb, na), len3), r3, pub skb))
ska
na
nb
r3'#1),
skb)) &&
not
(att
(f
(pub skb)
(enc (diff(make1 (na, pub ska), len1), r1, pub skb))
(enc (len2, r2, pub ska))
(enc (diff(make3 (nb, na), len3), r3, pub skb))
ska
na
nb
r3'#1) =
diff(enc (make3 (nb, na), r3, pub skb), enc (len3, r3, pub skb))) &&
not
(att
(f
(pub skb)
(enc (diff(make1 (na, pub ska), len1), r1, pub skb))
(enc (len2, r2, pub ska))
(enc (diff(make3 (nb, na), len3), r3, pub skb))
ska
na
nb
r3'#1) =
diff(enc (make1 (na, pub ska), r1, pub skb),
enc (len1, r1, pub skb))) }
{ r3' , A }
{ r1' , A }
{ nb , A }
{ r2 , A }
{ ska , A }
{ na , A }
{ skb , Gkey }
Constraints subgoals are:
Oracle subgoals are:
not
(att
(f
(pub skb)
(enc (diff(make1 (na, pub ska), len1), r1, pub skb))
(enc (len2, r2, pub ska))
(enc (diff(make3 (nb, na), len3), r3, pub skb))
ska
na
nb
r3'#1) =
diff(enc (make3 (nb, na), r3, pub skb), enc (len3, r3, pub skb))) &&
not
(att
(f
(pub skb)
(enc (diff(make1 (na, pub ska), len1), r1, pub skb))
(enc (len2, r2, pub ska))
(enc (diff(make3 (nb, na), len3), r3, pub skb))
ska
na
nb
r3'#1) =
diff(enc (make1 (na, pub ska), r1, pub skb), enc (len1, r1, pub skb))) =>
not
(att
(f
(pub skb)
(enc (diff(make1 (na, pub ska), len1), r1, pub skb))
(enc (len2, r2, pub ska))
(enc (diff(make3 (nb, na), len3), r3, pub skb))
ska
na
nb
r3'#1) =
diff(enc (make3 (nb, na), r3, pub skb), enc (len3, r3, pub skb))) &&
not
(att
(f
(pub skb)
(enc (diff(make1 (na, pub ska), len1), r1, pub skb))
(enc (len2, r2, pub ska))
(enc (diff(make3 (nb, na), len3), r3, pub skb))
ska
na
nb
r3'#1) =
diff(enc (make1 (na, pub ska), r1, pub skb), enc (len1, r1, pub skb))) =>
att
(f
(pub skb)
(enc (diff(make1 (na, pub ska), len1), r1, pub skb))
(enc (len2, r2, pub ska))
(enc (diff(make3 (nb, na), len3), r3, pub skb))
ska
na
nb
r3'#1) <>
enc (diff(make1 (na, pub ska), len1), r1, pub skb)
not
(att
(f
(pub skb)
(enc (diff(make1 (na, pub ska), len1), r1, pub skb))
(enc (len2, r2, pub ska))
(enc (diff(make3 (nb, na), len3), r3, pub skb))
ska
na
nb
r3'#1) =
diff(enc (make3 (nb, na), r3, pub skb), enc (len3, r3, pub skb))) &&
not
(att
(f
(pub skb)
(enc (diff(make1 (na, pub ska), len1), r1, pub skb))
(enc (len2, r2, pub ska))
(enc (diff(make3 (nb, na), len3), r3, pub skb))
ska
na
nb
r3'#1) =
diff(enc (make1 (na, pub ska), r1, pub skb), enc (len1, r1, pub skb))) =>
not
(att
(f
(pub skb)
(enc (diff(make1 (na, pub ska), len1), r1, pub skb))
(enc (len2, r2, pub ska))
(enc (diff(make3 (nb, na), len3), r3, pub skb))
ska
na
nb
r3'#1) =
diff(enc (make3 (nb, na), r3, pub skb), enc (len3, r3, pub skb))) &&
not
(att
(f
(pub skb)
(enc (diff(make1 (na, pub ska), len1), r1, pub skb))
(enc (len2, r2, pub ska))
(enc (diff(make3 (nb, na), len3), r3, pub skb))
ska
na
nb
r3'#1) =
diff(enc (make1 (na, pub ska), r1, pub skb), enc (len1, r1, pub skb))) =>
att
(f
(pub skb)
(enc (diff(make1 (na, pub ska), len1), r1, pub skb))
(enc (len2, r2, pub ska))
(enc (diff(make3 (nb, na), len3), r3, pub skb))
ska
na
nb
r3'#1) <>
enc (diff(make3 (nb, na), len3), r3, pub skb)
zeroes (make3 (nb, na)) = zeroes len3
zeroes (make1 (na, pub ska)) = zeroes len1
Final memory is:
{log -> [{ enc (diff(make3 (nb, na), len3), r3, pub skb) | true },
{ enc (diff(make1 (na, pub ska), len1), r1, pub skb) | true } ] }
[goal> Focused goal (1/4):
System: left:NSL_a/left, right:NSL/right (same for equivalences)
Variables:
f:message ->
message ->
message ->
message ->
message -> message -> message -> message -> message * bool * message
[adv, glob]
H: [happens(B)]
Hf: [f
(pub skb)
(enc (diff(make1 (na, pub ska), len1), r1, pub skb))
(enc (len2, r2, pub ska))
(enc (diff(make3 (nb, na), len3), r3, pub skb))
ska
na
nb
r3' =
(frame@pred B, exec@pred B, if (A <= pred B) then input@A)]
IH: equiv(msg1, msg2, msg3, pub skb, ska, na, nb, r1', r3', frame@pred B)
msg1 := enc (diff(make1 (na, pub ska), len1), r1, pub skb)
msg2 := enc (len2, r2, pub ska)
msg3 := enc (diff(make3 (nb, na), len3), r3, pub skb)
----------------------------------------
not
(att
(f
(pub skb)
(enc (diff(make1 (na, pub ska), len1), r1, pub skb))
(enc (len2, r2, pub ska))
(enc (diff(make3 (nb, na), len3), r3, pub skb))
ska
na
nb
r3'#1) =
diff(enc (make3 (nb, na), r3, pub skb), enc (len3, r3, pub skb))) &&
not
(att
(f
(pub skb)
(enc (diff(make1 (na, pub ska), len1), r1, pub skb))
(enc (len2, r2, pub ska))
(enc (diff(make3 (nb, na), len3), r3, pub skb))
ska
na
nb
r3'#1) =
diff(enc (make1 (na, pub ska), r1, pub skb), enc (len1, r1, pub skb))) =>
not
(att
(f
(pub skb)
(enc (diff(make1 (na, pub ska), len1), r1, pub skb))
(enc (len2, r2, pub ska))
(enc (diff(make3 (nb, na), len3), r3, pub skb))
ska
na
nb
r3'#1) =
diff(enc (make3 (nb, na), r3, pub skb), enc (len3, r3, pub skb))) &&
not
(att
(f
(pub skb)
(enc (diff(make1 (na, pub ska), len1), r1, pub skb))
(enc (len2, r2, pub ska))
(enc (diff(make3 (nb, na), len3), r3, pub skb))
ska
na
nb
r3'#1) =
diff(enc (make1 (na, pub ska), r1, pub skb), enc (len1, r1, pub skb))) =>
att
(f
(pub skb)
(enc (diff(make1 (na, pub ska), len1), r1, pub skb))
(enc (len2, r2, pub ska))
(enc (diff(make3 (nb, na), len3), r3, pub skb))
ska
na
nb
r3'#1) <>
enc (diff(make1 (na, pub ska), len1), r1, pub skb)


* by simpl ~flags:[diffr].
[> Line 929: by (simpl ...) [goal> Focused goal (1/3):
System: left:NSL_a/left, right:NSL/right (same for equivalences)
Variables:
f:message ->
message ->
message ->
message ->
message -> message -> message -> message -> message * bool * message
[adv, glob]
H: [happens(B)]
Hf: [f
(pub skb)
(enc (diff(make1 (na, pub ska), len1), r1, pub skb))
(enc (len2, r2, pub ska))
(enc (diff(make3 (nb, na), len3), r3, pub skb))
ska
na
nb
r3' =
(frame@pred B, exec@pred B, if (A <= pred B) then input@A)]
IH: equiv(msg1, msg2, msg3, pub skb, ska, na, nb, r1', r3', frame@pred B)
msg1 := enc (diff(make1 (na, pub ska), len1), r1, pub skb)
msg2 := enc (len2, r2, pub ska)
msg3 := enc (diff(make3 (nb, na), len3), r3, pub skb)
----------------------------------------
not
(att
(f
(pub skb)
(enc (diff(make1 (na, pub ska), len1), r1, pub skb))
(enc (len2, r2, pub ska))
(enc (diff(make3 (nb, na), len3), r3, pub skb))
ska
na
nb
r3'#1) =
diff(enc (make3 (nb, na), r3, pub skb), enc (len3, r3, pub skb))) &&
not
(att
(f
(pub skb)
(enc (diff(make1 (na, pub ska), len1), r1, pub skb))
(enc (len2, r2, pub ska))
(enc (diff(make3 (nb, na), len3), r3, pub skb))
ska
na
nb
r3'#1) =
diff(enc (make1 (na, pub ska), r1, pub skb), enc (len1, r1, pub skb))) =>
not
(att
(f
(pub skb)
(enc (diff(make1 (na, pub ska), len1), r1, pub skb))
(enc (len2, r2, pub ska))
(enc (diff(make3 (nb, na), len3), r3, pub skb))
ska
na
nb
r3'#1) =
diff(enc (make3 (nb, na), r3, pub skb), enc (len3, r3, pub skb))) &&
not
(att
(f
(pub skb)
(enc (diff(make1 (na, pub ska), len1), r1, pub skb))
(enc (len2, r2, pub ska))
(enc (diff(make3 (nb, na), len3), r3, pub skb))
ska
na
nb
r3'#1) =
diff(enc (make1 (na, pub ska), r1, pub skb), enc (len1, r1, pub skb))) =>
att
(f
(pub skb)
(enc (diff(make1 (na, pub ska), len1), r1, pub skb))
(enc (len2, r2, pub ska))
(enc (diff(make3 (nb, na), len3), r3, pub skb))
ska
na
nb
r3'#1) <>
enc (diff(make3 (nb, na), len3), r3, pub skb)


* by simpl ~flags:[diffr].
[> Line 931: by (simpl ...) [goal> Focused goal (1/2):
System: left:NSL_a/left, right:NSL/right (same for equivalences)
Variables:
f:message ->
message ->
message ->
message ->
message -> message -> message -> message -> message * bool * message
[adv, glob]
H: [happens(B)]
Hf: [f
(pub skb)
(enc (diff(make1 (na, pub ska), len1), r1, pub skb))
(enc (len2, r2, pub ska))
(enc (diff(make3 (nb, na), len3), r3, pub skb))
ska
na
nb
r3' =
(frame@pred B, exec@pred B, if (A <= pred B) then input@A)]
IH: equiv(msg1, msg2, msg3, pub skb, ska, na, nb, r1', r3', frame@pred B)
msg1 := enc (diff(make1 (na, pub ska), len1), r1, pub skb)
msg2 := enc (len2, r2, pub ska)
msg3 := enc (diff(make3 (nb, na), len3), r3, pub skb)
----------------------------------------
zeroes (make3 (nb, na)) = zeroes len3


* by rewrite len3.
[> Line 933: by (rewrite ...) [goal> Focused goal (1/1):
System: left:NSL_a/left, right:NSL/right (same for equivalences)
Variables:
f:message ->
message ->
message ->
message ->
message -> message -> message -> message -> message * bool * message
[adv, glob]
H: [happens(B)]
Hf: [f
(pub skb)
(enc (diff(make1 (na, pub ska), len1), r1, pub skb))
(enc (len2, r2, pub ska))
(enc (diff(make3 (nb, na), len3), r3, pub skb))
ska
na
nb
r3' =
(frame@pred B, exec@pred B, if (A <= pred B) then input@A)]
IH: equiv(msg1, msg2, msg3, pub skb, ska, na, nb, r1', r3', frame@pred B)
msg1 := enc (diff(make1 (na, pub ska), len1), r1, pub skb)
msg2 := enc (len2, r2, pub ska)
msg3 := enc (diff(make3 (nb, na), len3), r3, pub skb)
----------------------------------------
zeroes (make1 (na, pub ska)) = zeroes len1


* by rewrite len1.
[> Line 935: by (rewrite ...) [goal> lemma equiv_right is proved


Qed.
global lemma [left:NSL_a/left, right:NSL/right (same for equivalences)] equiv_right :
Forall (t:timestamp[const, glob]),
Let msg1 = enc (diff(make1 (na, pub ska), len1), r1, pub skb) in
Let msg2 = enc (len2, r2, pub ska) in
Let msg3 = enc (diff(make3 (nb, na), len3), r3, pub skb) in
[happens(t)] ->
equiv(msg1, msg2, msg3, pub skb, ska, na, nb, r1', r3', frame@t)
Exiting proof mode.



(* ----------------------------------------------------------------------- *)

(* Observational equivalence between NSL/left and NSL_a/left. *)
global lemma [NSL/left,NSL_a/left] equiv_left (t:timestamp[const]) :
Let msg1 = enc(make1(na,pub(ska)),r1,pub skb) in
Let msg2 = enc(diff((make2(na, nb, pub skb)),len2),r2,pub ska) in
Let msg3 = enc(make3(nb,na),r3,pub skb) in
[happens(t)] ->
equiv(msg1,msg2,msg3, pub ska,
skb, na, nb, r1', r2',
frame@t).
Goal equiv_left :
forall t:timestamp[const, glob],
Let msg1 = enc (make1 (na, pub ska), r1, pub skb) in
Let msg2 = enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska) in
Let msg3 = enc (make3 (nb, na), r3, pub skb) in
[happens(t)] ->
equiv(msg1, msg2, msg3, pub ska, skb, na, nb, r1', r2', frame@t)

Proof.
[goal> Focused goal (1/1):
Systems: left:NSL/left, right:NSL_a/left (same for equivalences)
Variables: t:timestamp[const, glob]
----------------------------------------
Let msg1 = enc (make1 (na, pub ska), r1, pub skb) in
Let msg2 = enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska) in
Let msg3 = enc (make3 (nb, na), r3, pub skb) in
[happens(t)] ->
equiv(msg1, msg2, msg3, pub ska, skb, na, nb, r1', r2', frame@t)


intro *.
[> Line 965: (intro *) [goal> Focused goal (1/1):
Systems: left:NSL/left, right:NSL_a/left (same for equivalences)
Variables: t:timestamp[const, glob]
H: [happens(t)]
msg1 := enc (make1 (na, pub ska), r1, pub skb)
msg2 := enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska)
msg3 := enc (make3 (nb, na), r3, pub skb)
----------------------------------------
0: msg1
1: msg2
2: msg3
3: pub ska
4: skb
5: na
6: nb
7: r1'
8: r2'
9: frame@t



induction t.
[> Line 967: (induction t) [goal> Focused goal (1/5):
Systems: left:NSL/left, right:NSL_a/left (same for equivalences)
Variables:
H: [happens(init)]
msg1 := enc (make1 (na, pub ska), r1, pub skb)
msg2 := enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska)
msg3 := enc (make3 (nb, na), r3, pub skb)
----------------------------------------
0: msg1
1: msg2
2: msg3
3: pub ska
4: skb
5: na
6: nb
7: r1'
8: r2'
9: frame@init



+ rewrite /*.
[> Line 969: (rewrite ...) [goal> Focused goal (1/5):
Systems: left:NSL/left, right:NSL_a/left (same for equivalences)
Variables:
H: [happens(init)]
msg1 := enc (make1 (na, pub ska), r1, pub skb)
msg2 := enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska)
msg3 := enc (make3 (nb, na), r3, pub skb)
----------------------------------------
0: enc (make1 (na, pub ska), r1, pub skb)
1: enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska)
2: enc (make3 (nb, na), r3, pub skb)
3: pub ska
4: skb
5: na
6: nb
7: r1'
8: r2'



crypto CCA2 (key :ska).
[> Line 971: (crypto ...) Direct bi-deduction sub-goal (assuming recursive calls are bi-deducible):


(enc (make1 (na, pub ska), r1, pub skb),
enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska),
enc (make3 (nb, na), r3, pub skb),
pub ska,
skb,
na,
nb,
r1',
r2')

Bi-deduction sub-goals for recursive calls:


Constraints are:
{ r2 , L }
{ r2' , A }
{ r1' , A }
{ r3 , A }
{ nb , A }
{ skb , A }
{ r1 , A }
{ na , A }
{ ska , Gkey }
Constraints subgoals are:
Oracle subgoals are: zeroes (make2 (na, nb, pub skb)) = zeroes len2
Final memory is:
{log -> [{ enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska) | true } ] }
[goal> Focused goal (1/5):
System: left:NSL/left, right:NSL_a/left (same for equivalences)
Variables:
H: [happens(init)]
msg1 := enc (make1 (na, pub ska), r1, pub skb)
msg2 := enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska)
msg3 := enc (make3 (nb, na), r3, pub skb)
----------------------------------------
zeroes (make2 (na, nb, pub skb)) = zeroes len2


by rewrite len2.
[> Line 973: by (rewrite ...) [goal> Focused goal (1/4):
Systems: left:NSL/left, right:NSL_a/left (same for equivalences)
Variables:
H: [happens(PUB)]
IH: equiv(msg1, msg2, msg3, pub ska, skb, na, nb, r1', r2', frame@pred PUB)
msg1 := enc (make1 (na, pub ska), r1, pub skb)
msg2 := enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska)
msg3 := enc (make3 (nb, na), r3, pub skb)
----------------------------------------
0: msg1
1: msg2
2: msg3
3: pub ska
4: skb
5: na
6: nb
7: r1'
8: r2'
9: frame@PUB



+ rewrite /*in *.
[> Line 975: (rewrite ... in *) [goal> Focused goal (1/4):
Systems: left:NSL/left, right:NSL_a/left (same for equivalences)
Variables:
H: [happens(PUB)]
IH: equiv(enc (make1 (na, pub ska), r1, pub skb),
enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska),
enc (make3 (nb, na), r3, pub skb), pub ska, skb, na, nb, r1', r2',
frame@pred PUB)
msg1 := enc (make1 (na, pub ska), r1, pub skb)
msg2 := enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska)
msg3 := enc (make3 (nb, na), r3, pub skb)
----------------------------------------
0: enc (make1 (na, pub ska), r1, pub skb)
1: enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska)
2: enc (make3 (nb, na), r3, pub skb)
3: pub ska
4: skb
5: na
6: nb
7: r1'
8: r2'
9: <frame@pred PUB,
<of_bool (exec@pred PUB && true),
if (exec@pred PUB && true) then <pub ska,pub skb>>>



apply IH.
[> Line 977: (apply ... ) [goal> Focused goal (1/3):
Systems: left:NSL/left, right:NSL_a/left (same for equivalences)
Variables:
H: [happens(A)]
IH: equiv(msg1, msg2, msg3, pub ska, skb, na, nb, r1', r2', frame@pred A)
msg1 := enc (make1 (na, pub ska), r1, pub skb)
msg2 := enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska)
msg3 := enc (make3 (nb, na), r3, pub skb)
----------------------------------------
0: msg1
1: msg2
2: msg3
3: pub ska
4: skb
5: na
6: nb
7: r1'
8: r2'
9: frame@A



+ rewrite /*in *.
[> Line 979: (rewrite ... in *) [goal> Focused goal (1/3):
Systems: left:NSL/left, right:NSL_a/left (same for equivalences)
Variables:
H: [happens(A)]
IH: equiv(enc (make1 (na, pub ska), r1, pub skb),
enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska),
enc (make3 (nb, na), r3, pub skb), pub ska, skb, na, nb, r1', r2',
frame@pred A)
msg1 := enc (make1 (na, pub ska), r1, pub skb)
msg2 := enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska)
msg3 := enc (make3 (nb, na), r3, pub skb)
----------------------------------------
0: enc (make1 (na, pub ska), r1, pub skb)
1: enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska)
2: enc (make3 (nb, na), r3, pub skb)
3: pub ska
4: skb
5: na
6: nb
7: r1'
8: r2'
9: <frame@pred A,
<of_bool (exec@pred A && true),
if (exec@pred A && true) then
(if (att (frame@pred A) = pub skb) then
diff(enc (make1 (na, pub ska), r1, pub skb),
enc (make1 (na, pub ska), r1, pub skb))
else enc (make1 (na, pub ska), r1', att (frame@pred A)))>>



apply IH.
[> Line 981: (apply ... ) [goal> Focused goal (1/2):
Systems: left:NSL/left, right:NSL_a/left (same for equivalences)
Variables:
H: [happens(A1)]
IH: equiv(msg1, msg2, msg3, pub ska, skb, na, nb, r1', r2', frame@pred A1)
msg1 := enc (make1 (na, pub ska), r1, pub skb)
msg2 := enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska)
msg3 := enc (make3 (nb, na), r3, pub skb)
----------------------------------------
0: msg1
1: msg2
2: msg3
3: pub ska
4: skb
5: na
6: nb
7: r1'
8: r2'
9: frame@A1



+ assert A < A1 by use depends_A_A1.
[> Line 983: ((have ...); 1: by (have ...)) [goal> Focused goal (1/2):
Systems: left:NSL/left, right:NSL_a/left (same for equivalences)
Variables:
H: [happens(A1)]
H0: [A < A1]
IH: equiv(msg1, msg2, msg3, pub ska, skb, na, nb, r1', r2', frame@pred A1)
msg1 := enc (make1 (na, pub ska), r1, pub skb)
msg2 := enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska)
msg3 := enc (make3 (nb, na), r3, pub skb)
----------------------------------------
0: msg1
1: msg2
2: msg3
3: pub ska
4: skb
5: na
6: nb
7: r1'
8: r2'
9: frame@A1



rewrite /*.
[> Line 985: (rewrite ...) [goal> Focused goal (1/2):
Systems: left:NSL/left, right:NSL_a/left (same for equivalences)
Variables:
H: [happens(A1)]
H0: [A < A1]
IH: equiv(msg1, msg2, msg3, pub ska, skb, na, nb, r1', r2', frame@pred A1)
msg1 := enc (make1 (na, pub ska), r1, pub skb)
msg2 := enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska)
msg3 := enc (make3 (nb, na), r3, pub skb)
----------------------------------------
0: enc (make1 (na, pub ska), r1, pub skb)
1: enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska)
2: enc (make3 (nb, na), r3, pub skb)
3: pub ska
4: skb
5: na
6: nb
7: r1'
8: r2'
9: <frame@pred A1,
<of_bool (exec@pred A1 && true),
if (exec@pred A1 && true) then
(if (att (frame@pred A1) =
diff(enc (make2 (na, nb, pub skb), r2, pub ska),
enc (len2, r2, pub ska))) then
(if (att (frame@pred A) = pub skb) then
<diff(enc (make3 (nb, na), r3, pub skb),
enc (make3 (nb, na), r3, pub skb)),<na,nb>>)
else if (get2_na (dec (att (frame@pred A1), ska)) = na &&
get2_id (dec (att (frame@pred A1), ska)) =
att (frame@pred A)) then
<enc
(make3 (get2_nb (dec (att (frame@pred A1), ska)), na),
r3',
att (frame@pred A)),
if (att (frame@pred A) = pub skb) then <na,nb>>)>>



fa !<_,_>.
[> Line 987: (fa !(pair _ _)) [goal> Focused goal (1/2):
Systems: left:NSL/left, right:NSL_a/left (same for equivalences)
Variables:
H: [happens(A1)]
H0: [A < A1]
IH: equiv(msg1, msg2, msg3, pub ska, skb, na, nb, r1', r2', frame@pred A1)
msg1 := enc (make1 (na, pub ska), r1, pub skb)
msg2 := enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska)
msg3 := enc (make3 (nb, na), r3, pub skb)
----------------------------------------
0: enc (make1 (na, pub ska), r1, pub skb)
1: enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska)
2: enc (make3 (nb, na), r3, pub skb)
3: pub ska
4: skb
5: na
6: nb
7: r1'
8: r2'
9: frame@pred A1
10: if (exec@pred A1 && true) then
(if (att (frame@pred A1) =
diff(enc (make2 (na, nb, pub skb), r2, pub ska),
enc (len2, r2, pub ska))) then
(if (att (frame@pred A) = pub skb) then
<diff(enc (make3 (nb, na), r3, pub skb),
enc (make3 (nb, na), r3, pub skb)),<na,nb>>)
else if (get2_na (dec (att (frame@pred A1), ska)) = na &&
get2_id (dec (att (frame@pred A1), ska)) = att (frame@pred A))
then
<enc
(make3 (get2_nb (dec (att (frame@pred A1), ska)), na),
r3',
att (frame@pred A)),
if (att (frame@pred A) = pub skb) then <na,nb>>)



fa if _ then _.
[> Line 989: (fa (if _ _ zero)) [goal> Focused goal (1/2):
Systems: left:NSL/left, right:NSL_a/left (same for equivalences)
Variables:
H: [happens(A1)]
H0: [A < A1]
IH: equiv(msg1, msg2, msg3, pub ska, skb, na, nb, r1', r2', frame@pred A1)
msg1 := enc (make1 (na, pub ska), r1, pub skb)
msg2 := enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska)
msg3 := enc (make3 (nb, na), r3, pub skb)
----------------------------------------
0: enc (make1 (na, pub ska), r1, pub skb)
1: enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska)
2: enc (make3 (nb, na), r3, pub skb)
3: pub ska
4: skb
5: na
6: nb
7: r1'
8: r2'
9: frame@pred A1
10: if (att (frame@pred A1) =
diff(enc (make2 (na, nb, pub skb), r2, pub ska),
enc (len2, r2, pub ska))) then
(if (att (frame@pred A) = pub skb) then
<diff(enc (make3 (nb, na), r3, pub skb),
enc (make3 (nb, na), r3, pub skb)),<na,nb>>)
else if (get2_na (dec (att (frame@pred A1), ska)) = na &&
get2_id (dec (att (frame@pred A1), ska)) = att (frame@pred A))
then
<enc
(make3 (get2_nb (dec (att (frame@pred A1), ska)), na),
r3',
att (frame@pred A)),if (att (frame@pred A) = pub skb) then <na,nb>>



have Hf := deduction_left (pred A1).
[> Line 991: (have (.. := ...)) [goal> Focused goal (1/2):
Systems: left:NSL/left, right:NSL_a/left (same for equivalences)
Variables:
H: [happens(A1)]
H0: [A < A1]
Hf: Let msg1 = enc (make1 (na, pub ska), r1, pub skb) in
Let msg2 = enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska) in
Let msg3 = enc (make3 (nb, na), r3, pub skb) in
Let fr =
fun (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub ska) msg1 msg2 msg3 skb nb r2'#1 in
Let ex =
fun (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub ska) msg1 msg2 msg3 skb nb r2'#2 in
Let pk =
fun (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message) =>
f (pub ska) msg1 msg2 msg3 skb nb r2'#3 in
[happens(pred A1)] ->
[pred A1 < A1] ->
Exists (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message
[adv, glob]),
[f (pub ska) msg1 msg2 msg3 skb nb r2' =
(frame@pred A1, exec@pred A1, if (A <= pred A1) then input@A)]
IH: equiv(msg1, msg2, msg3, pub ska, skb, na, nb, r1', r2', frame@pred A1)
msg1 := enc (make1 (na, pub ska), r1, pub skb)
msg2 := enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska)
msg3 := enc (make3 (nb, na), r3, pub skb)
----------------------------------------
0: enc (make1 (na, pub ska), r1, pub skb)
1: enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska)
2: enc (make3 (nb, na), r3, pub skb)
3: pub ska
4: skb
5: na
6: nb
7: r1'
8: r2'
9: frame@pred A1
10: if (att (frame@pred A1) =
diff(enc (make2 (na, nb, pub skb), r2, pub ska),
enc (len2, r2, pub ska))) then
(if (att (frame@pred A) = pub skb) then
<diff(enc (make3 (nb, na), r3, pub skb),
enc (make3 (nb, na), r3, pub skb)),<na,nb>>)
else if (get2_na (dec (att (frame@pred A1), ska)) = na &&
get2_id (dec (att (frame@pred A1), ska)) = att (frame@pred A))
then
<enc
(make3 (get2_nb (dec (att (frame@pred A1), ska)), na),
r3',
att (frame@pred A)),if (att (frame@pred A) = pub skb) then <na,nb>>



simpl ~zeta.
[> Line 993: (simpl ...) [goal> Focused goal (1/2):
Systems: left:NSL/left, right:NSL_a/left (same for equivalences)
Variables:
H: [happens(A1)]
H0: [A < A1]
Hf: [happens(pred A1)] ->
[pred A1 < A1] ->
Exists (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message
[adv, glob]),
[f
(pub ska)
(enc (make1 (na, pub ska), r1, pub skb))
(enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska))
(enc (make3 (nb, na), r3, pub skb))
skb
nb
r2' =
(frame@pred A1, exec@pred A1, if (A <= pred A1) then input@A)]
IH: equiv(msg1, msg2, msg3, pub ska, skb, na, nb, r1', r2', frame@pred A1)
msg1 := enc (make1 (na, pub ska), r1, pub skb)
msg2 := enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska)
msg3 := enc (make3 (nb, na), r3, pub skb)
----------------------------------------
0: enc (make1 (na, pub ska), r1, pub skb)
1: enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska)
2: enc (make3 (nb, na), r3, pub skb)
3: pub ska
4: skb
5: na
6: nb
7: r1'
8: r2'
9: frame@pred A1
10: if (att (frame@pred A1) =
diff(enc (make2 (na, nb, pub skb), r2, pub ska),
enc (len2, r2, pub ska))) then
(if (att (frame@pred A) = pub skb) then
<diff(enc (make3 (nb, na), r3, pub skb),
enc (make3 (nb, na), r3, pub skb)),<na,nb>>)
else if (get2_na (dec (att (frame@pred A1), ska)) = na &&
get2_id (dec (att (frame@pred A1), ska)) = att (frame@pred A))
then
<enc
(make3 (get2_nb (dec (att (frame@pred A1), ska)), na),
r3',
att (frame@pred A)),if (att (frame@pred A) = pub skb) then <na,nb>>



have Hap : happens(pred A1) by auto.
[> Line 995: ((have ...); 1: by (auto ...)) [goal> Focused goal (1/2):
Systems: left:NSL/left, right:NSL_a/left (same for equivalences)
Variables:
H: [happens(A1)]
H0: [A < A1]
Hap: [happens(pred A1)]
Hf: [happens(pred A1)] ->
[pred A1 < A1] ->
Exists (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message
[adv, glob]),
[f
(pub ska)
(enc (make1 (na, pub ska), r1, pub skb))
(enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska))
(enc (make3 (nb, na), r3, pub skb))
skb
nb
r2' =
(frame@pred A1, exec@pred A1, if (A <= pred A1) then input@A)]
IH: equiv(msg1, msg2, msg3, pub ska, skb, na, nb, r1', r2', frame@pred A1)
msg1 := enc (make1 (na, pub ska), r1, pub skb)
msg2 := enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska)
msg3 := enc (make3 (nb, na), r3, pub skb)
----------------------------------------
0: enc (make1 (na, pub ska), r1, pub skb)
1: enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska)
2: enc (make3 (nb, na), r3, pub skb)
3: pub ska
4: skb
5: na
6: nb
7: r1'
8: r2'
9: frame@pred A1
10: if (att (frame@pred A1) =
diff(enc (make2 (na, nb, pub skb), r2, pub ska),
enc (len2, r2, pub ska))) then
(if (att (frame@pred A) = pub skb) then
<diff(enc (make3 (nb, na), r3, pub skb),
enc (make3 (nb, na), r3, pub skb)),<na,nb>>)
else if (get2_na (dec (att (frame@pred A1), ska)) = na &&
get2_id (dec (att (frame@pred A1), ska)) = att (frame@pred A))
then
<enc
(make3 (get2_nb (dec (att (frame@pred A1), ska)), na),
r3',
att (frame@pred A)),if (att (frame@pred A) = pub skb) then <na,nb>>



apply Hf in Hap.
[> Line 997: (apply ... in Hap) [goal> Focused goal (1/3):
System: left:NSL/left, right:NSL_a/left (same for equivalences)
Variables:
H: [happens(A1)]
H0: [A < A1]
Hap: [happens(pred A1)]
Hf: [happens(pred A1)] ->
[pred A1 < A1] ->
Exists (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message
[adv, glob]),
[f
(pub ska)
(enc (make1 (na, pub ska), r1, pub skb))
(enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska))
(enc (make3 (nb, na), r3, pub skb))
skb
nb
r2' =
(frame@pred A1, exec@pred A1, if (A <= pred A1) then input@A)]
IH: equiv(msg1, msg2, msg3, pub ska, skb, na, nb, r1', r2', frame@pred A1)
msg1 := enc (make1 (na, pub ska), r1, pub skb)
msg2 := enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska)
msg3 := enc (make3 (nb, na), r3, pub skb)
----------------------------------------
pred A1 < A1

auto. [> Line 997: (auto ...) [goal> Focused goal (1/2):
Systems: left:NSL/left, right:NSL_a/left (same for equivalences)
Variables:
H: [happens(A1)]
H0: [A < A1]
Hap: Exists (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message
[adv, glob]),
[f
(pub ska)
(enc (make1 (na, pub ska), r1, pub skb))
(enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska))
(enc (make3 (nb, na), r3, pub skb))
skb
nb
r2' =
(frame@pred A1, exec@pred A1, if (A <= pred A1) then input@A)]
Hf: [happens(pred A1)] ->
[pred A1 < A1] ->
Exists (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message
[adv, glob]),
[f
(pub ska)
(enc (make1 (na, pub ska), r1, pub skb))
(enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska))
(enc (make3 (nb, na), r3, pub skb))
skb
nb
r2' =
(frame@pred A1, exec@pred A1, if (A <= pred A1) then input@A)]
IH: equiv(msg1, msg2, msg3, pub ska, skb, na, nb, r1', r2', frame@pred A1)
msg1 := enc (make1 (na, pub ska), r1, pub skb)
msg2 := enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska)
msg3 := enc (make3 (nb, na), r3, pub skb)
----------------------------------------
0: enc (make1 (na, pub ska), r1, pub skb)
1: enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska)
2: enc (make3 (nb, na), r3, pub skb)
3: pub ska
4: skb
5: na
6: nb
7: r1'
8: r2'
9: frame@pred A1
10: if (att (frame@pred A1) =
diff(enc (make2 (na, nb, pub skb), r2, pub ska),
enc (len2, r2, pub ska))) then
(if (att (frame@pred A) = pub skb) then
<diff(enc (make3 (nb, na), r3, pub skb),
enc (make3 (nb, na), r3, pub skb)),<na,nb>>)
else if (get2_na (dec (att (frame@pred A1), ska)) = na &&
get2_id (dec (att (frame@pred A1), ska)) = att (frame@pred A))
then
<enc
(make3 (get2_nb (dec (att (frame@pred A1), ska)), na),
r3',
att (frame@pred A)),if (att (frame@pred A) = pub skb) then <na,nb>>



clear Hf.
[> Line 999: (clear Hf) [goal> Focused goal (1/2):
Systems: left:NSL/left, right:NSL_a/left (same for equivalences)
Variables:
H: [happens(A1)]
H0: [A < A1]
Hap: Exists (f:message ->
message ->
message ->
message ->
message -> message -> message -> message * bool * message
[adv, glob]),
[f
(pub ska)
(enc (make1 (na, pub ska), r1, pub skb))
(enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska))
(enc (make3 (nb, na), r3, pub skb))
skb
nb
r2' =
(frame@pred A1, exec@pred A1, if (A <= pred A1) then input@A)]
IH: equiv(msg1, msg2, msg3, pub ska, skb, na, nb, r1', r2', frame@pred A1)
msg1 := enc (make1 (na, pub ska), r1, pub skb)
msg2 := enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska)
msg3 := enc (make3 (nb, na), r3, pub skb)
----------------------------------------
0: enc (make1 (na, pub ska), r1, pub skb)
1: enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska)
2: enc (make3 (nb, na), r3, pub skb)
3: pub ska
4: skb
5: na
6: nb
7: r1'
8: r2'
9: frame@pred A1
10: if (att (frame@pred A1) =
diff(enc (make2 (na, nb, pub skb), r2, pub ska),
enc (len2, r2, pub ska))) then
(if (att (frame@pred A) = pub skb) then
<diff(enc (make3 (nb, na), r3, pub skb),
enc (make3 (nb, na), r3, pub skb)),<na,nb>>)
else if (get2_na (dec (att (frame@pred A1), ska)) = na &&
get2_id (dec (att (frame@pred A1), ska)) = att (frame@pred A))
then
<enc
(make3 (get2_nb (dec (att (frame@pred A1), ska)), na),
r3',
att (frame@pred A)),if (att (frame@pred A) = pub skb) then <na,nb>>



destruct Hap as [f Hf].
[> Line 1001: (destruct Hap, [f Hf]) [goal> Focused goal (1/2):
Systems: left:NSL/left, right:NSL_a/left (same for equivalences)
Variables:
f:message ->
message ->
message ->
message -> message -> message -> message -> message * bool * message
[adv, glob]
H: [happens(A1)]
H0: [A < A1]
Hf: [f
(pub ska)
(enc (make1 (na, pub ska), r1, pub skb))
(enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska))
(enc (make3 (nb, na), r3, pub skb))
skb
nb
r2' =
(frame@pred A1, exec@pred A1, if (A <= pred A1) then input@A)]
IH: equiv(msg1, msg2, msg3, pub ska, skb, na, nb, r1', r2', frame@pred A1)
msg1 := enc (make1 (na, pub ska), r1, pub skb)
msg2 := enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska)
msg3 := enc (make3 (nb, na), r3, pub skb)
----------------------------------------
0: enc (make1 (na, pub ska), r1, pub skb)
1: enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska)
2: enc (make3 (nb, na), r3, pub skb)
3: pub ska
4: skb
5: na
6: nb
7: r1'
8: r2'
9: frame@pred A1
10: if (att (frame@pred A1) =
diff(enc (make2 (na, nb, pub skb), r2, pub ska),
enc (len2, r2, pub ska))) then
(if (att (frame@pred A) = pub skb) then
<diff(enc (make3 (nb, na), r3, pub skb),
enc (make3 (nb, na), r3, pub skb)),<na,nb>>)
else if (get2_na (dec (att (frame@pred A1), ska)) = na &&
get2_id (dec (att (frame@pred A1), ska)) = att (frame@pred A))
then
<enc
(make3 (get2_nb (dec (att (frame@pred A1), ska)), na),
r3',
att (frame@pred A)),if (att (frame@pred A) = pub skb) then <na,nb>>



assert frame@pred A1 = (f (pub ska) msg1 msg2 msg3 skb nb r2')#1 as ->
by rewrite Hf.
[> Line 1005: ((have ...); 1: by (rewrite ...)) [goal> Focused goal (1/2):
Systems: left:NSL/left, right:NSL_a/left (same for equivalences)
Variables:
f:message ->
message ->
message ->
message -> message -> message -> message -> message * bool * message
[adv, glob]
H: [happens(A1)]
H0: [A < A1]
Hf: [f
(pub ska)
(enc (make1 (na, pub ska), r1, pub skb))
(enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska))
(enc (make3 (nb, na), r3, pub skb))
skb
nb
r2' =
(frame@pred A1, exec@pred A1, if (A <= pred A1) then input@A)]
IH: equiv(msg1, msg2, msg3, pub ska, skb, na, nb, r1', r2', frame@pred A1)
msg1 := enc (make1 (na, pub ska), r1, pub skb)
msg2 := enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska)
msg3 := enc (make3 (nb, na), r3, pub skb)
----------------------------------------
0: enc (make1 (na, pub ska), r1, pub skb)
1: enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska)
2: enc (make3 (nb, na), r3, pub skb)
3: pub ska
4: skb
5: na
6: nb
7: r1'
8: r2'
9: f (pub ska) msg1 msg2 msg3 skb nb r2'#1
10: if (att (f (pub ska) msg1 msg2 msg3 skb nb r2'#1) =
diff(enc (make2 (na, nb, pub skb), r2, pub ska),
enc (len2, r2, pub ska))) then
(if (att (frame@pred A) = pub skb) then
<diff(enc (make3 (nb, na), r3, pub skb),
enc (make3 (nb, na), r3, pub skb)),<na,nb>>)
else if (get2_na
(dec (att (f (pub ska) msg1 msg2 msg3 skb nb r2'#1), ska)) =
na &&
get2_id
(dec (att (f (pub ska) msg1 msg2 msg3 skb nb r2'#1), ska)) =
att (frame@pred A)) then
<enc
(make3
(get2_nb
(dec (att (f (pub ska) msg1 msg2 msg3 skb nb r2'#1), ska)),
na),
r3',
att (frame@pred A)),if (att (frame@pred A) = pub skb) then <na,nb>>



assert att (frame@pred A) = (f (pub ska) msg1 msg2 msg3 skb nb r2')#3 as ->
by rewrite Hf (if_true (A <= pred A1)).
[> Line 1009: ((have ...); 1: by (rewrite ... ...)) [goal> Focused goal (1/2):
Systems: left:NSL/left, right:NSL_a/left (same for equivalences)
Variables:
f:message ->
message ->
message ->
message -> message -> message -> message -> message * bool * message
[adv, glob]
H: [happens(A1)]
H0: [A < A1]
Hf: [f
(pub ska)
(enc (make1 (na, pub ska), r1, pub skb))
(enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska))
(enc (make3 (nb, na), r3, pub skb))
skb
nb
r2' =
(frame@pred A1, exec@pred A1, if (A <= pred A1) then input@A)]
IH: equiv(msg1, msg2, msg3, pub ska, skb, na, nb, r1', r2', frame@pred A1)
msg1 := enc (make1 (na, pub ska), r1, pub skb)
msg2 := enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska)
msg3 := enc (make3 (nb, na), r3, pub skb)
----------------------------------------
0: enc (make1 (na, pub ska), r1, pub skb)
1: enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska)
2: enc (make3 (nb, na), r3, pub skb)
3: pub ska
4: skb
5: na
6: nb
7: r1'
8: r2'
9: f (pub ska) msg1 msg2 msg3 skb nb r2'#1
10: if (att (f (pub ska) msg1 msg2 msg3 skb nb r2'#1) =
diff(enc (make2 (na, nb, pub skb), r2, pub ska),
enc (len2, r2, pub ska))) then
(if (f (pub ska) msg1 msg2 msg3 skb nb r2'#3 = pub skb) then
<diff(enc (make3 (nb, na), r3, pub skb),
enc (make3 (nb, na), r3, pub skb)),<na,nb>>)
else if (get2_na
(dec (att (f (pub ska) msg1 msg2 msg3 skb nb r2'#1), ska)) =
na &&
get2_id
(dec (att (f (pub ska) msg1 msg2 msg3 skb nb r2'#1), ska)) =
f (pub ska) msg1 msg2 msg3 skb nb r2'#3) then
<enc
(make3
(get2_nb
(dec (att (f (pub ska) msg1 msg2 msg3 skb nb r2'#1), ska)),
na),
r3',
f (pub ska) msg1 msg2 msg3 skb nb r2'#3),
if (f (pub ska) msg1 msg2 msg3 skb nb r2'#3 = pub skb) then <na,nb>>



rewrite /msg1 /msg2 /msg3.
[> Line 1011: (rewrite ... ... ...) [goal> Focused goal (1/2):
Systems: left:NSL/left, right:NSL_a/left (same for equivalences)
Variables:
f:message ->
message ->
message ->
message -> message -> message -> message -> message * bool * message
[adv, glob]
H: [happens(A1)]
H0: [A < A1]
Hf: [f
(pub ska)
(enc (make1 (na, pub ska), r1, pub skb))
(enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska))
(enc (make3 (nb, na), r3, pub skb))
skb
nb
r2' =
(frame@pred A1, exec@pred A1, if (A <= pred A1) then input@A)]
IH: equiv(msg1, msg2, msg3, pub ska, skb, na, nb, r1', r2', frame@pred A1)
msg1 := enc (make1 (na, pub ska), r1, pub skb)
msg2 := enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska)
msg3 := enc (make3 (nb, na), r3, pub skb)
----------------------------------------
0: enc (make1 (na, pub ska), r1, pub skb)
1: enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska)
2: enc (make3 (nb, na), r3, pub skb)
3: pub ska
4: skb
5: na
6: nb
7: r1'
8: r2'
9: f
(pub ska)
(enc (make1 (na, pub ska), r1, pub skb))
(enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska))
(enc (make3 (nb, na), r3, pub skb))
skb
nb
r2'#1
10: if (att
(f
(pub ska)
(enc (make1 (na, pub ska), r1, pub skb))
(enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska))
(enc (make3 (nb, na), r3, pub skb))
skb
nb
r2'#1) =
diff(enc (make2 (na, nb, pub skb), r2, pub ska),
enc (len2, r2, pub ska))) then
(if (f
(pub ska)
(enc (make1 (na, pub ska), r1, pub skb))
(enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska))
(enc (make3 (nb, na), r3, pub skb))
skb
nb
r2'#3 =
pub skb) then
<diff(enc (make3 (nb, na), r3, pub skb),
enc (make3 (nb, na), r3, pub skb)),<na,nb>>)
else if (get2_na
(dec
(att
(f
(pub ska)
(enc (make1 (na, pub ska), r1, pub skb))
(enc
(diff(make2 (na, nb, pub skb), len2), r2, pub ska))
(enc (make3 (nb, na), r3, pub skb))
skb
nb
r2'#1),
ska)) =
na &&
get2_id
(dec
(att
(f
(pub ska)
(enc (make1 (na, pub ska), r1, pub skb))
(enc
(diff(make2 (na, nb, pub skb), len2), r2, pub ska))
(enc (make3 (nb, na), r3, pub skb))
skb
nb
r2'#1),
ska)) =
f
(pub ska)
(enc (make1 (na, pub ska), r1, pub skb))
(enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska))
(enc (make3 (nb, na), r3, pub skb))
skb
nb
r2'#3) then
<enc
(make3
(get2_nb
(dec
(att
(f
(pub ska)
(enc (make1 (na, pub ska), r1, pub skb))
(enc
(diff(make2 (na, nb, pub skb), len2), r2, pub ska))
(enc (make3 (nb, na), r3, pub skb))
skb
nb
r2'#1),
ska)),
na),
r3',
f
(pub ska)
(enc (make1 (na, pub ska), r1, pub skb))
(enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska))
(enc (make3 (nb, na), r3, pub skb))
skb
nb
r2'#3),
if (f
(pub ska)
(enc (make1 (na, pub ska), r1, pub skb))
(enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska))
(enc (make3 (nb, na), r3, pub skb))
skb
nb
r2'#3 =
pub skb) then <na,nb>>



crypto CCA2 (key:ska) => //.
[> Line 1013: ((crypto ...);(intro //)) Direct bi-deduction sub-goal (assuming recursive calls are bi-deducible):


(enc (make1 (na, pub ska), r1, pub skb),
enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska),
enc (make3 (nb, na), r3, pub skb),
pub ska,
skb,
na,
nb,
r1',
r2',
f
(pub ska)
(enc (make1 (na, pub ska), r1, pub skb))
(enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska))
(enc (make3 (nb, na), r3, pub skb))
skb
nb
r2'#1,
if (att
(f
(pub ska)
(enc (make1 (na, pub ska), r1, pub skb))
(enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska))
(enc (make3 (nb, na), r3, pub skb))
skb
nb
r2'#1) =
diff(enc (make2 (na, nb, pub skb), r2, pub ska),
enc (len2, r2, pub ska))) then
(if (f
(pub ska)
(enc (make1 (na, pub ska), r1, pub skb))
(enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska))
(enc (make3 (nb, na), r3, pub skb))
skb
nb
r2'#3 =
pub skb) then
<diff(enc (make3 (nb, na), r3, pub skb),
enc (make3 (nb, na), r3, pub skb)),<na,nb>>)
else if (get2_na
(dec
(att
(f
(pub ska)
(enc (make1 (na, pub ska), r1, pub skb))
(enc
(diff(make2 (na, nb, pub skb), len2), r2, pub ska))
(enc (make3 (nb, na), r3, pub skb))
skb
nb
r2'#1),
ska)) =
na &&
get2_id
(dec
(att
(f
(pub ska)
(enc (make1 (na, pub ska), r1, pub skb))
(enc
(diff(make2 (na, nb, pub skb), len2), r2, pub ska))
(enc (make3 (nb, na), r3, pub skb))
skb
nb
r2'#1),
ska)) =
f
(pub ska)
(enc (make1 (na, pub ska), r1, pub skb))
(enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska))
(enc (make3 (nb, na), r3, pub skb))
skb
nb
r2'#3) then
<enc
(make3
(get2_nb
(dec
(att
(f
(pub ska)
(enc (make1 (na, pub ska), r1, pub skb))
(enc
(diff(make2 (na, nb, pub skb), len2), r2, pub ska))
(enc (make3 (nb, na), r3, pub skb))
skb
nb
r2'#1),
ska)),
na),
r3',
f
(pub ska)
(enc (make1 (na, pub ska), r1, pub skb))
(enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska))
(enc (make3 (nb, na), r3, pub skb))
skb
nb
r2'#3),
if (f
(pub ska)
(enc (make1 (na, pub ska), r1, pub skb))
(enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska))
(enc (make3 (nb, na), r3, pub skb))
skb
nb
r2'#3 =
pub skb) then <na,nb>>)

Bi-deduction sub-goals for recursive calls:


Constraints are:
{ r2 , L }
{ r3' , A |
(get2_na
(dec
(att
(f
(pub ska)
(enc (make1 (na, pub ska), r1, pub skb))
(enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska))
(enc (make3 (nb, na), r3, pub skb))
skb
nb
r2'#1),
ska)) =
na &&
get2_id
(dec
(att
(f
(pub ska)
(enc (make1 (na, pub ska), r1, pub skb))
(enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska))
(enc (make3 (nb, na), r3, pub skb))
skb
nb
r2'#1),
ska)) =
f
(pub ska)
(enc (make1 (na, pub ska), r1, pub skb))
(enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska))
(enc (make3 (nb, na), r3, pub skb))
skb
nb
r2'#3) &&
not
(att
(f
(pub ska)
(enc (make1 (na, pub ska), r1, pub skb))
(enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska))
(enc (make3 (nb, na), r3, pub skb))
skb
nb
r2'#1) =
diff(enc (make2 (na, nb, pub skb), r2, pub ska),
enc (len2, r2, pub ska))) }
{ r2' , A }
{ r1' , A }
{ r3 , A }
{ nb , A }
{ skb , A }
{ r1 , A }
{ na , A }
{ ska , Gkey }
Constraints subgoals are:
Oracle subgoals are:
not
(att
(f
(pub ska)
(enc (make1 (na, pub ska), r1, pub skb))
(enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska))
(enc (make3 (nb, na), r3, pub skb))
skb
nb
r2'#1) =
diff(enc (make2 (na, nb, pub skb), r2, pub ska),
enc (len2, r2, pub ska))) =>
not
(att
(f
(pub ska)
(enc (make1 (na, pub ska), r1, pub skb))
(enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska))
(enc (make3 (nb, na), r3, pub skb))
skb
nb
r2'#1) =
diff(enc (make2 (na, nb, pub skb), r2, pub ska),
enc (len2, r2, pub ska))) =>
att
(f
(pub ska)
(enc (make1 (na, pub ska), r1, pub skb))
(enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska))
(enc (make3 (nb, na), r3, pub skb))
skb
nb
r2'#1) <>
enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska)
zeroes (make2 (na, nb, pub skb)) = zeroes len2
Final memory is:
{log -> [{ enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska) | true } ] }
[goal> Focused goal (1/3):
System: left:NSL/left, right:NSL_a/left (same for equivalences)
Variables:
f:message ->
message ->
message ->
message -> message -> message -> message -> message * bool * message
[adv, glob]
H: [happens(A1)]
H0: [A < A1]
Hf: [f
(pub ska)
(enc (make1 (na, pub ska), r1, pub skb))
(enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska))
(enc (make3 (nb, na), r3, pub skb))
skb
nb
r2' =
(frame@pred A1, exec@pred A1, if (A <= pred A1) then input@A)]
IH: equiv(msg1, msg2, msg3, pub ska, skb, na, nb, r1', r2', frame@pred A1)
msg1 := enc (make1 (na, pub ska), r1, pub skb)
msg2 := enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska)
msg3 := enc (make3 (nb, na), r3, pub skb)
----------------------------------------
not
(att
(f
(pub ska)
(enc (make1 (na, pub ska), r1, pub skb))
(enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska))
(enc (make3 (nb, na), r3, pub skb))
skb
nb
r2'#1) =
diff(enc (make2 (na, nb, pub skb), r2, pub ska), enc (len2, r2, pub ska))) =>
not
(att
(f
(pub ska)
(enc (make1 (na, pub ska), r1, pub skb))
(enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska))
(enc (make3 (nb, na), r3, pub skb))
skb
nb
r2'#1) =
diff(enc (make2 (na, nb, pub skb), r2, pub ska), enc (len2, r2, pub ska))) =>
att
(f
(pub ska)
(enc (make1 (na, pub ska), r1, pub skb))
(enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska))
(enc (make3 (nb, na), r3, pub skb))
skb
nb
r2'#1) <>
enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska)


* by project.
[> Line 1015: by project [goal> Focused goal (1/2):
System: left:NSL/left, right:NSL_a/left (same for equivalences)
Variables:
f:message ->
message ->
message ->
message -> message -> message -> message -> message * bool * message
[adv, glob]
H: [happens(A1)]
H0: [A < A1]
Hf: [f
(pub ska)
(enc (make1 (na, pub ska), r1, pub skb))
(enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska))
(enc (make3 (nb, na), r3, pub skb))
skb
nb
r2' =
(frame@pred A1, exec@pred A1, if (A <= pred A1) then input@A)]
IH: equiv(msg1, msg2, msg3, pub ska, skb, na, nb, r1', r2', frame@pred A1)
msg1 := enc (make1 (na, pub ska), r1, pub skb)
msg2 := enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska)
msg3 := enc (make3 (nb, na), r3, pub skb)
----------------------------------------
zeroes (make2 (na, nb, pub skb)) = zeroes len2


* by rewrite len2.
[> Line 1017: by (rewrite ...) [goal> Focused goal (1/1):
Systems: left:NSL/left, right:NSL_a/left (same for equivalences)
Variables:
H: [happens(B)]
IH: equiv(msg1, msg2, msg3, pub ska, skb, na, nb, r1', r2', frame@pred B)
msg1 := enc (make1 (na, pub ska), r1, pub skb)
msg2 := enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska)
msg3 := enc (make3 (nb, na), r3, pub skb)
----------------------------------------
0: msg1
1: msg2
2: msg3
3: pub ska
4: skb
5: na
6: nb
7: r1'
8: r2'
9: frame@B



+ rewrite /* in *.
[> Line 1019: (rewrite ... in *) [goal> Focused goal (1/1):
Systems: left:NSL/left, right:NSL_a/left (same for equivalences)
Variables:
H: [happens(B)]
IH: equiv(enc (make1 (na, pub ska), r1, pub skb),
enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska),
enc (make3 (nb, na), r3, pub skb), pub ska, skb, na, nb, r1', r2',
frame@pred B)
msg1 := enc (make1 (na, pub ska), r1, pub skb)
msg2 := enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska)
msg3 := enc (make3 (nb, na), r3, pub skb)
----------------------------------------
0: enc (make1 (na, pub ska), r1, pub skb)
1: enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska)
2: enc (make3 (nb, na), r3, pub skb)
3: pub ska
4: skb
5: na
6: nb
7: r1'
8: r2'
9: <frame@pred B,
<of_bool (exec@pred B && true),
if (exec@pred B && true) then
(if (att (frame@pred B) =
diff(enc (make1 (na, pub ska), r1, pub skb),
enc (make1 (na, pub ska), r1, pub skb))) then
diff(enc (make2 (na, nb, pub skb), r2, pub ska),
enc (len2, r2, pub ska))
else if (att (frame@pred B) =
diff(enc (make3 (nb, na), r3, pub skb),
enc (make3 (nb, na), r3, pub skb))) then empty
else if check_tag (dec (att (frame@pred B), skb)) then
enc
(make2 (get1_na (dec (att (frame@pred B), skb)), nb, pub skb),
r2',
get1_id (dec (att (frame@pred B), skb))))>>



apply IH.
[> Line 1021: (apply ... ) [goal> lemma equiv_left is proved


Qed.
global lemma [left:NSL/left, right:NSL_a/left (same for equivalences)] equiv_left :
Forall (t:timestamp[const, glob]),
Let msg1 = enc (make1 (na, pub ska), r1, pub skb) in
Let msg2 = enc (diff(make2 (na, nb, pub skb), len2), r2, pub ska) in
Let msg3 = enc (make3 (nb, na), r3, pub skb) in
[happens(t)] ->
equiv(msg1, msg2, msg3, pub ska, skb, na, nb, r1', r2', frame@t)
Exiting proof mode.



(* ------------------------------------------------------------------------ *)

(* We finally prove that the two projections of the bi-system NSL
are observationally equivalent, by transitivity. *)

(* Immediate consequence of equiv_left. *)
global lemma
[set: NSL; equiv:NSL/left,NSL_a/left]
equiv_left_sys (t:timestamp[const]) :
[happens(t)] -> equiv(frame@t).
Goal equiv_left_sys :
forall t:timestamp[const, glob], [happens(t)] -> equiv(frame@t)

Proof.
[goal> Focused goal (1/1):
Systems: NSL (equivalences: left:NSL/left, right:NSL_a/left)
Variables: t:timestamp[const, glob]
----------------------------------------
[happens(t)] -> equiv(frame@t)


intro *.
[> Line 1049: (intro *) [goal> Focused goal (1/1):
Systems: NSL (equivalences: left:NSL/left, right:NSL_a/left)
Variables: t:timestamp[const, glob]
H: [happens(t)]
----------------------------------------
0: frame@t



trans [NSL/left,NSL_a/left].
[> Line 1051: (trans ...) [goal> Focused goal (1/3):
Systems: NSL (equivalences: left:NSL/left, right:NSL/left)
Variables: t:timestamp[const, glob]
H: [happens(t)]
----------------------------------------
0: frame@t



+ auto.
[> Line 1053: (auto ...) [goal> Focused goal (1/2):
Systems: left:NSL/left, right:NSL_a/left (same for equivalences)
Variables: t:timestamp[const, glob]
H: [happens(t)]
----------------------------------------
0: frame@t



+ by apply equiv_left.
[> Line 1055: by (apply ... ) [goal> Focused goal (1/1):
Systems: NSL (equivalences: left:NSL_a/left, right:NSL_a/left)
Variables: t:timestamp[const, glob]
H: [happens(t)]
----------------------------------------
0: frame@t



+ auto.
[> Line 1057: (auto ...) [goal> lemma equiv_left_sys is proved


Qed.
global lemma [NSL (equivalences: left:NSL/left, right:NSL_a/left)] equiv_left_sys :
Forall (t:timestamp[const, glob]), [happens(t)] -> equiv(frame@t)
Exiting proof mode.



(* Immediate consequence of equiv_right. *)
global lemma
[set:NSL; equiv:NSL_a/left,NSL/right]
equiv_right_sys (t:timestamp[const]) :
[happens(t)] -> equiv(frame@t).
Goal equiv_right_sys :
forall t:timestamp[const, glob], [happens(t)] -> equiv(frame@t)

Proof.
[goal> Focused goal (1/1):
Systems: NSL (equivalences: left:NSL_a/left, right:NSL/right)
Variables: t:timestamp[const, glob]
----------------------------------------
[happens(t)] -> equiv(frame@t)


intro *.
[> Line 1075: (intro *) [goal> Focused goal (1/1):
Systems: NSL (equivalences: left:NSL_a/left, right:NSL/right)
Variables: t:timestamp[const, glob]
H: [happens(t)]
----------------------------------------
0: frame@t



trans [NSL_a/left,NSL/right].
[> Line 1077: (trans ...) [goal> Focused goal (1/3):
Systems: NSL (equivalences: left:NSL_a/left, right:NSL_a/left)
Variables: t:timestamp[const, glob]
H: [happens(t)]
----------------------------------------
0: frame@t



+ auto.
[> Line 1079: (auto ...) [goal> Focused goal (1/2):
Systems: left:NSL_a/left, right:NSL/right (same for equivalences)
Variables: t:timestamp[const, glob]
H: [happens(t)]
----------------------------------------
0: frame@t



+ by apply equiv_right.
[> Line 1081: by (apply ... ) [goal> Focused goal (1/1):
Systems: NSL (equivalences: left:NSL/right, right:NSL/right)
Variables: t:timestamp[const, glob]
H: [happens(t)]
----------------------------------------
0: frame@t



+ auto.
[> Line 1083: (auto ...) [goal> lemma equiv_right_sys is proved


Qed.
global lemma [NSL (equivalences: left:NSL_a/left, right:NSL/right)] equiv_right_sys :
Forall (t:timestamp[const, glob]), [happens(t)] -> equiv(frame@t)
Exiting proof mode.



global theorem [NSL] nsl_security (t:timestamp[const]) :
[happens(t)] -> equiv(frame@t).
Goal nsl_security :
forall t:timestamp[const, glob], [happens(t)] -> equiv(frame@t)

Proof.
[goal> Focused goal (1/1):
Systems: NSL (same for equivalences)
Variables: t:timestamp[const, glob]
----------------------------------------
[happens(t)] -> equiv(frame@t)


intro *.
[> Line 1095: (intro *) [goal> Focused goal (1/1):
Systems: NSL (same for equivalences)
Variables: t:timestamp[const, glob]
H: [happens(t)]
----------------------------------------
0: frame@t



trans [NSL_a/left,NSL_a/left].
[> Line 1097: (trans ...) [goal> Focused goal (1/3):
Systems: NSL (equivalences: left:NSL/left, right:NSL_a/left)
Variables: t:timestamp[const, glob]
H: [happens(t)]
----------------------------------------
0: frame@t



+ by apply equiv_left_sys.
[> Line 1099: by (apply ... ) [goal> Focused goal (1/2):
Systems: left:NSL_a/left, right:NSL_a/left (same for equivalences)
Variables: t:timestamp[const, glob]
H: [happens(t)]
----------------------------------------
0: frame@t



+ auto.
[> Line 1101: (auto ...) [goal> Focused goal (1/1):
Systems: NSL (equivalences: left:NSL_a/left, right:NSL/right)
Variables: t:timestamp[const, glob]
H: [happens(t)]
----------------------------------------
0: frame@t



+ by apply equiv_right_sys.
[> Line 1103: by (apply ... ) [goal> lemma nsl_security is proved


Qed.
global lemma [NSL (same for equivalences)] nsl_security :
Forall (t:timestamp[const, glob]), [happens(t)] -> equiv(frame@t)
Exiting proof mode.

Press the left and right arrows to do and undo an instruction.

Alternatively, you can double-click on an instruction.

This zone shows a Squirrel file. You can double-click on a comment to collapse it for better readabilility.

This zone shows the output given by Squirrel.

This zone shows the output of the previous instruction, to help identifying the change caused by the instruction.

Previously: