diff --git a/packages/core/fraction.mjs b/packages/core/fraction.mjs
index 3b1665b7a..0fc9bf9db 100644
--- a/packages/core/fraction.mjs
+++ b/packages/core/fraction.mjs
@@ -25,14 +25,14 @@ setInterval(() => {
 // this is a "mock" for fraction.js, using just floats without any rational arithmetic
 // to test if the performance gets better without fraction.js
 // result: it seems to get better but not by much
-// the main jankyness remains for some cpmplicated patterns
-// i tried counting the calls to Fraction and noticed there can be ~400k calls per second for not so complicated patterns
+// the main jankyness remains for some complicated patterns
 
 class Fraction {
   value; // number
   constructor(value) {
     instances++;
     if (value instanceof Fraction) {
+      // TODO: return this?
       this.value = value.value;
       fractions++;
     } else if (typeof value === 'string') {
@@ -82,6 +82,7 @@ class Fraction {
   equals(other) {
     return this.value.valueOf() === other.valueOf();
   }
+  // TODO: toFraction
 }
 
 // Returns the start of the cycle.
@@ -91,12 +92,16 @@ Fraction.prototype.sam = function () {
 
 // Returns the start of the next cycle.
 Fraction.prototype.nextSam = function () {
+  // return new Fraction(Math.floor(this.value) + 1);
   return this.sam().add(1);
 };
 
 // Returns a TimeSpan representing the begin and end of the Time value's cycle
 Fraction.prototype.wholeCycle = function () {
   return new TimeSpan(this.sam(), this.nextSam());
+  /*   const begin = Math.floor(this.value);
+  const end = begin + 1;
+  return new TimeSpan(begin, end); */
 };
 
 // The position of a time value relative to the start of its cycle.
diff --git a/study.md b/study.md
new file mode 100644
index 000000000..b0a554b74
--- /dev/null
+++ b/study.md
@@ -0,0 +1,61 @@
+# study: why are there so many calls?
+
+- `pure('c3')` => 746 calls per second...
+- shapeshifted: `(async()=>{return reify("c3").withLocation([1,5,20],[1,9,24])})()`Ï => same # of calls with or without shapeshifting
+- without highlighting (// strudel disable-highlighting), there are only 15 calls
+
+## call stack
+
+this is how the ~15 calls are made for the first query:
+
+- keypress -> activateCode -> evaluate -> safeEval -> pure -> new Pattern (pretty simple)
+- query 0
+  - const timespan = new TimeSpan(0,1)
+    - Fraction(0), Fraction(1)
+  - onQuery(new State(timespan))
+    - pattern.query(state)
+      - pure.query(state)
+        - state.span.spanCycles
+          - end.sam() -> this.floor -> new Fraction
+          - begin.sam -> this.floor -> new Fraction
+          - begin.nextSam
+            - begin.sam -> this.floor -> new Fraction
+            - .add(1) -> new Fraction
+        - Fraction(0).wholeCycle -> new TimeSpan(0, 1)
+          - this.sam -> new Fraction(0)
+          - this.nextSam -> new Fraction(1)
+        - new Hap(TimeSpan(0,1), TimeSpan(0,1), 'c3')
+  - Tone.getTransport().cancel(0);
+  - queryNextTime = 0.5
+  - t = 0.6
+
+## from simple to complicated
+
+(all without highlighting)
+
+- `pure('c3')`: 15 calls
+- `pure('c3').fast(1)`: 74 calls
+- `pure('c3').fast(1).fast(1)`: 133 calls
+- `pure('c3').fast(1).fast(1).fast(1)`: 192 calls
+- `pure('c3').fast(1).fast(1).fast(1).fast(1)`: 251 calls
+- `pure('c3').fast(1).fast(1).fast(1).fast(1).fast(1)`: 310 calls
+- `pure('c3').fast(2)`: 94 calls
+- `pure('c3').fast(2).fast(2)`: 264 calls
+- `pure('c3').fast(2).fast(2).fast(2)`: 636 calls
+- `pure('c3').fast(4)`: 134 calls
+
+## WIL
+
+- Fraction.wholeCycle: returns a timespan for the whole cycle the given fraction is in. Fraction(n).wholeCycle -> TimeSpan(n.floor, n.floor+1)
+  - e.g. `Fraction(0.5).wholeCycle` -> `TimeSpan(0, 1)`
+- TimeSpan.spanCycles: returns an array of whole cycle timespans that intersect with the given timespan
+  - e.g. `TimeSpan(0.5, 1.5)` -> `[TimeSpan(0, 1), TimeSpan(1, 2)]`
+- pure: returns one Hap for spanCycles of query span. Hap will get wholeCycle as whole and query span as part
+- reify: turns non patterns into patterns using pure. makes sure you get a pattern
+
+## notes
+
+- slowcat -> sequence -> fastcat -> slowcat is a somewhat hidden recursion
+- slowcat -> pat_n can be negative and will then return an empty array. is that good? shouldn't pat_n be always a positive index?
+- slowcat offset: how to think about this?
+- slowcat: why add offset and sub it from the query span?