Published
Edited
Oct 25, 2021
Importers
next = (n) => (n % 2n == 0n ? n / 2n : 3n * n + 1n)
function sequence_down(n) {
const result = [];
let nn = next(n);
result.push(nn);
while (nn > n) {
nn = next(nn);
result.push(nn);
}
return result;
}
sequence_down(15n)
function count_down(n) {
let i = 1n,
c = next(n);
while (c > n) {
i++;
c = next(c);
}
return i;
}
count_down(7n)
counts = bigrange(1n, 2n ** magnitude, 2n).map(count_down)
arrange_by_mod = (base) =>
_(counts).chunk(Number(base)).unzip().map(_.uniq).value()
arrange_by_mod(32n)
symbolic = (array) => array.map((it) => (it.length == 1 ? it[0] : `[${it[0]}]`))
symbolic(arrange_by_mod(32n))
magnitude = 21n
function mod_counts(base) {
const arranged = arrange_by_mod(base);
const lengths = _.countBy(arranged, "length");
const repr = symbolic(arranged);
const stable = lengths[1];
return {
base,
stable,
unstable: base - BigInt(stable),
ratio: stable / Number(base),
ratio_u: (Number(base) - stable) / Number(base),
min_unstable_len: _(lengths).omit(1).keys().map(_.toNumber).min(),
max_unstable_len: _(lengths).keys().map(_.toNumber).max(),
lengths,
repr: _.join(repr, " "),
repr_count: _.countBy(repr),
highest_in_stable: _.max(repr),
lowest_in_unstable: _(arranged)
.filter((it) => it.length > 1)
.map(_.min)
.min(),
raw: arranged
};
}
pattern = bigrange(2n, magnitude - 2n)
.map((x) => 2n ** x)
.map(mod_counts)
aq.from(pattern).view()
pattern.map((it) => it.repr)
bigrange(pattern.length - 1).map((i) => {
const a = pattern[i],
b = pattern[i + 1];
return `${a.base} to ${b.base}: ${b.ratio_u / a.ratio_u}`;
})
slice = {
const result = [];
const LIMIT = 200;
const ITERATIONS = 200n;
let exp = 1n;
const width = 2n ** exp;
let base = width;
let starters = bigrange(1n, width + 1n);
for (let i = 0; i < ITERATIONS; i++) {
const lengths = starters.map((parity) =>
bigrange(6n)
.map((x) => x * base + parity)
.map(count_down)
);
const reduced = lengths.map(_.uniq);
const stabilized_count = _(reduced)
.filter((it) => it.length == 1)
.size();
result.push({
base: `2^${exp}`,
exp,
starters,
//lengths,
stabilized_starters: _(reduced)
.map((it, id) => (it.length != 1 ? false : starters[id]))
.filter()
.value(),
stabilized_count,
stabilized_value:
stabilized_count == 0
? null
: Number(_.find(reduced, (it) => it.length == 1)[0])
//repr: symbolic(reduced).join(" ")
});
starters = _(reduced)
.map((it, id) => (it.length == 1 ? false : starters[id]))
.filter()
.value();
starters = [...starters, ...starters.map((it) => it + base)];
starters = _.take(starters, LIMIT);
exp++;
base *= 2n;
}
return result;
}
slice_table = aq.from(slice)
slice_table.view()
slice_table
.derive({
stabilized_value: (d) => op.fill_down(d.stabilized_value)
})
.derive({ x: (d) => op.lead(d.stabilized_value) - d.stabilized_value })
.array("x")
.slice(0, -1)
.join("")
.replace(/203/g, ".") // 3 rows
.replace(/\.\.03/g, ":") // 8 rows
.replace(/\.::/g, "!") // 19 rows
.replace(/!!!!:/g, "#") // 84 rows
function route(start) {
let n = start;
let res = "";
do {
if (n % 2n == 0n) {
n /= 2n;
res += "-";
} else {
n = n * 3n + 1n;
res += "+";
}
} while (n > start);
return res;
}
route(7n)
stable_patterns = slice.map((s) =>
s.stabilized_starters
.map((it) =>
bigrange(30n)
.map((i) => it + 2n ** s.exp * i)
.map(route)
)
)
_.every(stable_patterns, (base) =>
_.every(base, (starter) => _.uniq(starter).length == 1)
)
function bigrange(start, end, step) {
if (end !== 0 && end !== 0n && !end) {
end = start;
start = end - end;
}
if (!step) step = end / end; // TODO division by 0
const result = [];
while (start < end) {
result.push(start);
start += step;
}
return result;
}
Support BigInt serialization for Arquero tables
(BigInt.prototype.toJSON = function () {
return this.toString();
})
Purpose-built for displays of data
Observable is your go-to platform for exploring data and creating expressive data visualizations. Use reactive JavaScript notebooks for prototyping and a collaborative canvas for visual data exploration and dashboard creation.
