Step
*
2
1
2
2
2
of Lemma
mul_poly-sq
1. u : iMonomial()
2. v : iMonomial() List
3. ∀[q:iMonomial() List]. (mul_ipoly(v;q) ~ mul-ipoly(v;q))
4. u1 : iMonomial()
5. v1 : iMonomial() List
6. ∀p,q:iMonomial() List.  (add_ipoly(p;q) ∈ iMonomial() List)
7. ∀[f:(iMonomial() List) ⟶ iMonomial() ⟶ (iMonomial() List)]
     cbv_list_accum(x,a.f[x;a];mul-mono-poly(u;[u1 / v1]);v) ~ accumulate (with value x and list item a):
                                                                f[x;a]
                                                               over list:
                                                                 v
                                                               with starting value:
                                                                mul-mono-poly(u;[u1 / v1])) 
     supposing value-type(iMonomial() List)
8. ∀[f:(iMonomial() List) ⟶ iMonomial() ⟶ (iMonomial() List)]
     eager-accum(x,a.f[x;a];mul-mono-poly(u;[u1 / v1]);v) ~ accumulate (with value x and list item a):
                                                             f[x;a]
                                                            over list:
                                                              v
                                                            with starting value:
                                                             mul-mono-poly(u;[u1 / v1])) 
     supposing valueall-type(iMonomial() List)
⊢ accumulate (with value sofar and list item m):
   add_ipoly(sofar;mul-mono-poly(m;[u1 / v1]))
  over list:
    v
  with starting value:
   mul-mono-poly(u;[u1 / v1])) ~ accumulate (with value sofar and list item m):
                                  add-ipoly(sofar;mul-mono-poly(m;[u1 / v1]))
                                 over list:
                                   v
                                 with starting value:
                                  mul-mono-poly(u;[u1 / v1]))
BY
{ Assert ⌜accumulate (with value sofar and list item m):
           add_ipoly(sofar;mul-mono-poly(m;[u1 / v1]))
          over list:
            v
          with starting value:
           mul-mono-poly(u;[u1 / v1]))
          = accumulate (with value sofar and list item m):
             add-ipoly(sofar;mul-mono-poly(m;[u1 / v1]))
            over list:
              v
            with starting value:
             mul-mono-poly(u;[u1 / v1]))
          ∈ (iMonomial() List)⌝⋅ }
1
.....assertion..... 
1. u : iMonomial()
2. v : iMonomial() List
3. ∀[q:iMonomial() List]. (mul_ipoly(v;q) ~ mul-ipoly(v;q))
4. u1 : iMonomial()
5. v1 : iMonomial() List
6. ∀p,q:iMonomial() List.  (add_ipoly(p;q) ∈ iMonomial() List)
7. ∀[f:(iMonomial() List) ⟶ iMonomial() ⟶ (iMonomial() List)]
     cbv_list_accum(x,a.f[x;a];mul-mono-poly(u;[u1 / v1]);v) ~ accumulate (with value x and list item a):
                                                                f[x;a]
                                                               over list:
                                                                 v
                                                               with starting value:
                                                                mul-mono-poly(u;[u1 / v1])) 
     supposing value-type(iMonomial() List)
8. ∀[f:(iMonomial() List) ⟶ iMonomial() ⟶ (iMonomial() List)]
     eager-accum(x,a.f[x;a];mul-mono-poly(u;[u1 / v1]);v) ~ accumulate (with value x and list item a):
                                                             f[x;a]
                                                            over list:
                                                              v
                                                            with starting value:
                                                             mul-mono-poly(u;[u1 / v1])) 
     supposing valueall-type(iMonomial() List)
⊢ accumulate (with value sofar and list item m):
   add_ipoly(sofar;mul-mono-poly(m;[u1 / v1]))
  over list:
    v
  with starting value:
   mul-mono-poly(u;[u1 / v1]))
= accumulate (with value sofar and list item m):
   add-ipoly(sofar;mul-mono-poly(m;[u1 / v1]))
  over list:
    v
  with starting value:
   mul-mono-poly(u;[u1 / v1]))
∈ (iMonomial() List)
2
1. u : iMonomial()
2. v : iMonomial() List
3. ∀[q:iMonomial() List]. (mul_ipoly(v;q) ~ mul-ipoly(v;q))
4. u1 : iMonomial()
5. v1 : iMonomial() List
6. ∀p,q:iMonomial() List.  (add_ipoly(p;q) ∈ iMonomial() List)
7. ∀[f:(iMonomial() List) ⟶ iMonomial() ⟶ (iMonomial() List)]
     cbv_list_accum(x,a.f[x;a];mul-mono-poly(u;[u1 / v1]);v) ~ accumulate (with value x and list item a):
                                                                f[x;a]
                                                               over list:
                                                                 v
                                                               with starting value:
                                                                mul-mono-poly(u;[u1 / v1])) 
     supposing value-type(iMonomial() List)
