Added Roberts' totally twisted Kh differential to
spanning_tree_complex. Main set up to compare twisted E3, twisted Kh and normal Kh.
This commit is contained in:
Cotton Seed
parent
7d80c871ff
commit
50a2438996
4
Makefile
4
Makefile
@ -6,8 +6,8 @@ CXX = g++
|
|||||||
|
|
||||||
INCLUDES = -I/opt/local/include -I.
|
INCLUDES = -I/opt/local/include -I.
|
||||||
|
|
||||||
OPTFLAGS = -g
|
# OPTFLAGS = -g
|
||||||
# OPTFLAGS = -O2 -g
|
OPTFLAGS = -O2 -g
|
||||||
# OPTFLAGS = -O2 -DNDEBUG
|
# OPTFLAGS = -O2 -DNDEBUG
|
||||||
|
|
||||||
LDFLAGS = -L/opt/local/lib
|
LDFLAGS = -L/opt/local/lib
|
||||||
|
|||||||
@ -630,9 +630,9 @@ class map_impl : public refcounted
|
|||||||
|
|
||||||
virtual linear_combination<R> column (unsigned i) const = 0;
|
virtual linear_combination<R> column (unsigned i) const = 0;
|
||||||
|
|
||||||
linear_combination<R> map (linear_combination<R> &lc) const
|
linear_combination<R> map (const linear_combination<R> &lc) const
|
||||||
{
|
{
|
||||||
linear_combination<R> r;
|
linear_combination<R> r (this->to);
|
||||||
for (linear_combination_const_iter<R> i = lc; i; i ++)
|
for (linear_combination_const_iter<R> i = lc; i; i ++)
|
||||||
r.muladd (i.val (), column (i.key ()));
|
r.muladd (i.val (), column (i.key ()));
|
||||||
return r;
|
return r;
|
||||||
@ -750,7 +750,7 @@ class tensor_impl : public map_impl<R>
|
|||||||
public:
|
public:
|
||||||
tensor_impl (ptr<const map_impl<R> > f_, ptr<const map_impl<R> > g_)
|
tensor_impl (ptr<const map_impl<R> > f_, ptr<const map_impl<R> > g_)
|
||||||
: map_impl<R>(f_->from->tensor (g_->from),
|
: map_impl<R>(f_->from->tensor (g_->from),
|
||||||
f_->to->tensor (g_->from)),
|
f_->to->tensor (g_->to)),
|
||||||
f(f_),
|
f(f_),
|
||||||
g(g_)
|
g(g_)
|
||||||
{
|
{
|
||||||
@ -1741,7 +1741,7 @@ mod_map<R>::homology () const
|
|||||||
template<class R> basedvector<linear_combination<R>, 1>
|
template<class R> basedvector<linear_combination<R>, 1>
|
||||||
mod_map<R>::explicit_columns () const
|
mod_map<R>::explicit_columns () const
|
||||||
{
|
{
|
||||||
basedvector<linear_combination<R>, 1> v;
|
basedvector<linear_combination<R>, 1> v (impl->from->dim ());
|
||||||
for (unsigned i = 1; i <= impl->from->dim (); i ++)
|
for (unsigned i = 1; i <= impl->from->dim (); i ++)
|
||||||
v[i] = column (i);
|
v[i] = column (i);
|
||||||
return v;
|
return v;
|
||||||
|
|||||||
257
main.cpp
257
main.cpp
@ -108,217 +108,74 @@ test_field ()
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
void
|
bool
|
||||||
check (const dt_code &dt)
|
rank_lte (multivariate_laurentpoly<Z> p,
|
||||||
|
multivariate_laurentpoly<Z> q)
|
||||||
{
|
{
|
||||||
if (dt.num_components () > 1)
|
for (map<multivariate_laurent_monomial, Z>::const_iter i = p.coeffs; i; i ++)
|
||||||
{
|
{
|
||||||
knot_diagram kd (dt);
|
Z a = i.val ();
|
||||||
kd.marked_edge = 1;
|
Z b = q.coeffs(i.key (), Z (0));
|
||||||
show (kd); newline ();
|
assert (a != 0 && b != 0);
|
||||||
|
|
||||||
cube<Z2> c (kd, 1);
|
if (a > b)
|
||||||
mod_map<Z2> d = c.compute_d (1, 0, 0, 0, 0);
|
return 0;
|
||||||
sseq_builder b (c.khC, d);
|
|
||||||
sseq ss = b.build_sseq ();
|
|
||||||
|
|
||||||
unsigned n_comps = kd.num_components ();
|
|
||||||
assert (n_comps == dt.num_components ());
|
|
||||||
|
|
||||||
unsigned split = 1;
|
|
||||||
for (unsigned k = 1; k < unsigned_2pow (n_comps) - 1; k ++)
|
|
||||||
{
|
|
||||||
knot_diagram kd2 (SUBLINK,
|
|
||||||
smallbitset (n_comps, k),
|
|
||||||
kd);
|
|
||||||
kd2.marked_edge = 1;
|
|
||||||
unsigned n_comps2 = kd2.num_components ();
|
|
||||||
|
|
||||||
assert (n_comps2 == unsigned_bitcount (k));
|
|
||||||
assert (n_comps2 > 0);
|
|
||||||
assert (n_comps2 < n_comps);
|
|
||||||
|
|
||||||
cube<Z2> c2 (kd2, 1);
|
|
||||||
mod_map<Z2> d2 = c2.compute_d (1, 0, 0, 0, 0);
|
|
||||||
sseq_builder b2 (c2.khC, d2);
|
|
||||||
sseq ss2 = b2.build_sseq ();
|
|
||||||
|
|
||||||
printf (" k = %d, %d <=? %d\n",
|
|
||||||
k,
|
|
||||||
ss2.pages[1].total_rank (),
|
|
||||||
ss.pages[1].total_rank ());
|
|
||||||
if (ss2.pages[1].total_rank () > ss.pages[1].total_rank ())
|
|
||||||
printf (" !! COUNTEREXAMPLE\n");
|
|
||||||
|
|
||||||
if (unsigned_bitcount (k) == 1)
|
|
||||||
split *= ss2.pages[1].total_rank ();
|
|
||||||
}
|
|
||||||
|
|
||||||
printf (" split %d <=? %d\n",
|
|
||||||
split,
|
|
||||||
ss.pages[1].total_rank ());
|
|
||||||
if (split > ss.pages[1].total_rank ())
|
|
||||||
printf (" !! COUNTEREXAMPLE\n");
|
|
||||||
}
|
}
|
||||||
|
return 1;
|
||||||
}
|
}
|
||||||
|
|
||||||
int
|
int
|
||||||
main ()
|
main ()
|
||||||
{
|
{
|
||||||
ptr<const explicit_module<Q> > A
|
|
||||||
= new explicit_module<Q> (2, basedvector<Q, 1> (), basedvector<grading, 1> (2));
|
|
||||||
ptr<const explicit_module<Q> > B
|
|
||||||
= new explicit_module<Q> (3, basedvector<Q, 1> (), basedvector<grading, 1> (3));
|
|
||||||
ptr<const explicit_module<Q> > C
|
|
||||||
= new explicit_module<Q> (3, basedvector<Q, 1> (), basedvector<grading, 1> (3));
|
|
||||||
ptr<const explicit_module<Q> > D
|
|
||||||
= new explicit_module<Q> (2, basedvector<Q, 1> (), basedvector<grading, 1> (2));
|
|
||||||
ptr<const explicit_module<Q> > E
|
|
||||||
= new explicit_module<Q> (2, basedvector<Q, 1> (), basedvector<grading, 1> (3));
|
|
||||||
ptr<const explicit_module<Q> > F
|
|
||||||
= new explicit_module<Q> (2, basedvector<Q, 1> (), basedvector<grading, 1> (2));
|
|
||||||
|
|
||||||
map_builder<Q> fb (A, B);
|
|
||||||
fb[1].muladd (2, 1);
|
|
||||||
fb[1].muladd (3, 2);
|
|
||||||
fb[2].muladd (-5, 2);
|
|
||||||
fb[2].muladd (4, 3);
|
|
||||||
mod_map<Q> f (fb);
|
|
||||||
display ("f:\n", f);
|
|
||||||
|
|
||||||
map_builder<Q> gb (C, D);
|
|
||||||
gb[1].muladd (1, 1);
|
|
||||||
gb[2].muladd (3, 1);
|
|
||||||
gb[2].muladd (-2, 2);
|
|
||||||
gb[3].muladd (-6, 2);
|
|
||||||
mod_map<Q> g (gb);
|
|
||||||
display ("g:\n", g);
|
|
||||||
|
|
||||||
display ("f oplus g:\n", f.add (g));
|
|
||||||
|
|
||||||
map_builder<Q> hb (E, F);
|
|
||||||
hb[1].muladd (3, 2);
|
|
||||||
hb[2].muladd (-3, 1);
|
|
||||||
mod_map<Q> h (hb);
|
|
||||||
display ("h:\n", h);
|
|
||||||
|
|
||||||
mod_map<Q> fg = f.tensor (g);
|
|
||||||
display ("fg:\n", fg);
|
|
||||||
|
|
||||||
ptr<const module<Q> > AB_C = (A->tensor (B))->tensor (C),
|
|
||||||
A_BC = A->tensor (B->tensor (C));
|
|
||||||
assert (AB_C == A_BC);
|
|
||||||
|
|
||||||
assert ((f.tensor (g)).tensor (h) == f.tensor (g.tensor (h)));
|
|
||||||
|
|
||||||
ptr<const hom_module<Q> > homAB = A->hom (B);
|
|
||||||
linear_combination<Q> x = homAB->map_as_element (f);
|
|
||||||
display ("x:\n", x);
|
|
||||||
|
|
||||||
#if 0
|
|
||||||
for (unsigned i = 1; i <= 14; i ++)
|
|
||||||
{
|
|
||||||
for (unsigned j = 1; j <= mt_links (i, 0); j ++)
|
|
||||||
check (mt_link (i, 0, j));
|
|
||||||
|
|
||||||
for (unsigned j = 1; j <= mt_links (i, 1); j ++)
|
|
||||||
check (mt_link (i, 1, j));
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#if 0
|
#if 0
|
||||||
knot_diagram kd (rolfsen_knot (8, 19));
|
for (unsigned i = 1; i <= 10; i ++)
|
||||||
cube<Z2> c (kd);
|
for (unsigned j = 1; j <= rolfsen_crossing_knots (i); j ++)
|
||||||
sseq ss = compute_szabo_sseq (c);
|
{
|
||||||
multivariate_laurentpoly<Z> ssp = ss.pages[1].poincare_polynomial (ss.bounds);
|
knot_diagram kd (rolfsen_knot (i, j));
|
||||||
|
|
||||||
display ("ssp: ", ssp);
|
|
||||||
|
|
||||||
multivariate_laurentpoly<Z> p;
|
|
||||||
p.muladdeq (5, multivariate_laurent_monomial (VARIABLE, 1, -2));
|
|
||||||
p.muladdeq (-6, multivariate_laurent_monomial (VARIABLE, 2, 13));
|
|
||||||
p.muladdeq (14, (multivariate_laurent_monomial (VARIABLE, 1, 5)
|
|
||||||
* multivariate_laurent_monomial (VARIABLE, 2, -6)));
|
|
||||||
display ("p: ", p);
|
|
||||||
|
|
||||||
display ("p*p: ", p*p);
|
|
||||||
|
|
||||||
{
|
|
||||||
writer w ("dump");
|
|
||||||
write (w, p*p);
|
|
||||||
}
|
|
||||||
|
|
||||||
{
|
|
||||||
reader r ("dump");
|
|
||||||
multivariate_laurentpoly<Z> q (r);
|
|
||||||
|
|
||||||
display ("q: ", q);
|
|
||||||
|
|
||||||
assert (q == p*p);
|
|
||||||
}
|
|
||||||
#endif
|
#endif
|
||||||
|
for (unsigned i = 1; i <= 12; i ++)
|
||||||
|
for (unsigned j = 1; j <= htw_knots (i, 0); j ++)
|
||||||
|
{
|
||||||
|
knot_diagram kd (htw_knot (i, 0, j));
|
||||||
|
|
||||||
|
kd.marked_edge = 1;
|
||||||
|
|
||||||
|
show (kd); newline ();
|
||||||
|
|
||||||
|
spanning_tree_complex<Z2> c (kd);
|
||||||
|
|
||||||
#if 0
|
mod_map<fraction_field<polynomial<Z2> > > E2_d = c.twisted_d2 ();
|
||||||
multivariate_laurentpoly<Z> p = -11;
|
assert (E2_d.compose (E2_d) == 0);
|
||||||
p.muladdeq (5, VARIABLE, 1);
|
// display ("E2_d:\n", E2_d);
|
||||||
p.muladdeq (7, VARIABLE, 2);
|
|
||||||
p.muladdeq (-3, VARIABLE, 3);
|
chain_complex_simplifier<fraction_field<polynomial<Z2> > > E2_s (c.C, E2_d, 2);
|
||||||
|
assert (E2_s.new_d == 0);
|
||||||
|
|
||||||
|
multivariate_laurentpoly<Z> E3_p = E2_s.new_C->free_delta_poincare_polynomial ();
|
||||||
|
printf ("E3_p = "); show (E3_p); newline ();
|
||||||
|
|
||||||
|
mod_map<fraction_field<polynomial<Z2> > > tt_d = c.totally_twisted_kh_d ();
|
||||||
|
assert (tt_d.compose (tt_d) == 0);
|
||||||
|
// display ("tt_d:\n", tt_d);
|
||||||
|
|
||||||
|
chain_complex_simplifier<fraction_field<polynomial<Z2> > > tt_s (c.C, tt_d, 2);
|
||||||
|
assert (tt_s.new_d == 0);
|
||||||
|
|
||||||
multivariate_laurentpoly<Z> q = p*p + p + 23;
|
multivariate_laurentpoly<Z> tt_p = tt_s.new_C->free_delta_poincare_polynomial ();
|
||||||
multivariate_laurentpoly<Z> r = q*q - Z (7)*p + 81;
|
printf ("tt_p = "); show (tt_p); newline ();
|
||||||
|
|
||||||
multivariate_laurentpoly<Z> s = r - p*q + 10;
|
cube<Z2> kh_c (kd, 1);
|
||||||
|
mod_map<Z2> kh_d = kh_c.compute_d (1, 0, 0, 0, 0);
|
||||||
display ("p:", p);
|
|
||||||
display ("q:", q);
|
sseq_builder builder (kh_c.khC, kh_d);
|
||||||
display ("r:", r);
|
sseq ss = builder.build_sseq ();
|
||||||
display ("s:", s);
|
multivariate_laurentpoly<Z> kh_p = ss.pages[1].delta_poincare_polynomial (ss.bounds);
|
||||||
|
printf ("kh_p = "); show (kh_p); newline ();
|
||||||
map<multivariate_laurentpoly<Z>, std::string> m;
|
|
||||||
m.push (p, "p");
|
if (tt_p != kh_p)
|
||||||
m.push (q, "q");
|
printf (" > tt_p != kh_p!!\n");
|
||||||
m.push (r, "thisisr");
|
|
||||||
|
if (! rank_lte (E3_p, tt_p))
|
||||||
assert (m % p);
|
printf (" > rank E2 > rank tt!!\n");
|
||||||
assert (m % q);
|
}
|
||||||
assert (m % r);
|
|
||||||
assert (! (m % s));
|
|
||||||
|
|
||||||
assert (m(p) == "p");
|
|
||||||
assert (m(q) == "q");
|
|
||||||
assert (m(r) == "thisisr");
|
|
||||||
|
|
||||||
std::string str ("This is a test.");
|
|
||||||
|
|
||||||
{
|
|
||||||
writer w ("test.dat");
|
|
||||||
write (w, m);
|
|
||||||
}
|
|
||||||
|
|
||||||
reader rdr ("test.dat");
|
|
||||||
map<multivariate_laurentpoly<Z>, std::string> m2 (rdr);
|
|
||||||
|
|
||||||
assert (m == m2);
|
|
||||||
|
|
||||||
assert (m2(p) == "p");
|
|
||||||
assert (m2(q) == "q");
|
|
||||||
assert (m2(r) == "thisisr");
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#if 0
|
|
||||||
test_ring<Z2> (2);
|
|
||||||
test_ring<Z> (0);
|
|
||||||
test_ring<Q> (0);
|
|
||||||
test_ring<Zp<2> > (2);
|
|
||||||
test_ring<Zp<3> > (3);
|
|
||||||
test_ring<Zp<5> > (5);
|
|
||||||
test_ring<Zp<7> > (7);
|
|
||||||
|
|
||||||
test_field<Q> ();
|
|
||||||
test_field<Zp<7> > ();
|
|
||||||
test_field<Zp<5> > ();
|
|
||||||
test_field<Zp<3> > ();
|
|
||||||
test_field<Z2> ();
|
|
||||||
test_field<Zp<2> > ();
|
|
||||||
#endif
|
|
||||||
}
|
}
|
||||||
|
|||||||
@ -22,7 +22,8 @@ class spanning_tree_complex
|
|||||||
|
|
||||||
grading tree_grading (unsigned i) const;
|
grading tree_grading (unsigned i) const;
|
||||||
void show_tree (unsigned i) const;
|
void show_tree (unsigned i) const;
|
||||||
|
|
||||||
|
mod_map<R> totally_twisted_kh_d () const;
|
||||||
mod_map<R> twisted_d2 () const;
|
mod_map<R> twisted_d2 () const;
|
||||||
};
|
};
|
||||||
|
|
||||||
@ -90,8 +91,8 @@ template<class F> mod_map<fraction_field<polynomial<F> > >
|
|||||||
spanning_tree_complex<F>::twisted_d2 () const
|
spanning_tree_complex<F>::twisted_d2 () const
|
||||||
{
|
{
|
||||||
assert (kd.marked_edge);
|
assert (kd.marked_edge);
|
||||||
|
|
||||||
mod_map<R> d (C);
|
map_builder<R> b (C);
|
||||||
|
|
||||||
basedvector<int, 1> edge_weight (kd.num_edges ());
|
basedvector<int, 1> edge_weight (kd.num_edges ());
|
||||||
for (unsigned i = 1; i <= kd.num_edges (); i ++)
|
for (unsigned i = 1; i <= kd.num_edges (); i ++)
|
||||||
@ -201,10 +202,107 @@ spanning_tree_complex<F>::twisted_d2 () const
|
|||||||
x += R (polynomial<F> (1),
|
x += R (polynomial<F> (1),
|
||||||
polynomial<F> (1) + polynomial<F> (1, B));
|
polynomial<F> (1) + polynomial<F> (1, B));
|
||||||
|
|
||||||
d[i].muladd (x, j);
|
b[i].muladd (x, j);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
return d;
|
return mod_map<R> (b);
|
||||||
|
}
|
||||||
|
|
||||||
|
template<class F> mod_map<fraction_field<polynomial<F> > >
|
||||||
|
spanning_tree_complex<F>::totally_twisted_kh_d () const
|
||||||
|
{
|
||||||
|
assert (kd.marked_edge);
|
||||||
|
|
||||||
|
map_builder<R> b (C);
|
||||||
|
|
||||||
|
basedvector<int, 1> edge_weight (kd.num_edges ());
|
||||||
|
for (unsigned i = 1; i <= kd.num_edges (); i ++)
|
||||||
|
{
|
||||||
|
edge_weight[i] = i;
|
||||||
|
// edge_weight[i] = (1 << i);
|
||||||
|
// edge_weight[i] = 1;
|
||||||
|
}
|
||||||
|
|
||||||
|
for (unsigned i = 1; i <= trees.size (); i ++)
|
||||||
|
{
|
||||||
|
set<unsigned> t = trees[i];
|
||||||
|
|
||||||
|
smallbitset r (kd.n_crossings);
|
||||||
|
for (unsigned k = 1; k <= kd.n_crossings; k ++)
|
||||||
|
{
|
||||||
|
if ((edge_height[k] == 1) == (t % k))
|
||||||
|
r.push (k);
|
||||||
|
}
|
||||||
|
smoothing s (kd, r);
|
||||||
|
|
||||||
|
for (set_const_iter<unsigned> ee = t; ee; ee ++)
|
||||||
|
{
|
||||||
|
unsigned e = ee.val ();
|
||||||
|
|
||||||
|
if (edge_height[e] != 0)
|
||||||
|
continue;
|
||||||
|
|
||||||
|
for (unsigned f = 1; f <= bg.num_edges (); f ++)
|
||||||
|
{
|
||||||
|
if (edge_height[f] != 1 || (t % f))
|
||||||
|
continue;
|
||||||
|
|
||||||
|
set<unsigned> t2 (COPY, t);
|
||||||
|
t2.yank (e);
|
||||||
|
t2.push (f);
|
||||||
|
unsigned j = tree_idx(t2, 0);
|
||||||
|
if (j == 0)
|
||||||
|
continue;
|
||||||
|
|
||||||
|
set<unsigned> neither (COPY, t);
|
||||||
|
neither.yank (e);
|
||||||
|
|
||||||
|
smallbitset neither_r (kd.n_crossings);
|
||||||
|
for (unsigned k = 1; k <= kd.n_crossings; k ++)
|
||||||
|
{
|
||||||
|
if ((edge_height[k] == 1) == (neither % k))
|
||||||
|
neither_r.push (k);
|
||||||
|
}
|
||||||
|
smoothing neither_s (kd, neither_r);
|
||||||
|
|
||||||
|
set<unsigned> both (COPY, t);
|
||||||
|
both.push (f);
|
||||||
|
|
||||||
|
R A = 0;
|
||||||
|
for (unsigned k = 1; k <= kd.num_edges (); k ++)
|
||||||
|
{
|
||||||
|
if (neither_s.edge_circle[k]
|
||||||
|
!= neither_s.edge_circle[kd.marked_edge])
|
||||||
|
A += polynomial<F> (1, edge_weight[k]);
|
||||||
|
}
|
||||||
|
|
||||||
|
smallbitset both_r (kd.n_crossings);
|
||||||
|
for (unsigned k = 1; k <= kd.n_crossings; k ++)
|
||||||
|
{
|
||||||
|
if ((edge_height[k] == 1) == (both % k))
|
||||||
|
both_r.push (k);
|
||||||
|
}
|
||||||
|
smoothing both_s (kd, both_r);
|
||||||
|
|
||||||
|
R B = 0;
|
||||||
|
for (unsigned k = 1; k <= kd.num_edges (); k ++)
|
||||||
|
{
|
||||||
|
if (both_s.edge_circle[k]
|
||||||
|
!= both_s.edge_circle[kd.marked_edge])
|
||||||
|
B += polynomial<F> (1, edge_weight[k]);
|
||||||
|
}
|
||||||
|
|
||||||
|
R x;
|
||||||
|
|
||||||
|
x += R (polynomial<F> (1)) / A;
|
||||||
|
x += R (polynomial<F> (1)) / B;
|
||||||
|
|
||||||
|
b[i].muladd (x, j);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
return mod_map<R> (b);
|
||||||
}
|
}
|
||||||
|
|||||||
5
sseq.h
5
sseq.h
@ -150,8 +150,7 @@ class chain_complex_simplifier
|
|||||||
mod_map<R> pi, iota;
|
mod_map<R> pi, iota;
|
||||||
|
|
||||||
private:
|
private:
|
||||||
mod_map<R> new_d0;
|
basedvector<linear_combination, 1> new_d0;
|
||||||
|
|
||||||
basedvector<set<unsigned>, 1> preim;
|
basedvector<set<unsigned>, 1> preim;
|
||||||
|
|
||||||
bool build_pi_iota;
|
bool build_pi_iota;
|
||||||
@ -271,7 +270,7 @@ chain_complex_simplifier<R>::chain_complex_simplifier (ptr<const module<R> > C_,
|
|||||||
int dh,
|
int dh,
|
||||||
bool build_pi_iota_)
|
bool build_pi_iota_)
|
||||||
: C(C_), n(C_->dim ()), d(d_),
|
: C(C_), n(C_->dim ()), d(d_),
|
||||||
new_d0(COPY2, d),
|
new_d0(COPY2, d_.explicit_columns ()),
|
||||||
preim(C_->dim ()),
|
preim(C_->dim ()),
|
||||||
build_pi_iota(build_pi_iota_)
|
build_pi_iota(build_pi_iota_)
|
||||||
{
|
{
|
||||||
|
|||||||
Loading…
Reference in New Issue
Block a user