Skip to content

Latest commit

 

History

History
41 lines (33 loc) · 3.1 KB

todo.md

File metadata and controls

41 lines (33 loc) · 3.1 KB
  1. brute force characterize all distinct sets of chord-lengths capable of covering a modulo

Oh my goard! Just realized with mixed chord-length cycles, the chord lengths no longer need to be coprime!

Shit! It's totally recursive:

  1. I've been using the symmetric generator for the number of mixed length steps to count
  2. So, for example, suppose I'm avoiding mixed lengths in red.
  3. Then, I want a red-steps linear combination of those mixed lengths.
  4. And then, I have been looking for a blue-length product of that red-avoided blue-chord./
  5. But, its actually a blue-length linear combination of those those red-avoided chords with other blue chords
  6. In other words, I find a new red-avoided blue chord length, but then return to the same simple multiplication in avoiding blue.
  7. ... when instead, I should be considering mixed combinations in blue (including the new blue-chord) too on top of red.
  8. I think I though I was handling this with multiplication, because there's a symmetry when I switch red and blue
  9. ... but that symmetry of multiplication does not cover the twice over linear combinations.

... but, actually I am, because in the code, I multiply red and blue to the number of steps and then apply that to linear combinations. My concern above only holds if I were getting the linear combinations for red and then simply multiplying by blue, but with red*blue, I capture all possible linear combinations, not just the repeated sequence of red chords making up the same repeated blue chord.

  1. do I represent as inverses or large residues or both?

  2. is there anywhere I can't "subtract" (even in undirected graphs)?

  3. it should be ok to negate my mixed lengths step product (red*blue) at least for undirected graphs

  4. of course it would be the absolute value for the number of steps

  5. so I could use this to find the smaller number of steps to consider (fewer input possibilities)

  6. but I also need to eplicitly allow negated input residues chord lengths (for undirected graphs) or I won't get any "twists"!

  7. but is it be ok to reduce my mixed lengths step product (red*blue) with the modulo? that would speed things up!

  8. yes! simple argument:

  9. suppose I need 3 and 5 mod 11 to get me a chord of 2 (with some input predetermined residues)

  10. then, if I can make a valid cycle with 4 steps of those residues, then I can easily construct one in 15 steps by adding a lap

  11. notice non-trivial brs only seem to occur on symmetric cases, maybe that has something to do with directed input residues

  12. do I need one-sided residues (only matching min or max chord) help to build up to a two-sided (like with a linear combination or something)?

  13. consider autogenerating plus/minus residues for standardization or even more completeness (i.e. consider +/- on residue side instead of chord side)

  14. handle that residues sometimes end on a redundant 1

  15. write csv efficiently in chunks

  16. read and initialize with csv (rather than creating starting point arguments)

  17. consider speeding up implicit modpows in scan function

  18. don't recompute residues for pairs of factors that make the same generator

  19. handle inverses already computed