marchwicka/signature_function
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

saving results to file

Browse Source
This commit is contained in:
maria 2021-07-22 23:24:13 +02:00
parent e125b72ef2
commit 10c79cb47c
8 changed files with 573 additions and 268431 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

42
gaknot/__init__.py
View File

@ -6,27 +6,33 @@ r"""calculations of signature function and sigma invariant of generalized algebr
The package was used to prove Lemma 3.2 from a paper The package was used to prove Lemma 3.2 from a paper
'On the slice genus of generalized algebraic knots' Maria Marchwicka and Wojciech Politarczyk). 'On the slice genus of generalized algebraic knots' Maria Marchwicka and Wojciech Politarczyk).
It contains the following submodules. It contains the following submodules.
1) signature.sage - contains SignatureFunction class; 1) main.sage - with function prove_lemma
2) signature.sage - contains SignatureFunction class;
it encodes twisted and untwisted signature functions it encodes twisted and untwisted signature functions
of knots and allows to perform algebraic operations on them. of knots and allows to perform algebraic operations on them.
2) cable_signature.sage - contains the following classes: 3) cable_signature.sage - contains the following classes:
a) CableSummand - it represents a single cable knot, a) CableSummand - it represents a single cable knot,
b) CableSum - it represents a cable sum, i. e. linear combination of single cable knots; b) CableSum - it represents a cable sum, i. e. linear combination of single cable knots;
since the signature function and sigma invariant are additive under connected sum, since the signature function and sigma invariant are additive under connected sum,
the class use calculations from CableSummand objects, the class use calculations from CableSummand objects,
c) CableTemplate - it represents schema for a cable sums. c) CableTemplate - it represents a scheme for a cable sums.
3) main.sage - module that encodes interesting schemas for cable and perform calculations,
e.g. a proof for Lemma 3.2 from the paper.
""" """
#
# A knot (cable sum) is encoded as a list where each element (also a list) corresponds to a cable knot, e.g. a list from .utility import import_sage
# [[1, 3], [2], [-1, -2], [-3]] encodes import os
# T(2, 3; 2, 7) # T(2, 5) # -T(2, 3; 2, 5) # -T(2, 7).
# package = __name__.split('.')[0]
# To calculate the number of characters for which signature function vanish use dirname = os.path.dirname
# the function . path = dirname(dirname(__file__))
# import_sage('signature', package=package, path=path)
import_sage('cable_signature', package=package, path=path)
import_sage('main', package=package, path=path)
from .main import prove_lemma
# EXAMPLES:: # EXAMPLES::
# #
# sage: eval_cable_for_null_signature([[1, 3], [2], [-1, -2], [-3]]) # sage: eval_cable_for_null_signature([[1, 3], [2], [-1, -2], [-3]])
@ -56,13 +62,3 @@ It contains the following submodules.
# 2) set each q_i all or choose range in which q_i should varry # 2) set each q_i all or choose range in which q_i should varry
# 3) choose vector v / theta vector. # 3) choose vector v / theta vector.
# #
from .utility import import_sage
import os
package = __name__.split('.')[0]
dirname = os.path.dirname
path = dirname(dirname(__file__))
import_sage('signature', package=package, path=path)
import_sage('cable_signature', package=package, path=path)
import_sage('main', package=package, path=path)

127
gaknot/cable_signature.sage
View File

@ -3,7 +3,9 @@
import numpy as np import numpy as np
import itertools as it import itertools as it
import warnings import warnings
import logging
import re import re
import ast
from typing import Iterable from typing import Iterable
from collections import Counter from collections import Counter
from sage.arith.functions import LCM_list from sage.arith.functions import LCM_list
@ -487,8 +489,11 @@ class CableSum:
return result.is_integer() return result.is_integer()
def is_function_big_in_ranges(self, ranges_list, invariant=SIGMA, def is_function_big_in_ranges(self, ranges_list, invariant=SIGMA,
verbose=None): verbose=None, details=False,
p_part_order=None):
verbose = verbose or self.verbose verbose = verbose or self.verbose
p_part_order = p_part_order or self.q_order
if invariant == SIGNATURE: if invariant == SIGNATURE:
get_invariant = self.get_sign_ext_for_theta get_invariant = self.get_sign_ext_for_theta
name = "signature (extremum)" name = "signature (extremum)"
@ -496,21 +501,25 @@ class CableSum:
get_invariant = self.sigma_as_function_of_theta get_invariant = self.sigma_as_function_of_theta
name = "sigma value" name = "sigma value"
if verbose:
msg = "\nCalculating {}-primary part.".format(p_part_order)
print(msg)
logging.info(str(ranges_list))
for thetas in it.product(*ranges_list): for thetas in it.product(*ranges_list):
# Check only non-zero metabolizers. # Check only non-zero metabolizers.
if not self.is_metabolizer(thetas) or not any(thetas): if not self.is_metabolizer(thetas) or not any(thetas):
continue continue
#
# cond1 = thetas[0] and thetas[3] and not thetas[1] and not thetas[2]
# cond = thetas[0] and thetas[3] and not thetas[1] and not thetas[2]
function_is_small = True function_is_small = True
# Check if any element generated by thetas vector # Check if any element generated by thetas vector
# has a large signature or sigma. # has a large signature or sigma.
for shift in range(1, self.q_order): for shift in range(1, p_part_order):
shifted_thetas = [shift * th for th in thetas] shifted_thetas = \
[(shift * th) % p_part_order for th in thetas]
limit = 5 + np.count_nonzero(shifted_thetas) limit = 5 + np.count_nonzero(shifted_thetas)
inv_value = get_invariant(shifted_thetas, limit=limit) inv_value = get_invariant(shifted_thetas, limit=limit)
abs_value = abs(inv_value) abs_value = abs(inv_value)
@ -518,17 +527,22 @@ class CableSum:
if verbose: if verbose:
if shift == 1: if shift == 1:
print("\n" + "*" * 10) print("\n" + "*" * 10)
print("Knot sum:\n" + self.knot_description) print("[ character ] " + name)
print("[ characters ] " + name)
print(shifted_thetas, end=" ") print(shifted_thetas, end=" ")
print(inv_value) print(inv_value)
if abs_value > limit: if abs_value > limit:
function_is_small = False function_is_small = False
if invariant == SIGMA and verbose: if details:
self.print_calculations_for_sigma(*shifted_thetas) self.print_calculations_for_sigma(*shifted_thetas)
break break
if function_is_small: if function_is_small:
if verbose and invariant == SIGMA:
msg = "For an element x = " + str(thetas)
msg += " there does not exist any shift such that "
msg += "|sigma(K, shift * x)| > {}.\n".format(limit)
msg += "We can not give any lower bound for 4-genus."
print(msg)
return False return False
return True return True
@ -569,34 +583,63 @@ class CableSum:
print("Sigma = {} ~ {}\n".format(sigma[2], int(sigma[2]))) print("Sigma = {} ~ {}\n".format(sigma[2], int(sigma[2])))
# function that proves the main lemma # function that proves the main lemma
def is_function_big_for_all_metabolizers(self, invariant=SIGMA): def is_function_big_for_all_metabolizers(self, invariant=SIGMA,
verbose=False, details=False):
logging.info("start of is_function_big_for_all_metabolizers")
if invariant == SIGNATURE:
name = "signature (extremum)"
else:
name = "sigma value"
num_of_summands = len(self.knot_sum_as_k_valus) num_of_summands = len(self.knot_sum_as_k_valus)
if num_of_summands % 4: if num_of_summands % 4:
f_name = self.is_signature_big_for_all_metabolizers.__name__ f_name = self.is_signature_big_for_all_metabolizers.__name__
msg = "Function {}".format(f_name) + " is implemented only for " +\ msg = "Function {}".format(f_name) + " is implemented only for " +\
"knots that are direct sums of 4n direct summands." "knots that are direct sums of 4n direct summands."
raise ValueError(msg) raise ValueError(msg)
# check each p-primary part separately # check each p-primary part separately
logging.info("number of summands is {}".format(num_of_summands))
for shift in range(0, num_of_summands, 4): for shift in range(0, num_of_summands, 4):
# set character (twist) to be zero for all summands
ranges_list = num_of_summands * [range(0, 1)] logging.info("shift is {}".format(shift))
p_part_order = 2 * self.patt_k_list[shift] + 1
logging.info("set character (twist) to be zero for all summands")
ranges_list = num_of_summands * [range(1)]
logging.info(str(ranges_list))
# change ranges for all but one character for current p-primary part # change ranges for all but one character for current p-primary part
ranges_list[shift : shift + 3] = \ ranges_list[shift + 1 : shift + 4] = 3 * [range(p_part_order)]
[range(0, i + 1) for i in self.patt_k_list[shift: shift + 3]]
# change range for last character in current p-primary part # change range for first character in current p-primary part
# this one is consider to be 0 or 1 # this one is consider to be 0 or 1
# For any characters combinations (vectors) [a_1, a_2, a_3, a_4] where a_4 != 0 # For any characters combinations (vectors) [a_1, a_2, a_3, a_4]
# exists such as k < p that k * a_4 % p == 1. # where a_4 != 0 exists such a k < p that k * a_1 % p == 1.
ranges_list[shift + 3] = range(0, 2) ranges_list[shift] = range(0, 2)
if not self.is_function_big_in_ranges(ranges_list, invariant): logging.info("\n\ncall is_function_big_in_ranges with values")
logging.info(str(ranges_list))
if not self.is_function_big_in_ranges(ranges_list, invariant,
p_part_order=p_part_order,
verbose=verbose,
details=details):
logging.info("Not proven.")
return False return False
if verbose and invariant == SIGMA:
msg = "For each p-primery part for each vector x there exist "
msg += "a number 0 < shift < p such that "
msg += "sigma(K, shift * x) > 5 + eta(K, shift * x)."
print(msg)
print("q.e.d.")
return True return True
class CableTemplate: class CableTemplate:
def __init__(self, knot_formula, q_vector=None, k_vector=None, def __init__(self, knot_formula, q_vector=None, k_vector=None,
generate_q_vector=True, slice=True, verbose=False): generate_q_vector=True, algebraic=True, verbose=False):
self.verbose = verbose self.verbose = verbose
self._knot_formula = knot_formula self._knot_formula = knot_formula
# q_i = 2 * k_i + 1 # q_i = 2 * k_i + 1
@ -605,7 +648,27 @@ class CableTemplate:
elif q_vector is not None: elif q_vector is not None:
self.q_vector = q_vector self.q_vector = q_vector
elif generate_q_vector: elif generate_q_vector:
self.q_vector = self.get_q_vector(slice=slice) self.q_vector = self.get_q_vector(algebraic=slice)
self.templete_description = self.get_template_descrption()
def __str__(self):
return self.templete_description
def get_template_descrption(self):
k_indices = re.sub(r'[k ]', '', self.knot_formula)
k_indices = re.sub(r'\[\d+\]', lambda x: x.group()[1:-1], k_indices)
k_indices = ast.literal_eval(k_indices)
description = ""
for summand in k_indices :
part = ""
if summand[0] < 0:
part += "-"
part += "T("
for k in summand:
part += "2, q_" + str(abs(k)) + "; "
description += part[:-2] + ") # "
return description[:-3]
@property @property
def cable(self): def cable(self):
@ -616,7 +679,7 @@ class CableTemplate:
self.fill_q_vector() self.fill_q_vector()
return self._cable return self._cable
def fill_q_vector(self, q_vector=None, slice=True, lowest_number=2): def fill_q_vector(self, q_vector=None, algebraic=True, lowest_number=2):
self.q_vector = q_vector or self.get_q_vector(slice, lowest_number) self.q_vector = q_vector or self.get_q_vector(slice, lowest_number)
@property @property
@ -631,6 +694,7 @@ class CableTemplate:
self._k_vector = k self._k_vector = k
if self.extract_max(self.knot_formula) > len(k) - 1: if self.extract_max(self.knot_formula) > len(k) - 1:
msg = "The vector for knot_formula evaluation is to short!" msg = "The vector for knot_formula evaluation is to short!"
msg += "Note that we count from 0 (not 1)."
msg += "\nk_vector " + str(k) + " \nknot_formula " \ msg += "\nk_vector " + str(k) + " \nknot_formula " \
+ str(self.knot_formula) + str(self.knot_formula)
raise IndexError(msg) raise IndexError(msg)
@ -652,19 +716,28 @@ class CableTemplate:
numbers = map(int, numbers) numbers = map(int, numbers)
return max(numbers) return max(numbers)
def get_q_vector(self, slice=True, lowest_number=2): def get_q_vector(self, algebraic=True, lowest_number=2):
r"""
Returns q-vector with certain properties.
If slice a specific relation for each cabling-level is preserved.
Consider a cable T(2, q_0; 2, q_1; ...; 2, q_n).
Then for every q_i, q_(i + 1): q_(i + 1) > q_i * 4
"""
knot_formula = self.knot_formula knot_formula = self.knot_formula
q_vector = [0] * (self.extract_max(knot_formula) + 1) q_vector = [0] * (self.extract_max(knot_formula) + 1)
P = Primes() P = Primes()
for layer in self.get_layers_from_formula(knot_formula)[::-1]: for layer in self._get_layers_from_formula(knot_formula)[::-1]:
for el in layer: for el in layer:
q_vector[el] = P.next(lowest_number) q_vector[el] = P.next(lowest_number)
lowest_number = q_vector[el] lowest_number = q_vector[el]
lowest_number *= 4 if slice:
lowest_number *= 4
return q_vector return q_vector
@staticmethod @staticmethod
def get_layers_from_formula(knot_formula): def _get_layers_from_formula(knot_formula):
r"""helper method for get_q_vector"""
k_indices = re.sub(r'[k-]', '', knot_formula) k_indices = re.sub(r'[k-]', '', knot_formula)
k_indices = re.sub(r'\[\d+\]', lambda x: x.group()[1:-1], k_indices) k_indices = re.sub(r'\[\d+\]', lambda x: x.group()[1:-1], k_indices)
k_indices = eval(k_indices) k_indices = eval(k_indices)

286
gaknot/main.sage
View File

@ -1,6 +1,9 @@
#!/usr/bin/env sage -python #!/usr/bin/env sage -python
# TBD: read about Factory Method, variable in docstring, sage documentation,
# TBD
# print scheme and knot nicely
# read about Factory Method, variable in docstring, sage documentation,
# print calc. to output file # print calc. to output file
# decide about printing option # decide about printing option
# make __main__? # make __main__?
@ -13,6 +16,9 @@ import re
import numpy as np import numpy as np
import importlib import importlib
# constants - which invariants should be calculate
SIGMA = 0
SIGNATURE = 1
if __name__ == '__main__': if __name__ == '__main__':
from utility import import_sage from utility import import_sage
@ -33,41 +39,62 @@ cs = import_sage('cable_signature', package=package, path=path)
# def __init__(self): # def __init__(self):
# self.f_results = os.path.join(os.getcwd(), "results.out") # self.f_results = os.path.join(os.getcwd(), "results.out")
class Schemas: class Schema:
r"""This class stores inreresting schema of cable sums.
Cable knots sum can be given as a scheme, e.g. a scheme from the paper:
K(p_1 , p_2 , q_1 , q_2 , q_3 ) =
T(2, q_1; 2, p_1) # -T(2, q_2; 2, p_1) # T(2, p_1) # -T(2, q_3; 2, p_1) +
T(2, q_2; 2, p_2) # -T(2, p_2) # T(2, q_3; 2, p_2) # -T(2, q_1; 2, p_2).
We can represent it as nested list:
lemma_scheme = "[[ k[5], k[3]], " + \
"[ -k[1], -k[3]], " + \
"[ k[3]], " + \
"[ -k[6], -k[3]], " + \
"[ k[1], k[7]], " + \
"[ -k[7]], " + \
"[ k[6], k[7]], " + \
"[ -k[5], -k[7]]]",
where each k[i] corresponds to some q_i or p_i.
This expression will be later evaluated with k_vector.
See k_vector setter in class CableTemplate in cable_signature.sage module.
# knot_formula = "[[k[0], k[1], k[2]],\ Remark 1
# [ k[3], k[4]],\ In the paper we used p_i and q_i to describe torus knots and cables.
# [-k[0], -k[3], -k[4]],\ It was convinient for writing, but in all the code and documentation
# [ -k[1], -k[2]]]" only 'q' letter is used to encode torus knots or cables.
#
# knot_formula = "[[k[0], k[1], k[2]],\
# [ k[3]],\
# [-k[0], -k[1], -k[3]],\
# [ -k[2]]]"
Remark 2
There are two ways to set k[i] values for a scheme:
via q_vector or via k_vector.
Both should be lists and the relation is q[i] = 2 * k[i] + 1,
i.e. q should be an odd prime and k should be an even number such that
2 * k + 1 is prime.
To fill the scheme listed above we shoud use a list of lenght 8,
and k[0] will be ommited as it is not used in the scheme.
short_3_layers_a = "[[ k[5], k[3]], " + \ Remark 3
"[ -k[1], -k[3]], " + \ Except for development purposes, q_vector was computed with
"[ k[3]], " + \ a methode CableTemplate.get_q_vector and flag slice=True.
"[ -k[4], -k[6], -k[3]]]" The reason for that is that we were interested only in cases
where a specific relation for each cabling-level is preserved.
Consider a cable T(2, q_0; 2, q_1; ...; 2, q_n).
Then for every q_i, q_(i + 1): q_(i + 1) > q_i * 4.
short_3_layers_b = "[[k[4], k[1], k[7]], " + \ """
"[ -k[7]], " + \
"[ k[6], k[7]], " + \
"[ -k[5], -k[7]]]"
schema_short1 = "[ [k[5], k[3]], " + \ # scheme that is used in the paper
"[ -k[1], -k[3]], " + \ lemma_scheme_a = "[ [k[5], k[3]], " + \
"[ k[3]], " + \ "[ -k[1], -k[3]], " + \
"[ -k[6], -k[3]]]" "[ k[3]], " + \
"[ -k[6], -k[3]]]"
schema_short2 = "[[ k[1], k[7]], " + \ lemma_scheme_b = "[[ k[1], k[7]], " + \
"[ -k[7]], " + \ "[ -k[7]], " + \
"[ k[6], k[7]], " + \ "[ k[6], k[7]], " + \
"[ -k[5], -k[7]]]" "[ -k[5], -k[7]]]"
schema_short = "[[ k[5], k[3]], " + \ lemma_scheme = "[[ k[5], k[3]], " + \
"[ -k[1], -k[3]], " + \ "[ -k[1], -k[3]], " + \
"[ k[3]], " + \ "[ k[3]], " + \
"[ -k[6], -k[3]], " + \ "[ -k[6], -k[3]], " + \
@ -76,40 +103,76 @@ class Schemas:
"[ k[6], k[7]], " + \ "[ k[6], k[7]], " + \
"[ -k[5], -k[7]]]" "[ -k[5], -k[7]]]"
# two_summands_schema = "[ [k[0], k[1], k[4]], [-k[1], -k[3]],\
# [k[2], k[3]], [-k[0], -k[2], -k[4]] ]"
# two_small_summands_schema = "[[k[3]], [-k[3]],\
# [k[3]], [-k[3]] ]"
# #
# four_summands_schema = "[[k[3], k[2], k[0]],\ # formula_long = "[[k[0], k[5], k[3]], " + \
# [ -k[2], -k[0]],\ # "[ -k[5], -k[3]], " + \
# [ k[1], k[0]],\ # "[ k[2], k[3]], " + \
# [-k[3], -k[1], -k[0]]]" # "[-k[4], -k[2], -k[3]]" + \
# "[ k[4], k[1], k[7]], " + \
# "[ -k[1], -k[7]], " + \
# "[ k[6], k[7]], " + \
# "[-k[0], -k[6], -k[7]]]"
# #
four_summands_schema = "[[ k[0], k[1], k[3]]," + \ # formula_a = "[[k[0], k[5], k[3]], " + \
"[ -k[1], -k[3]]," + \ # "[ -k[1], -k[3]], " + \
"[ k[2], k[3]]," + \ # "[ k[3]], " + \
"[ -k[0], -k[2], -k[3]]]" # "[-k[4], -k[6], -k[3]]]"
#
# formula_1 = "[[ k[0], k[5], k[3]], " + \ # formula_b = "[[k[4], k[1], k[7]], " + \
# "[ -k[7]], " + \
# "[ k[6], k[7]], " + \
# "[-k[0], -k[5], -k[7]]]"
#
# formula_a = "[[ k[0], k[5], k[3]], " + \
# "[ -k[1], -k[3]], " + \ # "[ -k[1], -k[3]], " + \
# "[ k[2], k[3]], " + \ # "[ k[2], k[3]], " + \
# "[ -k[0], -k[2], -k[3]]]" # "[ -k[0], -k[2], -k[3]]]"
# #
# formula_2 = "[[ k[4], k[1], k[7]], " + \ # formula_b = "[[ k[4], k[1], k[7]], " + \
# "[ -k[5], -k[7]], " + \ # "[ -k[5], -k[7]], " + \
# "[ k[6], k[7]], " + \ # "[ k[6], k[7]], " + \
# "[ -k[4], -k[6], -k[7]]]" # "[ -k[4], -k[6], -k[7]]]"
# #
# formula_1 = "[[ k[0], k[5], k[3]], " + \ # formula_a = "[[ k[0], k[5], k[3]], " + \
# "[ -k[5], -k[3]], " + \ # "[ -k[5], -k[3]], " + \
# "[ k[2], k[3]], " + \ # "[ k[2], k[3]], " + \
# "[-k[4], -k[2], -k[3]]]" # "[-k[4], -k[2], -k[3]]]"
# #
# formula_2 = "[[ k[4], k[1], k[7]], " + \ # formula_b = "[[ k[4], k[1], k[7]], " + \
# "[ -k[1], -k[7]], " + \ # "[ -k[1], -k[7]], " + \
# "[ k[6], k[7]], " + \ # "[ k[6], k[7]], " + \
# "[-k[0], -k[6], -k[7]]]" # "[-k[0], -k[6], -k[7]]]"
#
#
# three_layers_formula_a = "[[k[0], k[1], k[2]],\
# [ k[3], k[4]],\
# [-k[0], -k[3], -k[4]],\
# [ -k[1], -k[2]]]"
#
# three_layers_formula_b = "[[k[0], k[1], k[2]],\
# [ k[3]],\
# [-k[0], -k[1], -k[3]],\
# [ -k[2]]]"
#
# short_3_layers_b = "[[ k[5], k[3]], " + \
# "[ -k[1], -k[3]], " + \
# "[ k[3]], " + \
# "[ -k[4], -k[6], -k[3]]]"
#
# short_3_layers_b = "[[k[4], k[1], k[7]], " + \
# "[ -k[7]], " + \
# "[ k[6], k[7]], " + \
# "[ -k[5], -k[7]]]"
#
# four_summands_scheme = "[[ k[0], k[1], k[3]]," + \
# "[ -k[1], -k[3]]," + \
# "[ k[2], k[3]]," + \
# "[ -k[0], -k[2], -k[3]]]"
#
# two_summands_scheme = "[ [k[0], k[1], k[4]], [-k[1], -k[3]],\
# [k[2], k[3]], [-k[0], -k[2], -k[4]] ]"
# two_small_summands_scheme = "[[k[3]], [-k[3]],\
# [k[3]], [-k[3]] ]"
def main(arg=None): def main(arg=None):
@ -120,43 +183,69 @@ def main(arg=None):
conf = Config() conf = Config()
cable_loop_with_details(conf) cable_loop_with_details(conf)
def prove_lemma(verbose=True, details=False):
def print_sigma_for_cable(verbose=True, Schemas=None): if verbose:
msg = "CALCULATIONS OF THE SIGMA INVARIANT\n"
msg += "Proof of main lemma from "
msg += "ON THE SLICE GENUS OF GENERALIZED ALGEBRAIC KNOTS\n\n"
print(msg)
schema_short1 = Schemas.schema_short1 lemma_scheme = Schema.lemma_scheme
schema_short2 = Schemas.schema_short2
schema_short = Schemas.schema_short
schema_four = Schemas.four_summands_schema
cable_template = cs.CableTemplate(knot_formula=schema_short) cable_template = cs.CableTemplate(knot_formula=lemma_scheme,
verbose=verbose)
cable_template.fill_q_vector()
q_v = cable_template.q_vector
cable = cable_template.cable
if verbose:
msg = "Let us consider a cable knot: \nK = "
msg += cable.knot_description + ".\n"
msg += "It is an example of cable knots of a scheme:\n"
msg += str(cable_template) + "."
print(msg)
cable.is_function_big_for_all_metabolizers(invariant=SIGMA,
verbose=verbose,
details=details)
def print_sigma_for_cable(verbose=True):
lemma_scheme_a = Schema.lemma_scheme_a
lemma_scheme_b = Schema.lemma_scheme_b
lemma_scheme = Schema.lemma_scheme
scheme_four = Schema.four_summands_scheme
cable_template = cs.CableTemplate(knot_formula=lemma_scheme)
cable_template.fill_q_vector() cable_template.fill_q_vector()
q_v = cable_template.q_vector q_v = cable_template.q_vector
print(q_v) print(q_v)
print(cable_template.cable.knot_description) print(cable_template.cable.knot_description)
cable1 = cs.CableTemplate(knot_formula=schema_short1, cable_a = cs.CableTemplate(knot_formula=lemma_scheme_a,
verbose=verbose, verbose=verbose,
q_vector=q_v q_vector=q_v
).cable ).cable
cable2 = cs.CableTemplate(knot_formula=schema_short2, cable_b = cs.CableTemplate(knot_formula=lemma_scheme_b,
verbose=verbose, verbose=verbose,
q_vector=q_v q_vector=q_v
).cable ).cable
cable = cs.CableTemplate(knot_formula=schema_short1, cable = cs.CableTemplate(knot_formula=lemma_scheme_a,
verbose=verbose, verbose=verbose,
q_vector=q_v q_vector=q_v
).cable ).cable
cable.plot_sigma_for_summands() cable.plot_sigma_for_summands()
# cable1.plot_sigma_for_summands() # cable_a.plot_sigma_for_summands()
# cable2.plot_sigma_for_summands() # cable_b.plot_sigma_for_summands()
def cable_loop_with_details(verbose=True): def cable_loop_with_details(verbose=True):
# verbose = False # verbose = False
schema_short1 = Schemas.schema_short1 lemma_scheme_a = Schema.lemma_scheme_a
schema_short2 = Schemas.schema_short2 lemma_scheme_b = Schema.lemma_scheme_b
schema_short = Schemas.schema_short lemma_scheme = Schema.lemma_scheme
cable_template = cs.CableTemplate(knot_formula=schema_short) cable_template = cs.CableTemplate(knot_formula=lemma_scheme)
list_of_q_vectors = [] list_of_q_vectors = []
# for el in [2, 3, 5, 7, 11, 13]: # for el in [2, 3, 5, 7, 11, 13]:
@ -165,19 +254,23 @@ def cable_loop_with_details(verbose=True):
q_v = cable_template.q_vector q_v = cable_template.q_vector
print(q_v) print(q_v)
print(cable_template.cable.knot_description) print(cable_template.cable.knot_description)
cable1 = cs.CableTemplate(knot_formula=schema_short1, cable_a = cs.CableTemplate(knot_formula=lemma_scheme_a,
verbose=verbose, verbose=verbose,
q_vector=q_v q_vector=q_v
).cable ).cable
cable2 = cs.CableTemplate(knot_formula=schema_short2, cable_b = cs.CableTemplate(knot_formula=lemma_scheme_b,
verbose=verbose, verbose=verbose,
q_vector=q_v q_vector=q_v
).cable ).cable
# print("\n") # print("\n")
# print(cable1.knot_description) # print(cable_a.knot_description)
is_1 = cable1.is_function_big_for_all_metabolizers(invariant=cs.SIGMA) is_a = cable_a.is_function_big_for_all_metabolizers(invariant=cs.SIGMA,
is_2 = cable2.is_function_big_for_all_metabolizers(invariant=cs.SIGMA) verbose=True,
if is_1 and is_2: details=True)
is_b = cable_b.is_function_big_for_all_metabolizers(invariant=cs.SIGMA,
verbose=True,
details=True)
if is_a and is_b:
print("sigma is big for all metabolizers") print("sigma is big for all metabolizers")
else: else:
print("sigma is not big for all metabolizers") print("sigma is not big for all metabolizers")
@ -186,11 +279,11 @@ def cable_loop_with_details(verbose=True):
def few_cable_without_calc(verbose=False): def few_cable_without_calc(verbose=False):
schema_short1 = Schemas.schema_short1 lemma_scheme_a = Schema.lemma_scheme_a
schema_short2 = Schemas.schema_short2 lemma_scheme_b = Schema.lemma_scheme_b
schema_short = Schemas.schema_short lemma_scheme = Schema.lemma_scheme
cable_template = cs.CableTemplate(knot_formula=schema_short) cable_template = cs.CableTemplate(knot_formula=lemma_scheme)
list_of_q_vectors = [] list_of_q_vectors = []
for el in [2, 3, 5, 7, 11, 13]: for el in [2, 3, 5, 7, 11, 13]:
@ -198,43 +291,23 @@ def few_cable_without_calc(verbose=False):
q_v = cable_template.q_vector q_v = cable_template.q_vector
print(q_v) print(q_v)
print(cable_template.cable.knot_description) print(cable_template.cable.knot_description)
cable1 = cs.CableTemplate(knot_formula=schema_short1, cable_a = cs.CableTemplate(knot_formula=lemma_scheme_a,
verbose=verbose, verbose=verbose,
q_vector=q_v q_vector=q_v
).cable ).cable
cable2 = cs.CableTemplate(knot_formula=schema_short2, cable_b = cs.CableTemplate(knot_formula=lemma_scheme_b,
verbose=verbose, verbose=verbose,
q_vector=q_v q_vector=q_v
).cable ).cable
is_1 = cable1.is_function_big_for_all_metabolizers(invariant=sigma) is_a = cable_a.is_function_big_for_all_metabolizers(invariant=sigma)
is_2 = cable2.is_function_big_for_all_metabolizers(invariant=sigma) is_b = cable_b.is_function_big_for_all_metabolizers(invariant=sigma)
if is_1 and is_2: if is_a and is_b:
print("sigma is big for all metabolizers") print("sigma is big for all metabolizers")
else: else:
print("sigma is not big for all metabolizers") print("sigma is not big for all metabolizers")
print("\n" * 3) print("\n" * 3)
def smallest_cable(verbose=True):
schema_short1 = Schemas.schema_short1
schema_short2 = Schemas.schema_short2
schema_short = Schemas.schema_short
cable_template = cs.CableTemplate(knot_formula=schema_short)
q_v = cable_template.q_vector
print(q_v)
cable1 = cs.CableTemplate(knot_formula=schema_short1,
verbose=verbose,
q_vector=q_v).cable
cable2 = cs.CableTemplate(knot_formula=schema_short2,
verbose=verbose,
q_vector=q_v).cable
cable1.is_function_big_for_all_metabolizers(invariant=sigma)
cable2.is_function_big_for_all_metabolizers(invariant=sigma)
def plot_many_untwisted_signature_functions(range_tuple=(1, 10)): def plot_many_untwisted_signature_functions(range_tuple=(1, 10)):
P = Primes() P = Primes()
for i in range(*range_tuple): for i in range(*range_tuple):
@ -250,26 +323,3 @@ if __name__ == '__main__':
else: else:
pass pass
# main() # main()
# formula_long = "[[k[0], k[5], k[3]], " + \
# "[-k[5], -k[3]], " + \
# "[k[2], k[3]], " + \
# "[-k[4], -k[2], -k[3]]" + \
# "[k[4], k[1], k[7]], " + \
# "[-k[1], -k[7]], " + \
# "[k[6], k[7]], " + \
# "[-k[0], -k[6], -k[7]]]"
#
#
# formula_1 = "[[k[0], k[5], k[3]], " + \
# "[-k[1], -k[3]], " + \
# "[ k[3]], " + \
# "[-k[4], -k[6], -k[3]]]"
#
# formula_2 = "[[k[4], k[1], k[7]], " + \
# "[ -k[7]], " + \
# "[k[6], k[7]], " + \
# "[-k[0], -k[5], -k[7]]]"
#
#

22
gaknot/signature.sage
View File

@ -32,7 +32,14 @@ ipython_info = get_ipython_info()
class SignatureFunction: class SignatureFunction:
r"""signature function is entirely encoded by its signature
jump, the class stores only information about signature jumps
in a dictionary self.jumps_counter
The dictionary stores data of the signature jump as a key/values pair,
where the key is the argument at which the functions jumps
and value encodes the value of the jump. Remember that we treat
signature functions as defined on the interval \[0,1).
"""
def __init__(self, values=None, counter=None, plot_title=''): def __init__(self, values=None, counter=None, plot_title=''):
# counter of signature jumps # counter of signature jumps
@ -367,16 +374,3 @@ class SignaturePloter:
\end{document} \end{document}
""" """
f.write(tail) f.write(tail)
SignatureFunction.__doc__ = \
"""
This simple class encodes twisted and untwisted signature functions
of knots. Since the signature function is entirely encoded by its signature
jump, the class stores only information about signature jumps
in a dictionary self.jumps_counter.
The dictionary stores data of the signature jump as a key/values pair,
where the key is the argument at which the functions jumps
and value encodes the value of the jump. Remember that we treat
signature functions as defined on the interval [0,1).
"""

4
gaknot/utility.py
View File

@ -27,7 +27,7 @@ def import_sage(module_name, package=None, path=''):
r"""Import or reload SageMath modules with preparse if the sage file exist. r"""Import or reload SageMath modules with preparse if the sage file exist.
Arguments: Arguments:
module_name - name of the module (without extension!) module_name - name of the module (without file extension!)
package - use only if module is used as a part of a package package - use only if module is used as a part of a package
Return: Return:
module module
@ -37,8 +37,6 @@ def import_sage(module_name, package=None, path=''):
# equivalent to import module_name as my_prefered_shortcut} # equivalent to import module_name as my_prefered_shortcut}
my_prefered_shortcut = import_sage('module_name') my_prefered_shortcut = import_sage('module_name')
""" """
sage_name = module_name + ".sage" sage_name = module_name + ".sage"
python_name = module_name + ".sage.py" python_name = module_name + ".sage.py"

99
notebooks/lemma.ipynb Normal file
View File

@ -0,0 +1,99 @@
{
"cells": [
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import path\n",
"import logging\n",
"from contextlib import redirect_stdout\n",
"# logging.basicConfig(level=logging.INFO)\n",
"import gaknot"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Lemma "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"scrolled": false
},
"outputs": [],
"source": [
"gaknot.prove_lemma()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Details to file"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"with open('very_detailed_calculations.txt', 'w') as f:\n",
" with redirect_stdout(f):\n",
" gaknot.prove_lemma(details=True)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Calculations to file"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"with open('calculations.txt', 'w') as f:\n",
" with redirect_stdout(f):\n",
" gaknot.prove_lemma(details=False)\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
}
],
"metadata": {
"kernelspec": {
"display_name": "SageMath 9.0",
"language": "sage",
"name": "sagemath"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.8.10"
}
},
"nbformat": 4,
"nbformat_minor": 4
}

268137
notebooks/main.ipynb
View File

File diff suppressed because one or more lines are too long

287
notebooks/tests.ipynb
View File

@ -12,7 +12,9 @@
"# display full output, not only last result, except ended with semicolon\n", "# display full output, not only last result, except ended with semicolon\n",
"from IPython.core.interactiveshell import InteractiveShell\n", "from IPython.core.interactiveshell import InteractiveShell\n",
"InteractiveShell.ast_node_interactivity = 'all';\n", "InteractiveShell.ast_node_interactivity = 'all';\n",
"from IPython.display import Image, SVG" "from IPython.display import Image, SVG\n",
"import logging\n",
"logging.basicConfig(level=logging.INFO)"
] ]
}, },
{ {
@ -28,6 +30,17 @@
"m = import_sage('main', package='gaknot', path=path.module_path)" "m = import_sage('main', package='gaknot', path=path.module_path)"
] ]
}, },
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"scrolled": false
},
"outputs": [],
"source": [
"m.prove_lemma(verbose=True)"
]
},
{ {
"cell_type": "markdown", "cell_type": "markdown",
"metadata": {}, "metadata": {},
@ -43,17 +56,17 @@
}, },
"outputs": [], "outputs": [],
"source": [ "source": [
"knot_formula = \"[[k[0], k[1], k[3]],\" + \\\n", "# knot_formula = \"[[k[0], k[1], k[3]],\" + \\\n",
" \" [-k[1], -k[3]],\" + \\\n", "# \" [-k[1], -k[3]],\" + \\\n",
" \" [k[2], k[3]],\" + \\\n", "# \" [k[2], k[3]],\" + \\\n",
" \" [-k[0], -k[2], -k[3]]]\"\n", "# \" [-k[0], -k[2], -k[3]]]\"\n",
"# q_vector = (3, 5, 7, 13)\n", "# # q_vector = (3, 5, 7, 13)\n",
"q_vector = (3, 5, 7, 11)\n", "# q_vector = (3, 5, 7, 11)\n",
"\n", "\n",
"template = cs.CableTemplate(knot_formula, q_vector=q_vector, verbose=True)\n", "# template = cs.CableTemplate(knot_formula, q_vector=q_vector, verbose=True)\n",
"cable = template.cable\n", "# cable = template.cable\n",
"# cable.plot_all_summands()\n", "# # cable.plot_all_summands()\n",
"cable.is_function_big_for_all_metabolizers(invariant=cs.SIGMA)" "# cable.is_function_big_for_all_metabolizers(invariant=cs.SIGMA)"
] ]
}, },
{ {
@ -80,11 +93,27 @@
"\n", "\n",
"\n", "\n",
"\n", "\n",
"cable_template_1 = cs.CableTemplate(knot_formula=formula_1)\n", "# cable_template_1 = cs.CableTemplate(knot_formula=formula_1)\n",
"cable_template_2 = cs.CableTemplate(knot_formula=formula_2)\n", "# cable_template_2 = cs.CableTemplate(knot_formula=formula_2)\n",
"cable_template = cable_template_1 + cable_template_2" "# cable_template = cable_template_1 + cable_template_2"
] ]
}, },
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# cable_template.knot_formula"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{ {
"cell_type": "markdown", "cell_type": "markdown",
"metadata": {}, "metadata": {},
@ -98,17 +127,17 @@
"metadata": {}, "metadata": {},
"outputs": [], "outputs": [],
"source": [ "source": [
"q_vector = (5, 13, 19, 41,\\\n", "# q_vector = (5, 13, 19, 41,\\\n",
" 7, 17, 23, 43)\n", "# 7, 17, 23, 43)\n",
"cable_template.fill_q_vector(q_vector=q_vector)\n", "# cable_template.fill_q_vector(q_vector=q_vector)\n",
"cable = cable_template.cable\n", "# cable = cable_template.cable\n",
"print(cable.knot_description)\n", "# print(cable.knot_description)\n",
"\n", "\n",
"q_vector_small = (3, 7, 13, 19,\\\n", "# q_vector_small = (3, 7, 13, 19,\\\n",
" 5, 11, 17, 23)\n", "# 5, 11, 17, 23)\n",
"cable_template.fill_q_vector(q_vector=q_vector)\n", "# cable_template.fill_q_vector(q_vector=q_vector)\n",
"cable = cable_template.cable\n", "# cable = cable_template.cable\n",
"print(cable.knot_description)" "# print(cable.knot_description)"
] ]
}, },
{ {
@ -136,14 +165,14 @@
"outputs": [], "outputs": [],
"source": [ "source": [
"\n", "\n",
"cable_template.fill_q_vector()\n", "# cable_template.fill_q_vector()\n",
"# print(cable_template.q_vector)\n", "# # print(cable_template.q_vector)\n",
"# print(cable_template.knot_formula)\n", "# # print(cable_template.knot_formula)\n",
"\n", "\n",
"slice_canidate = cable_template.cable\n", "# slice_canidate = cable_template.cable\n",
"print(slice_canidate.knot_description)\n", "# print(slice_canidate.knot_description)\n",
"sf = slice_canidate(4,4,4,4,0,0,0,0)\n", "# sf = slice_canidate(4,4,4,4,0,0,0,0)\n",
"sf = slice_canidate(4,1,1,4,0,0,0,0)\n", "# sf = slice_canidate(4,1,1,4,0,0,0,0)\n",
"\n", "\n",
"\n", "\n",
"# cable.is_signature_big_for_all_metabolizers()\n" "# cable.is_signature_big_for_all_metabolizers()\n"
@ -190,22 +219,22 @@
"\n", "\n",
"\n", "\n",
"\n", "\n",
"cable_template_1 = cs.CableTemplate(knot_formula=formula_1)\n", "# cable_template_1 = cs.CableTemplate(knot_formula=formula_1)\n",
"cable_template_2 = cs.CableTemplate(knot_formula=formula_2)\n", "# cable_template_2 = cs.CableTemplate(knot_formula=formula_2)\n",
"cable_template = cable_template_1 + cable_template_2\n", "# cable_template = cable_template_1 + cable_template_2\n",
"\n", "\n",
"cable_template.fill_q_vector()\n", "# cable_template.fill_q_vector()\n",
"# print(cable_template.q_vector)\n", "# # print(cable_template.q_vector)\n",
"# print(cable_template.knot_formula)\n", "# # print(cable_template.knot_formula)\n",
"\n", "\n",
"slice_canidate = cable_template.cable\n", "# slice_canidate = cable_template.cable\n",
"print(slice_canidate.knot_description)\n", "# print(slice_canidate.knot_description)\n",
"sf = slice_canidate(4,4,4,4,0,0,0,0)\n", "# sf = slice_canidate(4,4,4,4,0,0,0,0)\n",
"sf = slice_canidate(4,1,1,4,0,0,0,0)\n", "# sf = slice_canidate(4,1,1,4,0,0,0,0)\n",
"\n", "\n",
"\n", "\n",
"slice_canidate.q_order\n", "# slice_canidate.q_order\n",
"# slice_canidate.is_signature_big_for_all_metabolizers()" "# # slice_canidate.is_signature_big_for_all_metabolizers()"
] ]
}, },
{ {
@ -226,20 +255,20 @@
"\n", "\n",
"\n", "\n",
"\n", "\n",
"cable_template_1 = cs.CableTemplate(knot_formula=formula_1)\n", "# cable_template_1 = cs.CableTemplate(knot_formula=formula_1)\n",
"cable_template_2 = cs.CableTemplate(knot_formula=formula_2)\n", "# cable_template_2 = cs.CableTemplate(knot_formula=formula_2)\n",
"cable_template = cable_template_1 + cable_template_2\n", "# cable_template = cable_template_1 + cable_template_2\n",
"cable_template.fill_q_vector()\n", "# cable_template.fill_q_vector()\n",
"\n", "\n",
"slice_canidate = cable_template.cable\n", "# slice_canidate = cable_template.cable\n",
"print(slice_canidate.knot_description)\n", "# print(slice_canidate.knot_description)\n",
"\n", "\n",
"slice_canidate.q_order\n", "# slice_canidate.q_order\n",
"# slice_canidate.is_signature_big_for_all_metabolizers()\n", "# # slice_canidate.is_signature_big_for_all_metabolizers()\n",
"sigma = slice_canidate.get_sigma_as_function_of_theta()\n", "# sigma = slice_canidate.get_sigma_as_function_of_theta()\n",
"# sigma((0, 6, 6, 0, 0,0,0,0))\n", "# # sigma((0, 6, 6, 0, 0,0,0,0))\n",
"# 13450/83\n", "# # 13450/83\n",
"sigma((9, 9, 9, 9, 0,0,0,0))" "# sigma((9, 9, 9, 9, 0,0,0,0))"
] ]
}, },
{ {
@ -275,18 +304,18 @@
"\n", "\n",
"\n", "\n",
"\n", "\n",
"cable_template_1 = cs.CableTemplate(knot_formula=formula_1)\n", "# cable_template_1 = cs.CableTemplate(knot_formula=formula_1)\n",
"cable_template_2 = cs.CableTemplate(knot_formula=formula_2)\n", "# cable_template_2 = cs.CableTemplate(knot_formula=formula_2)\n",
"cable_template = cable_template_1 + cable_template_2\n", "# cable_template = cable_template_1 + cable_template_2\n",
"\n", "\n",
"cable_template.fill_q_vector()\n", "# cable_template.fill_q_vector()\n",
"# print(cable_template.q_vector)\n", "# # print(cable_template.q_vector)\n",
"# print(cable_template.knot_formula)\n", "# # print(cable_template.knot_formula)\n",
"\n", "\n",
"slice_canidate = cable_template.cable\n", "# slice_canidate = cable_template.cable\n",
"print(slice_canidate.knot_description)\n", "# print(slice_canidate.knot_description)\n",
"sf = slice_canidate(4,4,4,4,0,0,0,0)\n", "# sf = slice_canidate(4,4,4,4,0,0,0,0)\n",
"sf = slice_canidate(4,1,1,4,0,0,0,0)\n", "# sf = slice_canidate(4,1,1,4,0,0,0,0)\n",
"# slice_canidate.is_signature_big_for_all_metabolizers()" "# slice_canidate.is_signature_big_for_all_metabolizers()"
] ]
}, },
@ -311,20 +340,20 @@
"\n", "\n",
"\n", "\n",
"\n", "\n",
"cable_template_1 = cs.CableTemplate(knot_formula=formula_1)\n", "# cable_template_1 = cs.CableTemplate(knot_formula=formula_1)\n",
"cable_template_2 = cs.CableTemplate(knot_formula=formula_2)\n", "# cable_template_2 = cs.CableTemplate(knot_formula=formula_2)\n",
"cable_template = cable_template_1 + cable_template_2\n", "# cable_template = cable_template_1 + cable_template_2\n",
"\n", "\n",
"cable_template.fill_q_vector()\n", "# cable_template.fill_q_vector()\n",
"# print(cable_template.q_vector)\n", "# # print(cable_template.q_vector)\n",
"# print(cable_template.knot_formula)\n", "# # print(cable_template.knot_formula)\n",
"\n", "\n",
"slice_canidate = cable_template.cable\n", "# slice_canidate = cable_template.cable\n",
"print(slice_canidate.knot_description)\n", "# print(slice_canidate.knot_description)\n",
"sf = slice_canidate(4,4,4,4,0,0,0,0)\n", "# sf = slice_canidate(4,4,4,4,0,0,0,0)\n",
"sf = slice_canidate(4,1,1,4,0,0,0,0)\n", "# sf = slice_canidate(4,1,1,4,0,0,0,0)\n",
"slice_canidate.q_order\n", "# slice_canidate.q_order\n",
"# slice_canidate.is_signature_big_for_all_metabolizers()\n" "# # slice_canidate.is_signature_big_for_all_metabolizers()\n"
] ]
}, },
{ {
@ -333,8 +362,8 @@
"metadata": {}, "metadata": {},
"outputs": [], "outputs": [],
"source": [ "source": [
"sf = slice_canidate()\n", "# sf = slice_canidate()\n",
"sf = sf[2]" "# sf = sf[2]"
] ]
}, },
{ {
@ -343,7 +372,7 @@
"metadata": {}, "metadata": {},
"outputs": [], "outputs": [],
"source": [ "source": [
"sf.plot()" "# sf.plot()"
] ]
}, },
{ {
@ -360,24 +389,62 @@
"formula_2 = \"[[ k[1], k[7]], \" + \\\n", "formula_2 = \"[[ k[1], k[7]], \" + \\\n",
" \"[ -k[7]], \" + \\\n", " \"[ -k[7]], \" + \\\n",
" \"[ k[6], k[7]], \" + \\\n", " \"[ k[6], k[7]], \" + \\\n",
" \"[ -k[5], -k[7]]]\"\n", " \"[ -k[5], -k[7]]]\""
"\n", ]
"\n", },
"\n", {
"\n", "cell_type": "code",
"cable_template_1 = cs.CableTemplate(knot_formula=formula_1)\n", "execution_count": null,
"cable_template_2 = cs.CableTemplate(knot_formula=formula_2)\n", "metadata": {},
"cable_template = cable_template_1 + cable_template_2\n", "outputs": [],
"\n", "source": [
"cable_template.fill_q_vector()\n", "# cable_template_1 = cs.CableTemplate(knot_formula=formula_1)\n",
"# cable_template_2 = cs.CableTemplate(knot_formula=formula_2)\n",
"# cable_template = cable_template_1 + cable_template_2"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# cable_template.knot_formula"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# cable_template.fill_q_vector()\n",
"# print(cable_template.q_vector)\n", "# print(cable_template.q_vector)\n",
"# print(cable_template.knot_formula)\n", "# print(cable_template.knot_formula)"
"\n", ]
"slice_canidate = cable_template.cable\n", },
"print(slice_canidate.knot_description)\n", {
"sf = slice_canidate(4,4,4,4,0,0,0,0)\n", "cell_type": "code",
"sf = slice_canidate(4,1,1,4,0,0,0,0)\n", "execution_count": null,
"slice_canidate.q_order" "metadata": {},
"outputs": [],
"source": [
"# cable_template.fill_q_vector()\n",
"# print(cable_template.q_vector)\n",
"# print(cable_template.knot_formula)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# slice_canidate = cable_template.cable\n",
"# print(slice_canidate.knot_description)\n",
"# sf = slice_canidate(4,4,4,4,0,0,0,0)\n",
"# sf = slice_canidate(4,1,1,4,0,0,0,0)\n",
"# slice_canidate.q_order"
] ]
}, },
{ {
@ -399,7 +466,7 @@
}, },
"outputs": [], "outputs": [],
"source": [ "source": [
"slice_canidate.is_function_big_for_all_metabolizers(invariant=cs.SIGMA)" "# slice_canidate.is_function_big_for_all_metabolizers(invariant=cs.SIGMA)"
] ]
}, },
{ {
@ -410,7 +477,7 @@
}, },
"outputs": [], "outputs": [],
"source": [ "source": [
"slice_canidate.is_function_big_for_all_metabolizers(invariant=cs.SIGNATURE)" "# slice_canidate.is_function_big_for_all_metabolizers(invariant=cs.SIGNATURE)"
] ]
}, },
{ {
@ -419,10 +486,10 @@
"metadata": {}, "metadata": {},
"outputs": [], "outputs": [],
"source": [ "source": [
"sigma = slice_canidate.get_sigma_as_function_of_theta()\n", "# sigma = slice_canidate.get_sigma_as_function_of_theta()\n",
"sigma((0, 6, 6, 0, 0,0,0,0))\n", "# sigma((0, 6, 6, 0, 0,0,0,0))\n",
"# 13450/83\n", "# # 13450/83\n",
"sigma((9, 0, 0, 9, 0,0,0,0))" "# sigma((9, 0, 0, 9, 0,0,0,0))"
] ]
}, },
{ {
@ -431,8 +498,8 @@
"metadata": {}, "metadata": {},
"outputs": [], "outputs": [],
"source": [ "source": [
"_, _, sf = slice_canidate((1, 1, 0, 0, 0,0,0,0))\n", "# _, _, sf = slice_canidate((1, 1, 0, 0, 0,0,0,0))\n",
"sf" "# sf"
] ]
}, },
{ {
@ -441,7 +508,7 @@
"metadata": {}, "metadata": {},
"outputs": [], "outputs": [],
"source": [ "source": [
"sg.SignaturePloter.plot(sf)" "# sg.SignaturePloter.plot(sf)"
] ]
}, },
{ {
@ -453,7 +520,7 @@
"outputs": [], "outputs": [],
"source": [ "source": [
"\n", "\n",
"slice_canidate.plot_sum_for_theta_vector([0r,4r,0r,4r,0r,0r,0r,0r], save_to_dir=True)" "# slice_canidate.plot_sum_for_theta_vector([0r,4r,0r,4r,0r,0r,0r,0r], save_to_dir=True)"
] ]
}, },
{ {
@ -462,7 +529,7 @@
"metadata": {}, "metadata": {},
"outputs": [], "outputs": [],
"source": [ "source": [
"sf.plot()\n" "# sf.plot()\n"
] ]
}, },
{ {
@ -470,7 +537,9 @@
"execution_count": null, "execution_count": null,
"metadata": {}, "metadata": {},
"outputs": [], "outputs": [],
"source": [] "source": [
"# help(cs.CableTemplate.get_q_vector)"
]
}, },
{ {
"cell_type": "code", "cell_type": "code",