Max Kaye's Site

I started doing outdoor bouldering about a week ago (we've been in lockdown for the last ~2 months). I found an unclimbed wall that's close enough to home (for current exercise-distance restrictions) and have been working on that recently. I've posted some videos of this to my max's bouldering playlist on YT. I've also documented the wall on theCrag: https://www.thecrag.com/climbing/australia/new-south-wales-and-act/sydney-metropolitan/area/5156697663

Before lockdown I was 4-5 weeks in to my 'send all the purples' goal at my gym (purples are bouldering routes of a particular grade) -- my gym resets a few sections of wall every week and has a 6 week cycle.

This is a repost of a post I made to reddit on June 13th 2017. I found it again recently and wanted to document it here.

The Problem (what's the optimal encoding?)

You have a known list of n candidates on a ballot. In the act of voting, the voter must number each candidate from 1 to n, using each number once. The voter is thus describing a transformation on the list of candidates into a particular permutation. What is the minimum number of bits needed to exactly describe any order, and the method?

My naive approach is to count (from the left) the number of 'jumps' each candidate must take to arrive in their ranked position skipping any previously ranked candidates.

So if we had 3 candidates: cs = ['c1', 'c2', 'c3'] and a list of ranks rs = [2, 3, 1] we'd do this (where zip(cs, rs) matches candidates to ranks):

• First, c1 should be in the 2nd position, which is 1 move from the far left open spot. Since c1 could move 2 positions though we need to use 2 bits. Record 01
• Second, 'c2' needs to be in 3rd position, which is also 1 move from the far left open spot (since we skip over the filled position from step 1). Because 'c2' could only move a maximum of 1 jump, we only need 1 bit: record 1.
• Third, 'c3' trivially fits into the last space, so we need 0 bits.

Our final result is 011.

To decode the permutation, take N bits in the sequence ceil(log(2, n)), ceil(log(2, n-1)), ceil(log(2, n-2)), ..., ceil(log(2, 2)), which is [2, 1, 0] in our case. Use those bits (in this case ['01', '1']) to move each candidate into open spots.

By numerical analysis this method very closely fits O(n Log n) space complexity. (total_bits = 0.89 * n * log(2, n) seems to describe the pattern very closely).

The exact number of bits used will be t = Sigma(i=2, n)( ceil(log(2, i)) ).

It occurs to me that simply listing the positions is O(n log n) too, but the exact number of bits required is t = ceil(log(2, n))*n which is more than my method.

Reddit user tilrman pointed out:

With n candidates, there are P(n) = n! permutations. Each voter selects one of these permutations, so a vote can be represented by an integer [0, n!-1].

2 more comments follow in that branch before I posted my soln

My Solution

clarification: in "base factorial" I'm using base in the same way as base 10 (our number system) or base 2 (binary numbers).

Basic idea is to use factoradics - sort of like base factorial where the k^th integer is in [0, k] and to convert back to base 10 you'd multiply it by k!. e.g.: 3210 is 0*1! + 1*2! + 2*3! + 3*4!. Also 4321 + 1 = 10000 which is 1*5! = 120 in base 10.

These numbers uniquely enumerate permutations for a list of n unique elements and allow one to 'read' the permutation from the number. e.g. [a, b, c, d, e] in permutation 2310 leads to [d, c, a, e, b]. Put a in 2+1th free slot, put b in 3+1th free spot, put c in 1+1th free slot, put d in 0+1th free slot, put e in the last spot.

This means we can map all integers in [0, n!-1] to a unique permutation (via modulo-ing and subtracting successive factorials), and back again quickly and efficiently (though arbitrarily sized integers (e.g. in python or haskell) make this much easier than small integers - 150! is like 110 bytes long as a raw integer)

Finally a sanity check: for a list of k elements we have a maximum count of (k-1) (k-2) ... (k-k+1) where each bracketed expression is a digit. If we add 1 we end up with 1 followed by k zeros, which corresponds to k!, and so our maximum integer is 1 less at k!-1 which is what we expect :)

I like a lot of Louis Rossmann's videos and his thoughts.

This topic is for discussing and collecting good ones. Here's two; one recent, one old

• (2021-09) Rossmann vid on covid+society; seems good - perspective on being a business owner, masks, lockdowns, etc.
• (2013-07) The $30,000 pocket dial - a story from Rossmann's early days

I think freedom and universality must have some deep connection.

If you have the freedom to do something, that means -- wrt that context -- you can do whatever you like. You're unconstrained; that aspect cannot (or at least should not) be a bottleneck.

That gives you some unboundedness wrt method, or content, or whatever the freedom relates to. Freedom of speech removes a bound on speech. Freedom of thought removes a bound on thought.

Freedom enables universality; and without certain freedoms, you cannot have certain universalities.

I thought that freedom and thinking were like orthogonal; both necessary for philosophy and good life, but neither sufficient. Now I suspect there's more there than I realized.

Climbing gyms (and everything else) have just reopened (for the vaccinated) in Sydney, following a ~3.5 month lockdown. Now that climbing is frequent and regular again, I've been reconsidering climbing goals.

Before lockdown, my goal was to send every new grade 3¹ (out of 6) problem, every week, for 6 weeks (I'd done 5 weeks when lockdown started). 6 weeks is a full rotation, so achieving this means that I would have consistently been able to project any purple in 2-3 sessions. The purpose of this goal was to emphasise consistency over results (better to do be capable of any grade 3 problem than some grade 3 and some grade 4).

The current goal I've settled on is to send every grade 3 climb (in the gym) in a week -- there's about 24 or so (give or take depending on what gets set). I sent 10 this morning (over about 2hrs). I don't think I'd have been able to do that if I hadn't done some outdoor climbing during lockdown, tho. So far, so good. I have been going through them methodically, with a few exceptions (picking ones I thought I could do towards the end of the session, for example). So far no grade 3 has been particularly challenging, though crowd-beta has helped a bit. Major bottleneck atm (session-to-session) is probably endurance -- going to monitor that and take corrective action if it doesn't improve this week.

Video: https://youtu.be/Vr6X2Z6Ag2w

Source code: https://github.com/XertroV/43-attempts/

The method is documented in the repo readme.

make sure to chmod +x it and should just work (provided you have curl and extended grep support)

#!/usr/bin/env bash

FILENAME="$1"
GIPHY_CODE_OR_URL="$2"

if [ -z "$FILENAME" ] || [ -z "$2" ]; then
  echo "usage: $0 GIF_NAME GIPHY_URL_OR_CODE"
  exit 1
fi

CODE_FROM_URL=$(echo "$GIPHY_CODE_OR_URL" | egrep -o 'media\/([A-Za-z0-9]{12,})\/giphy' | cut -d '/' -f 2)

if [ -z "$CODE_FROM_URL" ]; then
  CODE_FROM_URL=$(echo "$GIPHY_CODE_OR_URL" | egrep -o '[A-Za-z0-9]{12,}')
fi

echo "saving to: $FILENAME.mp4"
echo "dling gif from: $GIPHY_CODE_OR_URL"
echo "giphy code: $CODE_FROM_URL"

curl "https://media.giphy.com/media/$CODE_FROM_URL/giphy.mp4" --output "$FILENAME.mp4"

xdg-open "$FILENAME.mp4" || true

e.g., governor

• relevant to learning
• redlining in a controlled env can be useful for like measuring progress or something, but that shouldn't be the norm
• by maintaining excap one can ensure there's room to move -- buffer. that's important while learning b/c you're focusing on creating new organization of knowledge and reorganizing existing knowledge. trying to learn without excap is like trying to do tetris with no v-space. with lots of v-space tetris is manageable, but it gets hyperbolically harder as you approach the top.

re long-running learning conflict: the more exploratory side means exhausting excap quickly (manageable when surveying, but not when trying to complete a project).

this script will speed up (or slow down) video and audio via ffmpeg.

put the following in e.g., ~/.local/bin/mod-video-speed and chmod +x it.

#!/usr/bin/env python3

import subprocess
import sys, re

this_file = sys.argv[0]
filename = this_file.split('/')[-1]
args = sys.argv[1:]

if len(args) != 3:
  print(f'Error: need 3 args but you provided {len(args)}. {args}')
  print(f'\n\tUSAGE: {filename} INFILE OUTFILE SPEED')
  print(f'\n\tINFILE: input file (source)\n\tOUTFILE: output file (destination)')
  print(f'\tSPEED: the speed of the output video in the format `2x` or `1.43x` -- must end with `x`')
  sys.exit(1)

in_file = sys.argv[1]
out_file = sys.argv[2]
speed_raw = sys.argv[3]
speed_pattern = r'([0-9]+\.?[0-9]*)x'
speed_re = re.match(speed_pattern, speed_raw)
if speed_re is None:
  print(f"Error: SPEED argument did not match `{speed_pattern}`\n\nExamples: `1x`, `0.5x`, `123.456x`, `99x`")
  sys.exit(2)
speed = float(speed_re[1])
pts_speed = 1./speed
print(f"Processing {in_file} and modifying video speed to {speed}, outputting to {out_file}.")

ffmpeg_cmd_list = ['ffmpeg', '-i', in_file, '-filter_complex',
                   f"[0:v]setpts={pts_speed}*PTS[v];[0:a]atempo={speed}[a]",
                   '-map', '[v]', '-map', '[a]', out_file]
print(f"Running ffmpeg cmd: {' '.join(ffmpeg_cmd_list)}")
subprocess.run(ffmpeg_cmd_list)

license: public domain

archiving for my own future purposes + i don't know if this is replicated anywhere else on the web.

• round 1: https://web.archive.org/web/20210512150518/https://syd.blochaus.com.au/wp-content/uploads/sites/4/2021/03/sbs2021results_round01.pdf
• round 2: https://web.archive.org/web/20211217124144/https://syd.blochaus.com.au/wp-content/uploads/sites/4/2021/04/BHAU-61424-Sydney-Boulder-Series-Round-2-Results_DC03.pdf
• round 3: https://web.archive.org/web/20211217124126/https://syd.blochaus.com.au/wp-content/uploads/sites/4/2021/04/BHAU-61424-Sydney-Boulder-Series-Round-3-Results_DC02-3.pdf
• round 4: https://web.archive.org/web/20211217124114/https://syd.blochaus.com.au/wp-content/uploads/sites/4/2021/05/BHAU-61492-Sydney-Boulder-Series-Round-4-Results_DC02.pdf
• combined 1,2,3,4: https://web.archive.org/web/20211217124059/https://syd.blochaus.com.au/wp-content/uploads/sites/4/2021/05/BHAU-61424-SBS-Combined-Round-1_2_3_4-Results_DC02.pdf
• combined 1,2,3: https://web.archive.org/web/20211217124859/https://syd.blochaus.com.au/wp-content/uploads/sites/4/2021/04/BHAU-61424-SBS-Combined-Round-1_2_3-Results_DC02-2.pdf
• participant info pack: https://web.archive.org/web/20210512144534/https://syd.blochaus.com.au/wp-content/uploads/sites/4/2021/03/sbs2021info-1.pdf