Ok lets go deeper into the mini-notation!

Here's a video. I experimented with fitting more things in a 'lesson', making a longer video accordingly.. But I think I was flagging by the end! I put a clarification or two in the subtitles. I also experimented with visualisation, which turned out more helpful at some points than others.. As ever, feedback is warmly invited!

- 0:12 - recap of the first part * 1:20 - intro
- 1:45 - 'speeding up' steps/subsequence with '*'
- 4:35 - repeating steps/subsequences with '!'
- 5:46 - 'slowing down' steps with '/'
- 11:08 - polyphony (and polyrhythm) with "[ , ]"
- 13:42 - polymeter with "{ , }" (compared with polyrhythm with "[ , ]")
- 16:28 - rhythmic 'feet' with "."
- 19:26 - one step per cycle with angle brackets

Here's a worksheet for hands-on exploration. Be sure to edit things to test your assumptions and try to get round what's going on - and please do ask questions if anything is unclear. I've put a few tasks at the end.. Following forum discussion we're also putting together more creative tasks.

```
-- SPEEDING UP, REPEATING, AND SLOWING DOWN
-- SPEEDING UP A STEP WITH "*"
-- https://www.youtube.com/watch?v=h_f11uago28&t=105s
-- Make a step go 'faster', so it repeats itself within its step:
d1 $ sound "hi lo*3"
-- It works with subsequences too
d1 $ sound "hi [hi lo]*2"
-- And 'n' patterns
d1 $ n "[0 ~ 0] 2 [0 9]*2 2" # sound "cpu"
-- Let's try speeding up a pattern by one-and-a-half:
d1 $ sound "bd [sd hc]*1.5"
-- It has two steps, so if you speed it up by 1.5, you get three steps.
-- The first time around you get "bd [sd hc sd]", the second time "bd [hc sd hc]"
-- SLOWING DOWN A STEP WITH "/"
-- https://www.youtube.com/watch?v=h_f11uago28&t=346s
-- Make 'lo' sound only every other cycle:
d1 $ sound "hi lo/2"
-- Make 'lo' sound only every third cycle:
d1 $ sound "hi lo/3"
-- Slow down a subsequence, so only one step sounds per cycle:
d1 $ sound "clap [numbers:0 numbers:1 numbers:2]/3"
-- Take two steps from a six step sequence each cycle, by slowing it by 3:
d1 $ n "0 0 0 [0 1 3 4 5 6]/3" # sound "cpu2"
-- Make things strange by slowing down with funky ratios!
d1 $ n "0 0 0 [0 1 3 4 5 6]/2.5" # sound "cpu2"
-- REPEATING A STEP WITH "!"
-- https://www.youtube.com/watch?v=h_f11uago28&t=275s
-- If you want to repeat steps on the same metrical level, then you can use ! ..
-- So this:
d1 $ sound "hi lo!3"
-- Is the same as this:
d1 $ sound "hi lo lo lo"
-- You can also use an ! on its own for a single repeat. So this:
d1 $ sound "hi lo !"
-- Is the same as this:
d1 $ sound "hi lo lo"
-- You can repeat subsequences too, so these are the same:
d1 $ sound "bd bd [hi lo] !"
d1 $ sound "bd bd [hi lo] [hi lo]"
-- POLYPHONY WITH ","
-- https://www.youtube.com/watch?v=h_f11uago28&t=668s
-- With ',' you can have more than one subsequence happening at the same time.
-- Where you have the possibility of more than one note happening at once,
-- that's called musical "polyphony"
-- This is like where you have multiple channels d1 and d2 active at the same time:
d1 $ sound "bd sd"
d2 $ sound "rs rs rs"
-- .. but with ","" you can put them both in the same pattern. This sounds
-- the same as the two above patterns playing at once:
d1 $ sound "[bd sd, rs rs rs]"
-- The subsequences line up to fill the same cycle.
-- So "[a b, c d e]" lines up like this:
-- |a--b--|
-- |c-d-e-|
-- There's an 'alphabet' sample set in the default samples that can help with
-- this!
d1 $ n "[0 1, 2 3 4]" # sound "alphabet"
-- There's another way of getting subsequences to align, using { } instead of [ ]:
d1 $ n "{0 1, 2 3 4}" # sound "alphabet"
-- Video explanation: https://www.youtube.com/watch?v=h_f11uago28&t=822s
-- The first three cycles of this looks like this:
-- |ababab|
-- |cdecde|
-- What's happening? Well Tidal aligns the first subsequence, "0 1", to fit
-- the cycle, as before. But then it fits the others to it *stepwise*. So
-- now the steps align, but the cycles don't! In the space of three
-- cycles, there are three repetitions of "a b" and two repetitions of "c d e"
-- The [ ] notation creates what is called a musical 'polyrhythm' - multiple
-- rhythms happening within the same timeframe, e.g.:
d1 $ n "[0 5 2 ~, 0 3 4*2 0 3]" # sound "cpu2"
-- The { } notation creates a 'polymetre' - where metres of different durations
-- phase in and out of each other, e.g.:
d1 $ n "{0 5 2 ~, 0 3 4*2 0 3}" # sound "cpu2"
-- I (Alex) get mixed up between polyrhythm and polymetre all the time, and
-- tend to just call them both polyrhythm for simplicity..
-- 'Traditional' music software with linear 'piano roll' style notation systems
-- can really struggle with polyrhythm/metre, but it's really easy with Tidal
-- and a *lot* of fun to explore.
-- RHYTHMIC FEET WITH "."
-- https://www.youtube.com/watch?v=h_f11uago28&t=988s
-- You can 'mark out' regular rhythmic 'feet' with "."
-- So this:
d1 $ sound "bd sd . mt ht lt . arpy arpy:4 . snare clap:4 bd"
-- Is another way of saying exactly this:
d1 $ sound "[bd sd] [mt ht lt] [arpy arpy:4] [snare clap:4 bd]"
-- So the "." breaks up a sequence into parts of equal duration
-- To break down a step _within_ the "." notation, you can still
-- use [], etc:
d1 $ sound "bd sd . mt [ht mt] lt . arpy [arpy:4 arpy:5] . snare clap:4 bd"
-- That's the same as:
d1 $ sound "[bd sd] [mt [ht mt] lt] [arpy [arpy:4 arpy:5]] [snare clap:4 bd]"
-- ONE STEP PER CYCLE WITH "<>"
-- https://www.youtube.com/watch?v=h_f11uago28&t=1166s
-- Often it's nice to pick one step from a subsequence every cycle.
-- One way is this:
d1 $ sound "hi [arpy arpy:1 arpy:2 arpy:3]/4"
-- You can do the same thing with < > - it picks one step per cycle, without
-- you having to worry about how many steps there are inside:
d1 $ sound "hi <arpy arpy:1 arpy:2 arpy:3>"
-- REVISION TASKS
-- Copy each of the following patterns in turn, and edit them so that they
-- are shorter, using the "<>", "!", "[]" and/or "." introduced above.
d1 $ sound "kick snare snare"
d1 $ sound "kick [snare snare]"
d1 $ sound "kick snare kick snare kick snare"
d1 $ n "0 [1 2 3]/3" # sound "cpu2"
d1 $ n "[0 0 2] [4 5 6 7] [4 1] [0 3 0 3]" # sound "cpu2"
d1 $ sound "kick snare kick snare kick snare clap"
d1 $ sound "[kick snare kick snare kick snare] clap"
d1 $ sound "bd sd sd sd bd [sd sd sd]"
-- Trying to make code as short as possible is called "golfing" for some reason.
-- It can be useful as a form of practice, but sometimes longer code
-- is actually much easier to understand and edit!
```

**Next lesson:**