8. ∀[f:(iMonomial() List) ⟶ iMonomial() ⟶ (iMonomial() List)]
     eager-accum(x,a.f[x;a];mul-mono-poly(u;[u1 / v1]);v) ~ accumulate (with value x and list item a):
                                                             f[x;a]
                                                            over list:
                                                              v
                                                            with starting value:
                                                             mul-mono-poly(u;[u1 / v1])) 
     supposing valueall-type(iMonomial() List)
9. accumulate (with value sofar and list item m):
    add_ipoly(sofar;mul-mono-poly(m;[u1 / v1]))
   over list:
     v
   with starting value:
    mul-mono-poly(u;[u1 / v1]))
= accumulate (with value sofar and list item m):
   add-ipoly(sofar;mul-mono-poly(m;[u1 / v1]))
  over list:
    v
  with starting value:
   mul-mono-poly(u;[u1 / v1]))
∈ (iMonomial() List)
⊢ accumulate (with value sofar and list item m):
   add_ipoly(sofar;mul-mono-poly(m;[u1 / v1]))
  over list:
    v
  with starting value:
   mul-mono-poly(u;[u1 / v1])) ~ accumulate (with value sofar and list item m):
                                  add-ipoly(sofar;mul-mono-poly(m;[u1 / v1]))
                                 over list:
                                   v
                                 with starting value:
                                  mul-mono-poly(u;[u1 / v1]))
Latex:
Latex:
1.  u  :  iMonomial()
2.  v  :  iMonomial()  List
3.  \mforall{}[q:iMonomial()  List].  (mul\_ipoly(v;q)  \msim{}  mul-ipoly(v;q))
4.  u1  :  iMonomial()
5.  v1  :  iMonomial()  List
6.  \mforall{}p,q:iMonomial()  List.    (add\_ipoly(p;q)  \mmember{}  iMonomial()  List)
7.  \mforall{}[f:(iMonomial()  List)  {}\mrightarrow{}  iMonomial()  {}\mrightarrow{}  (iMonomial()  List)]
          cbv\_list\_accum(x,a.f[x;a];mul-mono-poly(u;[u1  /  v1]);v) 
          \msim{}  accumulate  (with  value  x  and  list  item  a):
                f[x;a]
              over  list:
                  v
              with  starting  value:
                mul-mono-poly(u;[u1  /  v1])) 
          supposing  value-type(iMonomial()  List)
8.  \mforall{}[f:(iMonomial()  List)  {}\mrightarrow{}  iMonomial()  {}\mrightarrow{}  (iMonomial()  List)]
          eager-accum(x,a.f[x;a];mul-mono-poly(u;[u1  /  v1]);v) 
          \msim{}  accumulate  (with  value  x  and  list  item  a):
                f[x;a]
              over  list:
                  v
              with  starting  value:
                mul-mono-poly(u;[u1  /  v1])) 
          supposing  valueall-type(iMonomial()  List)
\mvdash{}  accumulate  (with  value  sofar  and  list  item  m):
      add\_ipoly(sofar;mul-mono-poly(m;[u1  /  v1]))
    over  list:
        v
    with  starting  value:
      mul-mono-poly(u;[u1  /  v1]))  \msim{}  accumulate  (with  value  sofar  and  list  item  m):
                                                                    add-ipoly(sofar;mul-mono-poly(m;[u1  /  v1]))
                                                                  over  list:
                                                                      v
                                                                  with  starting  value:
                                                                    mul-mono-poly(u;[u1  /  v1]))
By
Latex:
Assert  \mkleeneopen{}accumulate  (with  value  sofar  and  list  item  m):
                  add\_ipoly(sofar;mul-mono-poly(m;[u1  /  v1]))
                over  list:
                    v
                with  starting  value:
                  mul-mono-poly(u;[u1  /  v1]))
                =  accumulate  (with  value  sofar  and  list  item  m):
                      add-ipoly(sofar;mul-mono-poly(m;[u1  /  v1]))
                    over  list:
                        v
                    with  starting  value:
                      mul-mono-poly(u;[u1  /  v1]))\mkleeneclose{}\mcdot{}
Home
Index