#!/usr/bin/env sage -python # TBD # print scheme and knot nicely # read about Factory Method, variable in docstring, sage documentation, # print calc. to output file # decide about printing option # make __main__? import os import sys import itertools as it import re import numpy as np import importlib # constants - which invariants should be calculate SIGMA = 0 SIGNATURE = 1 if __name__ == '__main__': from utility import import_sage package = None path = '' else: from .utility import import_sage package = os.path.join( __name__.split('.')[0]) path = '../' sg = import_sage('signature', package=package, path=path) cs = import_sage('cable_signature', package=package, path=path) # class Config: # def __init__(self): # self.f_results = os.path.join(os.getcwd(), "results.out") class Schema: r"""This class stores interesting 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. Remark 1 In the paper, we used p_i and q_i to describe torus knots and cables. It was convenient for writing, but in all the code and documentation only 'q' letter is used to encode torus knots or cables. Remark 2 There are two ways to set k[i] values for a scheme: via q_vector or 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 should use a list of length 8, and k[0] will be omitted as it is not used in the scheme. Remark 3 Except for development purposes, q_vector was computed with a method CableTemplate.get_q_vector and flag slice=True. 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. """ # scheme that is used in the paper lemma_scheme_a = "[ [k[5], k[3]], " + \ "[ -k[1], -k[3]], " + \ "[ k[3]], " + \ "[ -k[6], -k[3]]]" lemma_scheme_b = "[[ k[1], k[7]], " + \ "[ -k[7]], " + \ "[ k[6], k[7]], " + \ "[ -k[5], -k[7]]]" 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]]]" # # 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_a = "[[k[0], k[5], k[3]], " + \ # "[ -k[1], -k[3]], " + \ # "[ k[3]], " + \ # "[-k[4], -k[6], -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[2], k[3]], " + \ # "[ -k[0], -k[2], -k[3]]]" # # formula_b = "[[ k[4], k[1], k[7]], " + \ # "[ -k[5], -k[7]], " + \ # "[ k[6], k[7]], " + \ # "[ -k[4], -k[6], -k[7]]]" # # formula_a = "[[ k[0], k[5], k[3]], " + \ # "[ -k[5], -k[3]], " + \ # "[ k[2], k[3]], " + \ # "[-k[4], -k[2], -k[3]]]" # # formula_b = "[[ k[4], k[1], k[7]], " + \ # "[ -k[1], -k[7]], " + \ # "[ 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): try: limit = int(arg[1]) except (IndexError, TypeError): limit = None conf = Config() cable_loop_with_details(conf) def prove_lemma(verbose=True, details=False): 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) lemma_scheme = Schema.lemma_scheme 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() q_v = cable_template.q_vector print(q_v) print(cable_template.cable.knot_description) cable_a = cs.CableTemplate(knot_formula=lemma_scheme_a, verbose=verbose, q_vector=q_v ).cable cable_b = cs.CableTemplate(knot_formula=lemma_scheme_b, verbose=verbose, q_vector=q_v ).cable cable = cs.CableTemplate(knot_formula=lemma_scheme_a, verbose=verbose, q_vector=q_v ).cable cable.plot_sigma_for_summands() # cable_a.plot_sigma_for_summands() # cable_b.plot_sigma_for_summands() def cable_loop_with_details(verbose=True): # verbose = False lemma_scheme_a = Schema.lemma_scheme_a lemma_scheme_b = Schema.lemma_scheme_b lemma_scheme = Schema.lemma_scheme cable_template = cs.CableTemplate(knot_formula=lemma_scheme) list_of_q_vectors = [] # for el in [2, 3, 5, 7, 11, 13]: for el in [2]: cable_template.fill_q_vector(lowest_number=el) q_v = cable_template.q_vector print(q_v) print(cable_template.cable.knot_description) cable_a = cs.CableTemplate(knot_formula=lemma_scheme_a, verbose=verbose, q_vector=q_v ).cable cable_b = cs.CableTemplate(knot_formula=lemma_scheme_b, verbose=verbose, q_vector=q_v ).cable # print("\n") # print(cable_a.knot_description) is_a = cable_a.is_function_big_for_all_metabolizers(invariant=cs.SIGMA, verbose=True, 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") else: print("sigma is not big for all metabolizers") print("\n" * 3) def few_cable_without_calc(verbose=False): lemma_scheme_a = Schema.lemma_scheme_a lemma_scheme_b = Schema.lemma_scheme_b lemma_scheme = Schema.lemma_scheme cable_template = cs.CableTemplate(knot_formula=lemma_scheme) list_of_q_vectors = [] for el in [2, 3, 5, 7, 11, 13]: cable_template.fill_q_vector(lowest_number=el) q_v = cable_template.q_vector print(q_v) print(cable_template.cable.knot_description) cable_a = cs.CableTemplate(knot_formula=lemma_scheme_a, verbose=verbose, q_vector=q_v ).cable cable_b = cs.CableTemplate(knot_formula=lemma_scheme_b, verbose=verbose, q_vector=q_v ).cable is_a = cable_a.is_function_big_for_all_metabolizers(invariant=sigma) is_b = cable_b.is_function_big_for_all_metabolizers(invariant=sigma) if is_a and is_b: print("sigma is big for all metabolizers") else: print("sigma is not big for all metabolizers") print("\n" * 3) def plot_many_untwisted_signature_functions(range_tuple=(1, 10)): P = Primes() for i in range(*range_tuple): q = P.unrank(i) a = cs.CableSummand.get_untwisted_signature_function(q=q) a.plot() if __name__ == '__main__': if '__file__' in globals(): # skiped in interactive mode as __file__ is not defined main(sys.argv) else: pass # main()