Def P  Q == PQ

is mentioned by

Thm* P:(AAProp), f:(BA), x,y:B List. Thm* (x swap adjacent[P(f(x),f(y))] y) Thm*  Thm* (map(f;x) swap adjacent[P(x,y)] map(f;y))	[swap_adjacent_map]
Thm* P:(AAProp), f:(A), L1,L2:A List. Thm* (L1 swap adjacent[P(x,y)] L2) Thm*  Thm* (filter(f;L1) swap adjacent[P(x,y)] filter(f;L2)) Thm*  filter(f;L1) = filter(f;L2)	[filter_swap_adjacent]
Thm* P:(AAProp), X,Y:A List, a,b:A. Thm* P(a,b)  ((X @ [a; b] @ Y) swap adjacent[P(x,y)] (X @ [b; a] @ Y))	[swap_adjacent_instance]
Thm* P:(AAProp).  Thm* (Sym x,y:A. P(x,y))  (Sym L1,L2:A List. L1 swap adjacent[P(x,y)] L2)	[symmetric_swap_adjacent]
Thm* L:T List, P:(TTProp). Thm* (x,y:T. Dec(P(x,y))) Thm*  Thm* (x,y:T. P(x,y)  P(y,x)) Thm*  Thm* (L':T List.  Thm* ((L (swap adjacent[P(x,y)]^*) L') & (i:(||L'||-1). P(L'[i],L'[(i+1)])))	[partial_sort]
Thm* L:T List, P:(TT). Thm* (x,y:T. P(x,y)  P(y,x)) Thm*  Thm* (L':T List.  Thm* ((L guarded_permutation(T;L,i. P(L[i],L[(i+1)])) L') Thm* (& (i:(||L'||-1). P(L'[i],L'[(i+1)])))	[partial_sort_exists_2]
Thm* n,m:, f:(nm), p:(nn), q:(mm). Thm* Bij(n; n; p) Thm*  Thm* Bij(m; m; q) Thm*  Thm* sum(f(p(x),q(y)) | x < n; y < m) = sum(f(x,y) | x < n; y < m)	[permute_double_sum]
Thm* n:, f:(n), p:(nn). Thm* Bij(n; n; p)  sum(f(p(x)) | x < n) = sum(f(x) | x < n)	[permute_sum]
Thm* k:, p:(kk). Bij(k; k; p)  (L:(k-1) List. p = compose_flips(L))	[permute_by_flips]
Thm* k:, x,y,z:k. Thm* y = z  x = y  (x, y) = compose_list([(x, z); (y, z); (x, z)])	[flip_lemma]
Thm* n:, R:(nnProp). (i,j:n. Dec(i R j))  (i,j:n. Dec(i (R^*) j))	[decidable__rel_star]
Thm* f,g:(TT). Bij(T; T; f)  Bij(T; T; g)  Bij(T; T; f o g)	[compose_bij]
Thm* P:(L:(T List)(||L||-1)), m:((T List)). Thm* (L:T List, i:(||L||-1). Thm* (P(L,i)  P(swap(L;i;i+1),i) & m(swap(L;i;i+1))<m(L)) Thm*  Thm* (L:T List.  Thm* (L':T List.  Thm* ((L guarded_permutation(T;L,i. P(L,i)) L') & (i:(||L'||-1). P(L',i)))	[partial_sort_exists]
Thm* f:(AB), L1,L2:A List. L1  L2  map(f;L1)  map(f;L2)	[iseg_map]
Thm* L:T List, i:(||L||-1), a,b:T. Thm* a before b  swap(L;i;i+1)  a before b  L  a = L[(i+1)] & b = L[i]	[l_before_swap]
Thm* i:, L:A List. Thm* i+1<||L|| Thm*  Thm* (X,Y:A List. Thm* (L = (X @ [L[i]; L[(i+1)]] @ Y) Thm* (& swap(L;i;i+1) = (X @ [L[(i+1)]; L[i]] @ Y))	[swap_adjacent_decomp]
Thm* L1,L2:T List, i,j:||L1||. Thm* L2 = swap(L1;i;j) Thm*  Thm* L2[i] = L1[j] & L2[j] = L1[i] & ||L2|| = ||L1||   & L1 = swap(L2;i;j) Thm* & (x:||L2||. x = i  x = j  L2[x] = L1[x])	[swapped_select]
Thm* L:T List, P:(||L||Prop). Thm* (x:||L||. Dec(P(x))) Thm*  Thm* (i:||L||. P(i))  (i:||L||. P(i) & (j:||L||. i<j  P(j)))	[last_with_property]
Thm* L:T List, P:(||L||Prop). Thm* (x:||L||. Dec(P(x))) Thm*  Thm* (L1,L2:T List, f1:(||L1||||L||), f2:(||L2||||L||). Thm* (interleaving_occurence(T;L1;L2;L;f1;f2) Thm* (& (i:||L1||. P(f1(i))) & (i:||L2||. P(f2(i))) Thm* (& (i:||L||.  Thm* (& ((P(i)  (j:||L1||. f1(j) = i)) Thm* (& (& (P(i)  (j:||L2||. f2(j) = i))))	[interleaving_split]
Thm* L,L1,L2:T List. interleaving(T;L1;L2;L)  L1  L	[interleaving_sublist]
Thm* L1,L2,L:T List. disjoint_sublists(T;L1;L2;L)  L1  L & L2  L	[disjoint_sublists_sublist]
Thm* L:T List, n:, f:(n||L||). Thm* increasing(f;n) Thm*  Thm* (L1:T List. ||L1|| = n   & sublist_occurence(T;L1;L;f))	[range_sublist]
Thm* F:(AProp), L:A List. (k:A. Dec(F(k)))  Dec((kL.F(k)))	[decidable__l_exists]
Thm* F:(AProp), L:A List. (k:A. Dec(F(k)))  Dec((kL.F(k)))	[decidable__l_all]
Thm* P:(T), l:T List. no_repeats(T;l)  no_repeats(T;filter(P;l))	[no_repeats_filter]
Thm* L:T List, P:(TProp). (xL.P(x))  L  {x:T| P(x) } List	[list_set_type]
Thm* P:(T), L:T List. (xL.P(x))  (filter(P;L) ~ nil)	[filter_is_nil]
Thm* P:(T), L:T List. (xL.P(x))  filter(P;L) = L	[filter_trivial2]
Thm* P:(T), L:T List. (xL.P(x))  (filter(P;L) ~ L)	[filter_trivial]
Def (xL.P(x)) == x:T. (x  L)  P(x)	[l_all]

In prior sections: core well fnd int 1 bool 1 int 2 union rel 1 num thy 1 fun 1 list 1 sqequal 1 mb basic mb nat mb list 1

Try larger context: MarkB generic IF YOU CAN SEE THIS go to /sfa/Nuprl/Shared/Xindentation_hack_doc.html