text:
Generate unseen numbers
Let us say a substring is any continuous section of an original string.  For example cat is a substring of concatenate.  We will say that a proper substring is a substring that is not equal to the original string.  For example concatenate is a substring of concatenate but not a proper substring. (single character strings have no proper substrings)
We will now define a sequence using these terms.  The nth term in this sequence will be the smallest number such that there is a proper substring of its binary representation that is not a substring of any earlier term in the sequence.  The first term is 10.
As an exercise lets generate the first 5 terms.  I will work in binary to make things easier.
The first term is 10. Since 11, the next smallest number, has only one proper substring, 1 which is also a substring of 10, 11 is not in the sequence.  100 however does contain the proper substring 00 which is not a substring of 10 so 100 is our next term.  Next is 101 which contains the unique proper substring 01 adding it to the sequence, then 110 contains the proper substring 11 which is new adding it to the sequence.
Now we have
10, 100, 101, 110

111 is up next but it contains only the substrings 1 and 11 making it not a term.  1000 however contains 000 adding it to the sequence.
Here are the first couple terms in decimal
2, 4, 5, 6, 8, 9, 10, 11, 14, 16, 17, 18, 19, 20, 21, 22, 23, 24, 26, 30, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 50, 54, 56, 58

Task
Either

Take n as input and generate the nth term in this sequence (either 0 or 1 indexed)
Continuously output terms of the sequence

This is code-golf answers are scored in bytes with less bytes being better.

Is the output supposed to be in decimal or binary? Or either?

@AdmBorkBork I think it's supposed to be integers.

Could add the 100th term (or any  other large n) ?

@AdmBorkBork  You should output in any standard allowed format.

@Rod Is 36 large enough? a(36) is 47 (1 indexed).

@WheatWizard a(100) is 144 (0 indexed)

@Rod Looks like I have a bug.  I've deleted all entries afterwards until I can fix the bug.

is empty string a valid sub string of any string? Is empty string a valid proper sub string to any non-empty string?

@tsh Yes to both.  However it doesn't matter because it will never be unique.

Python 3, 88 80 78 75 bytes
-6 bytes thanks to Wheat Wizard
-2 bytes thanks to RootTwo
-3 bytes thanks to notjagan

s={0}
n=1
while 1:n+=1;b=f"{n:b}";p={b[1:],b[:-1]};s|=p-s and{b,print(n)}|p

Try it online!

Porting to python 3 saves 4 bytes if you want

Actually 7

@WheatWizard ninja'd

In Python 3.6, you can save 2 more by replacing bin(n)[2:] with f"{n:b}".

-3 bytes with some really weird changes.

Jelly, 22 bytes
BẆṖ
ṄÇ;ð⁹Çḟ¥?⁹⁸‘¤ß
2ç⁸

Try it online!

Mathematica, 116 110 bytes
x={};f=Subsequences[#~IntegerDigits~2]&;Do[MemberQ[Most@f@n,s_/;FreeQ[f/@x,s,2]]&&x~AppendTo~Echo@n,{n,2,∞}]

Infinitely outputs terms of the sequence.
Explanation
x={};

x is the list of terms of the sequence so far.
f=Subsequences[#~IntegerDigits~2]&

f is a Function which takes an integer and returns all Subsequences of its base 2 representation (including the empty list {} and the full list of IntegerDigits itself).
Do[...,{n,2,∞}]

Evaluate ... for value of n from 2 to ∞.
...&&x~AppendTo~Echo@n

If ... is False, then the second argument to And (&&) is never evaluated. If ... is True, then Echo@n prints and returns n, which we then AppendTo the list x.
MemberQ[Most@f@n,s_/;FreeQ[f/@x,s,2]]

We want to check that some proper substring of n is not a substring of any previous term in the sequence. Most@f@n is the list of proper substrings of n, we then check whether there are any substrings s_ which is a MemberQ of that list such that the list f/@x of lists of substrings of previous terms of the sequence is FreeQ of s at level 2.

Mathematica, 109 94 bytes
s={};Do[!SubsetQ[s,(t=Subsequences@IntegerDigits[i,2])[[2;;-2]]]&&(s=s~Join~t;Echo@i),{i,∞}]

Continuously output terms of the sequence
Special thanx to @ngenisis for -15 bytes

Mathematica, 123 bytes
(s=r={};For[i=2,i<2#,i++,If[!ContainsAll[s,(t=Subsequences@IntegerDigits[i,2])[[2;;-2]]],s=s~Join~t;r~AppendTo~i]];r[[#]])&

Take n as input and generate the nth term in this sequence (1 indexed)
input

[1000]

output

1342

Good idea to keep track of the substrings that have appeared so far! I spy at least15 bytes that can go: SubsetQ is shorter than and equivalent to ContainsAll, you can use And instead of If, the Union is unnecessary, and Do is almost always shorter than For: s={};Do[!SubsetQ[s,(t=Subsequences@IntegerDigits[i,2])[[2;;-2]]]&&(s=s~Join~t;Echo@i),{i,∞}]

3 more bytes by using Most: s={};Do[!SubsetQ[s,Most[t=Subsequences@IntegerDigits[i,2]]]&&(s=s~Join~t;Echo@i),{i,2,∞}]

Pyth, 20 bytes
u+G
fP-Fm.:.Bd)+TG1Y

This prints the sequence infinitely. It can only be used offline as a consequence.
Explanation (The space is a newline):
u+G fP-Fm.:.Bd)+TG1Y
u                  Y    Apply the following function to the previous output
                        until it stops changing (or forever, in this case),
                        starting with the empty list
    f             1     Find the first positive integer where
               +TG      The integer prepended to the current list
        m               Map to
           .Bd          Convert to binary
         .:   )         Form all subsequences
      -F                Fold the filter-out function over the list
                        This iteratively removes all subsequences already seen
                        from the candidate
     P                  Remove the last subsequence which is the whole number.
   (newline)            Print that first integer
 +G                     Prepend that first integer to the list

Pyth, 20 bytes
.V2I-=ZP.:jb2)Yb=+YZ

Try it online!

Haskell,  172 bytes
import Data.List
b 0=""
b n=b(n`div`2)++(show$n`mod`2)
s=nub.(tails=<<).inits
p x=s x\\[x]
n(_,l)x|(p.b)x\\l/=[]=(x,l++(s.b)x)|1<2=(0,l)
filter(>1)$fst<$>scanl n(1,[])[1..]

Try it online.
Explanation
The code generates the sequence continuously.

b returns the binary representation of an Int as a String
s returns all the substrings of a string
p returns all the proper substrings of a string
n is a function that is applied iteratively and returns a tuple containing:

the current element, if it is a member of the sequence, otherwise 0
a list of all substrings to check against for all following numbers

finally, scanl is used to call n over and over again and its output is filtered to only contain elements greater than 1

Here's a slightly more readable version, before golfing:
import Data.List

binary :: Int -> String
binary 0=""
binary n|(d,r)<-divMod n 2=binary d++["01"!!r]

substrings :: String -> [String]
substrings xs = nub$inits xs>>=tails

properSubstrings :: String -> [String]
properSubstrings xs = substrings xs\\[xs]

sb  = substrings.binary
psb = properSubstrings.binary

g = scanl step (1,[]) [1..]
  where step (_,l) x | psb x \\ l /= [] = (x,l++sb x)
                     | otherwise        = (0,l)

f=filter(>1)$fst<$>g

JavaScript, 57 bytes
for(x=1;;x++)/^10|10(00)*$/.test(x.toString(2))&&alert(x)

alert=x=>{if(x>100)throw 'Let we stop here.';document.write(x+'<br/>');};

for(x=1;;x++)/^10|10(00)*$/.test(x.toString(2))&&alert(x)

Let we write the given number n in binary form, then:

If the number is starts with 10, n must in the sequence:

remove the first 1 in it, the remaining binary string must not be seen, since n is the smallest number which may contain such string

If the number is starts with 11:

By removing the first 1 in it, the remaining binary string (let we donate it as 1x must be seen since:

number 1x is in the sequence, or
number 1x0 is in the sequence, since it contain unique sub string 1x

If it is odd (ends with 1), it must not in the sequence, since:

(n - 1) / 2 in the sequence, or
(n - 1) in the sequence, since it contain unique sub string (n - 1) / 2

If it is even (ends with 0), it is in the sequence iff n / 2 is not in the sequence

with the same idea, n / 2 is not in the sequence iff n / 2 is odd, or n / 4 is in the sequence

Conclusion:
the binary form of the number starts with 10 or ends with 1 followed by odd number of 0. Or describe in regex: x match /^10|10(00)*$/.


text:
Round Me, Help Me
Given an input n, your program or function must output the smallest positive integer k such that n rounded to the nearest multiple of k is greater than n.
Example.
Given an input 20, the output value should be 3:

The nearest multiple of 1 is 20, which is not greater than 20.
The nearest multiple of 2 is 20, which is not greater than 20.
The nearest multiple of 3 is 21, which is greater than 20, so it is output.

Test Cases
#Input  #Output
2       3
4       5
6       4
8       3
10      4
12      7
14      3
16      6
18      4
20      3
22      4
24      5
26      3
28      5
30      4
32      3
34      4
36      8
38      3
40      6
42      4
44      3
46      4
48      5
50      3
52      6
54      4
56      3
58      4
60      7
62      3
64      5
66      4
68      3
70      4
72      11
74      3
76      6
78      4
80      3
82      4
84      5
86      3
88      5
90      4
92      3
94      4
96      7
98      3
1000    6

The output given any odd input should be 2.
Rules

n is a positive integer less than 2^32
rounding is performed such that if two multiples of k are equally distant from n, the greater one is chosen ("round halves up"). In this way, every odd n yields an output of 2.
This is code-golf, so shortest code in each language wins.

I've edited the format of your test cases to make it easier to read, and more concise. Let me know if you have any problems with this, or if any of the new examples are off. :)

@Shaggy Done! I removed 500 odds and 450 evens from the list.

Is there an oeis link for this sequence?

@JamesK I did not find one when I searched earlier. Possibly someone with an OEIS account could make one?

Python 3, 48 38 bytes
Edit: -10 bytes by using recursion
l=lambda x,y=2:y*(x%y>=y/2)or l(x,y+1)

Try it online!

Japt, 6 bytes
@<rX}a

Try it online!
Explanation:
@    <r X}a
XYZ{U<UrX}a
X              // X = 0; Increments when the condition in between {...} fails
   {     }a    // Return the first integer X where:
    U          //   The input
     <U        //   is less than the input
       rX      //     rounded to the nearest multiple of X

r is a builtin? o_o

@EriktheOutgolfer: Japt also has built-ins for rounding up or down :)

I knew this feature would come in handy someday :D

@Shaggy that's nuts! o_o_o

@Oliver: This has me more convinced to get to grips with function methods, now - my own version of this was 7 bytes: o æ@<rX

MATL, 13 bytes
tQ:yy/Yo*<fX<

Try it online! Or verify all inputs from 1 to 1000.
Explanation
Consider input 6.
t      % Implicit input. Duplicate
       % STACK: 6, 6
Q:     % Add 1, range
       % STACK: 6, [1 2 3 4 5 6 7]
yy     % Duplicate top two elements
       % STACK: 6, [1 2 3 4 5 6 7], 6, [1 2 3 4 5 6 7]
/      % Divide, element-wise
       % STACK: 6, [1 2 3 4 5 6 7], [6 3 2 1.5 1.2 1 0.8571]
Yo     % Round to closest integer. Halves are rounded up
       % STACK: 6, [1 2 3 4 5 6 7], [6 3 2 2 1 1 1]
*      % Multiply, element-wise
       % STACK: 6, [6 6 6 8 5 6 7]
<      % Less than, element-wise
       % STACK: [0 0 0 1 0 0 1]
f      % Find: indices of nonzeros (1-based)
       % STACK: [4 7]
X<     % Minimum of vector. Implicit display
       % STACK: 4

JavaScript (ES6), 28 25 bytes
n=>g=x=>n%x>=x/2?x:g(-~x)

3 bytes saved thanks to Arnauld.

Test it

o.innerText=(f=

n=>g=x=>n%x>=x/2?x:g(-~x)

)(i.value=64)();oninput=_=>o.innerText=f(+i.value)()
<input id=i type=number>

Or test all numbers from 1-1000 (Give it a minute to run):

f=n=>g=x=>n%x>=x/2?x:g(-~x);[2,3,2,5,2,4,2,3,2,4,2,7,2,3,2,6,2,4,2,3,2,4,2,5,2,3,2,5,2,4,2,3,2,4,2,8,2,3,2,6,2,4,2,3,2,4,2,5,2,3,2,6,2,4,2,3,2,4,2,7,2,3,2,5,2,4,2,3,2,4,2,11,2,3,2,6,2,4,2,3,2,4,2,5,2,3,2,5,2,4,2,3,2,4,2,7,2,3,2,6,2,4,2,3,2,4,2,5,2,3,2,6,2,4,2,3,2,4,2,11,2,3,2,5,2,4,2,3,2,4,2,7,2,3,2,6,2,4,2,3,2,4,2,5,2,3,2,5,2,4,2,3,2,4,2,8,2,3,2,6,2,4,2,3,2,4,2,5,2,3,2,6,2,4,2,3,2,4,2,7,2,3,2,5,2,4,2,3,2,4,2,13,2,3,2,6,2,4,2,3,2,4,2,5,2,3,2,5,2,4,2,3,2,4,2,7,2,3,2,6,2,4,2,3,2,4,2,5,2,3,2,6,2,4,2,3,2,4,2,9,2,3,2,5,2,4,2,3,2,4,2,8,2,3,2,6,2,4,2,3,2,4,2,5,2,3,2,5,2,4,2,3,2,4,2,8,2,3,2,6,2,4,2,3,2,4,2,5,2,3,2,6,2,4,2,3,2,4,2,7,2,3,2,5,2,4,2,3,2,4,2,7,2,3,2,6,2,4,2,3,2,4,2,5,2,3,2,5,2,4,2,3,2,4,2,10,2,3,2,6,2,4,2,3,2,4,2,5,2,3,2,6,2,4,2,3,2,4,2,11,2,3,2,5,2,4,2,3,2,4,2,8,2,3,2,6,2,4,2,3,2,4,2,5,2,3,2,5,2,4,2,3,2,4,2,7,2,3,2,6,2,4,2,3,2,4,2,5,2,3,2,6,2,4,2,3,2,4,2,8,2,3,2,5,2,4,2,3,2,4,2,7,2,3,2,6,2,4,2,3,2,4,2,5,2,3,2,5,2,4,2,3,2,4,2,9,2,3,2,6,2,4,2,3,2,4,2,5,2,3,2,6,2,4,2,3,2,4,2,7,2,3,2,5,2,4,2,3,2,4,2,8,2,3,2,6,2,4,2,3,2,4,2,5,2,3,2,5,2,4,2,3,2,4,2,7,2,3,2,6,2,4,2,3,2,4,2,5,2,3,2,6,2,4,2,3,2,4,2,8,2,3,2,5,2,4,2,3,2,4,2,7,2,3,2,6,2,4,2,3,2,4,2,5,2,3,2,5,2,4,2,3,2,4,2,10,2,3,2,6,2,4,2,3,2,4,2,5,2,3,2,6,2,4,2,3,2,4,2,7,2,3,2,5,2,4,2,3,2,4,2,8,2,3,2,6,2,4,2,3,2,4,2,5,2,3,2,5,2,4,2,3,2,4,2,7,2,3,2,6,2,4,2,3,2,4,2,5,2,3,2,6,2,4,2,3,2,4,2,8,2,3,2,5,2,4,2,3,2,4,2,9,2,3,2,6,2,4,2,3,2,4,2,5,2,3,2,5,2,4,2,3,2,4,2,10,2,3,2,6,2,4,2,3,2,4,2,5,2,3,2,6,2,4,2,3,2,4,2,7,2,3,2,5,2,4,2,3,2,4,2,7,2,3,2,6,2,4,2,3,2,4,2,5,2,3,2,5,2,4,2,3,2,4,2,8,2,3,2,6,2,4,2,3,2,4,2,5,2,3,2,6,2,4,2,3,2,4,2,8,2,3,2,5,2,4,2,3,2,4,2,13,2,3,2,6,2,4,2,3,2,4,2,5,2,3,2,5,2,4,2,3,2,4,2,7,2,3,2,6,2,4,2,3,2,4,2,5,2,3,2,6,2,4,2,3,2,4,2,13,2,3,2,5,2,4,2,3,2,4,2,7,2,3,2,6,2,4,2,3,2,4,2,5,2,3,2,5,2,4,2,3,2,4,2,8,2,3,2,6,2,4,2,3,2,4,2,5,2,3,2,6,2,4,2,3,2,4,2,7,2,3,2,5,2,4,2,3,2,4,2,11,2,3,2,6,2,4,2,3,2,4,2,5,2,3,2,5,2,4,2,3,2,4,2,7,2,3,2,6,2,4,2,3,2,4,2,5,2,3,2,6,2,4,2,3,2,4,2,9,2,3,2,5,2,4,2,3,2,4,2,7,2,3,2,6,2,4,2,3,2,4,2,5,2,3,2,5,2,4,2,3,2,4,2,8,2,3,2,6].forEach((x,y)=>o.innerText+=`\n-----------------------------\n${(++y+"").padStart(7)}  |${(y=f(y)()+"").padStart(8)}  |  ${x==y}`)

  Input  |  Output  |  Pass

Proton, 33 bytes
n=>[x for x:2..n+2if n%x>=x/2][0]

Try it online!

I don't know anything about Proton, but It seems you can save 3 bytes: Try it online!

Maybe a coincidence, but this is exactly the same as totallyhuman's solution...:p

@EriktheOutgolfer We posted it at the same time (in fact I ninja'd him by a few seconds) with 37-byter, because Hyper borked the operators, and when he fixed them we both updated.

Uhh, I ninja'd you IIRC. :P

@totallyhuman You ninja'd me with a 41-byter. I posted the 37-byter first and ninja'd you with that one by a few seconds.

Python 2, 35 bytes
f=lambda n,i=1:n%i*2/i or-~f(n,i+1)

Try it online!

Pyth, 12 11 bytes
hfgy%QTTm+2

Try it here.

Proton, 33 bytes
x=>[y for y:2..x+2if x%y>=y/2][0]

Try it online!

FWIW, why did you remove ?

Jelly, 11 bytes
÷R%1<.¬;1TṂ

A monadic link taking and returning positive integers.
Try it online! or see a test suite.
How?
÷R%1<.¬;1TṂ - Link: number, n       e.g. 10
 R          - range(n)               [ 1,2,3     ,4  ,5,6     ,7     ,8   ,9     ,10]
÷           - n divided by           [10,5,3.33..,2.5,2,1.66..,1.42..,1.25,1.11..,1 ]
  %1        - modulo by 1            [ 0,0,0.33..,0.5,0,0.66..,0.42..,0.25,0.11..,0 ]
    <.      - less than 0.5?         [ 1,1,1     ,0  ,1,0     ,1     ,1   ,1     ,1 ]
      ¬     - not                    [ 0,0,0     ,1  ,0,1     ,0     ,0   ,0     ,0 ]
       ;1   - concatenate a 1        [ 0,0,0     ,1  ,0,1     ,0     ,0   ,0     ,0 , 1]
         T  - truthy indices         [            4    ,6                           ,11]
          Ṃ - minimum                4

Note: The concatenation of 1 is just to handle the cases where n is one of 1 ,2, or 4 when the result needs to be n+1 (‘R÷@%1<.¬TṂ would also work).

Haskell, 33 32 bytes
f n=[i|i<-[1..],2*mod n i>=i]!!0

Try it online!
Saved one byte thanks to w0lf

You can use !!0 instead of head

Dyalog APL, 23 22 bytes
{⊃x/⍨⍵<x×⌊.5+⍵÷x←⍳1+⍵}

Try it online!

Java 8, 42 bytes
Lambda from Integer to Integer.
n->{for(int f=1;;)if(n%++f*2>=f)return f;}

Try It Online
Acknowledgments

-1 byte thanks to Kevin Cruijssen

You can save a byte by starting f=1 and using ++f on the first f, like this: n->{for(int f=1;;)if(n%++f*2>=f)return f;}

Pyth, 5 bytes
fgy%Q

Test suite
No rounding builtins, just checking for the first positive integer T, where double the input mod T is greater than or equal to T.
Explanation:
fgy%Q
fgy%QTT    Implicit variable introduction.
f          Find the first positive integer T such that the following is truthy:
   %QT     Input % T
  y        Doubled
 g    T    Is greater than or equal to T

x86 Machine Code, 17 bytes
This code implements a basic, iterative solution in the form of a reusable function:
31 F6                   xor    esi, esi
46                      inc    esi         ; set ESI (our temp register) to 1

                     Loop:
89 C8                   mov    eax, ecx    ; copy 'n' to EAX for division
46                      inc    esi         ; eagerly increment temp
99                      cdq                ; extend EAX into EDX:EAX
F7 F6                   div    esi         ; divide EDX:EAX by ESI
01 D2                   add    edx, edx    ; multiply remainder by 2
39 F2                   cmp    edx, esi    ; compare remainder*2 to temp
7C F4                   jb     Loop        ; keep looping if remainder*2 < temp

96                      xchg   eax, esi    ; put result into EAX (1 byte shorter than MOV)
C3                      ret

The function follows the fastcall calling convention, so that the single parameter (n) is passed in the ECX register. The return value (k) is, per usual, returned in the EAX register.
Try it online!

Perl 5, 24 + 1 (-p) = 25 bytes
1while$_%++$k<$k/2;$_=$k

Try it online!
Tries each integer $k starting at 1 until it finds a remainder that is at least half of $k.

Forth (gforth), 45 bytes
: f 1 begin 1+ 2dup mod over 1+ 2/ >= until ;

Try it online!
Code Explanation
: f             \ start a new word definition
  1             \ start a counter at 1
  begin         \ start an indefinite loop
    1+          \ add 1 to counter
    2dup mod    \ duplicate input value and counter, get remainder of input/counter
    over 1+ 2/  \ get counter/2 (add 1 to force rounding up)
    >=          \ check if remainder is greater than counter/2
  until         \ end loop if true, otherwise go back to beginning
;               \ end word definition

05AB1E, 9 bytes
∞.ΔIs/Dò‹

Try it online!
Explanation
∞.ΔIs/Dò‹ Full code
∞.Δ       Returns the first number for which the following code returns true
             -> stack is [n]
   Is     Push the input and swap the stack -> stack is [input, n]
     /    Divide both of them -> stack is [input/n]
      Dò  Duplicate and round the second -> stack is [input/n, rounded(input/n)]
        ‹ Check if input/n got larger by rounding -> stack is [bool]
             -> if bool is true, abort and return the current number

Rockstar, 681 bytes
Thought takes Patience and Control
While Patience is as high as Control
Let Patience be without Control

Give back Patience

Rock takes Art
Love is neverending
Sex is bottomless
Put Thought taking Art & Love into your head
If your head is Sex
Give back Art
Else
Limits are inspiration
Put Art with Limits without your head into the rubbish
Give back the rubbish

Listen to Chance
Questions are unstoppable
Until Questions is Chance
Build Questions up
Put Thought taking Chance, Questions into your mind
Answers are independence (but)
Put Questions over Answers into the world
Put Rock taking the world into the world
If your mind is as big as the world
Say Questions
Break it down

You can try rockstar online, but you'll need to copy and paste the code across. It will prompt you for an input number.
I didn't go for lowest byte count , because Rockstar is obviously not made for golfing, so instead I tried to go for Rock 'n' Roll lyrics.
Explanation:
This is based on the same solution as others (python, java):
Iterate up from 2:
if n % iterator >= ceil(n/2)
    return iterator

First I need to define modulus and ceiling functions though, which for poetry's sake are called Thought and Rock.
The below is a less poetic version with different variable names, and explanations where the syntax is unclear. Parentheses denote comments.
Modulus takes Number and Divisor
While Number is as high as Divisor
Put Number minus Divisor into Number
    (blank line ending While block)
Give back Number (return Number)
    (blank line ending function declaration)
Ceil takes Decimal
Put Modulus taking Decimal, 1 into Remainder
If Remainder is 0
Give back Decimal (return Decimal)
Else
Put Decimal with 1 minus Remainder into Result
Give back Result (return Result)
    (blank line ending if block)
    (blank line ending function declaration)
Listen to Input (Read from STDIN to Input)
Index is 1
Until Index is Input
Build Index up (Increment by 1)
Put Modulus taking Input, Index into LHS
Put Index over 2 into RHS
Put Ceil taking RHS into RHS
If LHS is as big as RHS
Say Index
Break it down (Break from loop)

Jelly, 18 bytes
ɓ÷Ḟ,¥Ċ$×ạÐṂ⁸Ṁ>⁸µ1#

Try it online!
Full program.

Full program. When is it not?

@totallyhuman Sometimes it also works as a function.

Swift 3, 51 bytes
{n in(2..<n+2).filter{Float(n%$0)>=Float($0)/2}[0]}

For some extremely bizarre reasons, [0] doesn't work online. Here is the online compiler-compatible version (that uses .first! instead):
{n in(2..<n+2).filter{Float(n%$0)>=Float($0)/2}.first!}

Test Suite (online-compatible).

C# (Mono), 39 bytes
n=>{int i=1;for(;n%++i*2<i;);return i;}

Try it online!

Stax, 7 bytes
ç&╬▼⌐╔ñ

Run and debug it

source: Stack Exchange

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/

sort: votes


text:
Golf a number bigger than TREE(3)
The function TREE(k) gives the length of the longest sequence of trees T1, T2, ... where each vertex is labelled with one of k colours, the tree Ti has at most i vertices, and no tree is a minor of any tree following it in the sequence.
TREE(1) = 1, with e.g. T1 = (1).
TREE(2) = 3: e.g. T1 = (1); T2 = (2)--(2); T3 = (2).
TREE(3) is a big big number. Even bigger than Graham's number. Your job is to output a number even bigger than it!
This is a code-golf so the goal is to write the shortest program in any language that deterministically outputs a number bigger than or equal to TREE(3) (to the stdout).

You aren't allowed to take input.
Your program must eventually terminate but you can assume the machine has infinite memory.
You might assume your language's number type can hold any finite value but need to explain how this exactly works in your language (ex: does a float have infinite precision?)

Infinities are not allowed as output.
Underflow of a number type throws an exception. It does not wrap around.

Because TREE(3) is such a complex number you can use the fast growing hierarchy approximation fϑ(Ωω ω)+1(3) as the number to beat.
You need to provide an explanation of why your number is so big and an ungolfed version of your code to check if your solution is valid (since there is no computer with enough memory to store TREE(3))

Note: None of the answers currently found here work.
Why is TREE(3) so big?

@AdmBorkBork TREE(3) is much harder to beat than Graham's number. None of the answers you list are valid here.

Separately from whether it's a duplicate or not, what's the winning criterion?

@PyRulez none of those answers work, but unless I'm mistaken, they could be trivially lengthened to work.

@StepHen not trivally. Getting to Tree(3) requires a whole new paradigm.

@StepHen whoops, I always forget that.

@PyRulez from the (now deleted) comment about Ackermann, couldn't I just run a really big Ackermann? (and Ackermann is a builtin in several langs)

@StepHen your input would need to be significantly bigger than Graham's number.

@PyRulez How will we know if we've done it? Say I define f(x) : f(2) = 2 and f(x>2) = f(x-1)^f(x-1). Is f(1000000) > TREE(3)?

@benzene you will need to use math. It doesn't look like your answer works though. I added a link describing the size of Tree(3).

@PyRulez It looks as though we only have weak lower bounds on Tree(3), not the actual value or upper bound expressions. What math can we use to determine if some number is larger than it?

@benzene the third note has some upper bounds. We don't have tight upper bounds, but we do have upper bounds. I listed some, in fact.

This paper by Friedman lends itself to very short and simple programs, but apparently the resulting function, though enormous, can't compete with TREE(3) even for very large inputs. https://pdfs.semanticscholar.org/03dc/a166fed9d17a4c3507a76a66f8e1951f7d7a.pdf

"It can be an integer, float, or any other number type that language supports. This number must be bigger than what is known as TREE(3)." Normally for this kind of question we assume that big integers are unbounded (despite the practical bounds imposed by implementation), but I don't recall any previous similar question which allowed floats and I'm not sure how to interpret this permission.

@PeterTaylor you can assume that are unbounded as well. (Just no infinity.) I was just trying to be open in what I allow.

Possible duplicate: https://codegolf.stackexchange.com/questions/18028/largest-number-printable

@KSmarts that's not [tag:code-golf]

relevant: https://codegolf.meta.stackexchange.com/questions/14057/should-output-a-number-bigger-than-tree3-be-edited-an-reopened

@fejfo I would, but I can't vote again, since I voted to reopen it once already.

TREE(3)+1 there I win

@HyperNeutrino in what programming language is that valid?

None; it's just theoretical, and I'm being facetious :P

@KSmarts You do realize none of the answers there come close to TREE(3)?

Couldn’t I just output strings? In output, they’re identical to integers/floats... etc.

@StanStrum why not just take the length of the string, which is basically the same thing?

@PyRulez I don’t like using numbers > 2 ^ 31 - 1

@StanStrum but your fine with strings that big? If you want, you could output a string of 9s, and that would count as outputting a number.

@StanStrum this question has already been closed and reopened twice, so I don't really want to change it

@PyRulez That’s alright. First, I’ll need to procrastinate my work to satisfy myself. Then, I’ll head off to my bash prompt and marker board.

@Stephen In order to reach TREE(3) using Ack(k,k), k will need to be on nearly the same order of magnitude as TREE(3). In particular, k needs to be on the level of f_ϑ(Ωω ω)+1(n), which is practically speaking TREE(3).

@benzene See the previous comment.

Does anyone know how many digits are in TREE(3)? I've looked around and all I've found is that it's too big to easily describe. Is it more or less than 2E15?

@EngineerToast about log(TREE(3)), which is much larger than tree(7) (note TREE and tree are different functions).

@PyRulez I couldn't find much on that but I did find something about Graham's number: "Writing out the number of digits it has would take more atoms that can be found on the planet, and that wouldn't even be
remotely close!" Since TREE(3) is insanely larger than that, I'm going to say it's longer than 2E15 digits. Printing 9s for the next 7,000 years is not a valid solution, then.

@EngineerToast See this comment. It more or less transcribes into "the amount of digits of TREE(3) are so large, that it's on the same magnitude of TREE(3)." Generally, once numbers reach the scale of 1E(1E(1E(1E(1E(1E(...)))))) we say "the amount of digits" looks practically the same as the number itself. (hopefully that makes sense)

Is a solution like while (i++ < INT_MAX) while (j++ < INT_MAX) while (k++ < INT_MAX) while (l++ < INT_MAX) while (m++ < INT_MAX) printf("999"); allowed?

@MDXF I'm gonna say no, because using INT_MAX is kinda a cheating (otherwise, print INT_MAX would insta win). In general, your output needs to be the same for any sufficiently large system.

@MDXF also, pretty sure you won't reach TREE(3) anytime soon like that.

@HyperNeutrino Okay, you win. I made an answer with TREE(3)+1. It's needs to be better golfed if its going to win though.

If I output a string of digits, does that count? And if I print multiple times, will we concatenate the final results?

@SimplyBeautifulArt yeah, that should be fine

You don't fix the number of k color... If that number is fixed I in the place of color use label {1..k+1} and my TREE(k+1) is bigger than your TREE(k)

@RosLuP uhm, $k=3$. If you want to do $TREE(4)$, that's fine. (You have to write a program to output it though.)

@ØrjanJohansen Thanks for the generosity.

Public service announcement: I'm opening a Discord server dedicated to explaining ordinals and the fast growing hierarchy. The end goal will be to reach an understanding of the magnitude of TREE(3) and larger things using only recursion, and lots of it.

Add the tag ([tag:tree-traversal])?

@ØrjanJohansen Whoops sorry, wrong question. :P

See also: Ridiculously Huge numbers Part 20

@SimplyBeautifulArt I'm not sure. Answers do not need to do anything with trees, and most of them do not. TREE(3) is just a number that just so happens to be defined in terms of trees. Many number of similar magnitude are not defined in terms of trees.

Javascript, 111 bytes, ~ \$f_{\psi(\Omega_\omega)}(6)\$
\$f\$ is the Fast-growing Hierarchy. \$ψ\$ is Buchholz's Psi. This entry, despite being 111 bytes, dominates all of the previous entries in both size and the amount of bytes (except for Loader's number).
Here is the code:
s=JSON.stringify;P=([y,z])=>y?JSON.parse((k=s([P(y),z])).replaceAll(s(z),k)):z;for(a=b=0;a=b++<9?[a,0]:P(a););b

Here is the same code expanded out:
function P([y,z]) {
  if (y==0) {
    return z
  } else {
    k = JSON.stringify([P(y),z])
    return JSON.parse(k.replaceAll(JSON.stringify(z),k))
  }
}

for(a=b=0;a=b++<9?[a,0]:P(a););
b;

I'm going to explain both the P function and the for loop.
The Predecessor Function
The inputs of the predecessor function are binary trees with zeroes as leaf nodes. Here are some examples of binary trees:

0
[0,0]
[[0,[0,0]],[0,0]]
[[[[[0,0],0],[0,0]],[0,0]],[[0,[0,0]],[0,[0,0]]]]
[[[[[[[[[[0,0],0],0],0],0],0],0],0],0],0]

The Predecessor function is defined like this:

P([0,z])=z
P([x,y])=[P(x),y] but with all instances of y replaced with [P(x),y]
P(0) is left undefined

Right away, we can see 0 represents the number \$0\$, and [0,z] represents the structure \$z+1\$.
Natural numbers can be represented as [0,[0,[0,...[0,0]...]]] with \$n+1\$ zeroes. For example, \$1 =\$ [0,0], \$2 =\$ [0,[0,0]], \$3 =\$ [0,[0,[0,0]]], and so on.
Now consider the string [1,n] where \$n>1\$.
P([1,n])=[0,n] but replace all instances of \$n\$ with [0,n] \$\to\$ [0,[0,n]]
Therefore, [1,n] corresponds to \$n+3\$, as P(P(P([1,n]))) = n
By this logic, [2,n] corresponds to \$n+7\$, [3,n] corresponds to \$n+15\$, and [n,n] would approximately correspond to \$2^n\$. Maybe [[0,n],n] corresponds to \$2^{n+1}\$?
Not so fast!
Consider the string [[0,n],n]. One would expect this to correspond to \$2^{n+1}\$, but it is much stronger. P([[0,n],n]) \$\to\$ [P([0,n]),n] = [n,n], but then the second step would be to replace all instances of n with the entire tree, or [n,n]. This makes P([[0,n],n])=[[n,n],[n,n]] rather than [n,[n,n]].
One would ask whether this would cause an infinite loop. Let's try P([[n,n],[n,n]]). If we let J = P([n,n]), we will get:
P([[n,n],[n,n]])=[J,[n,n]] but with all instances of [n,n] replaced with [J,[n,n]]
However, there are no instances of [n,n] within J, because J is strictly less than [n,n]. Therefore, P([[n,n],[n,n]])=[J,[J,[n,n]]]. This works for all J less than [n,n].
So this means [[0,n],n] corresponds to \$2^{2^n}\$. [[0,[0,n]],n] corresponds to \$2^{2^{2^{2^n}}}\$. And finally, [[n,n],n] corresponds to \$n \uparrow\uparrow n\$. Now it is time to bring in the Middle Growing Hierarchy.
Middle Growing Hierarchy
The Middle Growing Hierarchy is defined here: https://googology.wikia.org/wiki/Middle-growing_hierarchy
One can make an approximate distinction with the Middle Growing Hierarchy.

[0,n] corresponds to \$m(0,n) \sim n+1\$
[1,n] corresponds to \$m(2,n) \sim n+3\$
[2,n] corresponds to \$m(3,n) \sim n+7\$
[n,n] corresponds to \$m(n,n) \sim n+2^n\$ and \$m(ω,n)\$
[n,[n,n]] corresponds to \$m(n+1,n) \sim 2^{n+1}\$ (not \$m(ω+1,n)\$)
[[0,n],n] corresponds to \$m(ω+1,n) \sim 2^{2^n}\$
[[0,[0,n]],n] corresponds to \$m(ω+2,n) \sim 2^{2^{2^{2^n}}}\$
[[1,n],n] corresponds to \$m(ω+3,n) \sim 2^{2^{2^{2^{2^{2^{2^{2^n}}}}}}}\$
[[n,n],n] corresponds to \$m(ω2,n) \sim n \uparrow\uparrow n\$

One can see a correspondence with the left-hand side of the binary tree and the inner subscript of the Middle Growing Hierarchy. Let's continue the correspondence. I will omit the right hand side of the binary tree and the base of the Middle Growing Hierarchy.

[n,n] corresponds to \$ω_2\$
[0,[n,n]] corresponds to \$ω_2+1\$
[n,[n,n]] corresponds to \$ω_3\$
[[0,n],[n,n]] corresponds to \$ω_4\$
[[1,n],[n,n]] corresponds to \$ω_6\$
[[0,n],n] corresponds to \$ω^2\$

So it seems like there is a jump from [[n,n],n] to [[[0,n],n],n], similar to the jump from [n,n] to [[0,n],n]. But even this doesn't capture the power of this notation.
More Ordinal Comparison

[n,[[0,n],n]] corresponds to \$ω^2+ω\$
[[n,n],[[0,n],n]] corresponds to \$2\timesω^2\$
[[n,[n,n]],[[0,n],n]] corresponds to \$ω^3\$
[[[0,n],[n,n]],[[0,n],n]] corresponds to \$ω^4\$
[[[0,n],n],[[0,n],n]] corresponds to \$ω^ω\$

We're not even at [[0,[0,n]],n] yet, what is going on?

[[[0,n],n],[[[0,n],n],[[0,n],n]]] corresponds to \$2\timesω^ω\$
[[n,[[0,n],n]],[[[0,n],n],[[0,n],n]]] corresponds to \$ω^{ω+1}\$
[[[n,n],[[0,n],n]],[[[0,n],n],[[0,n],n]]] corresponds to \$ω^{ω_2}\$
[[n,[[n,n],[[0,n],n]]],[[[0,n],n],[[0,n],n]]] corresponds to \$ω^{ω_2+1}\$
[[[0,[n,n]],[[0,n],n]],[[[0,n],n],[[0,n],n]]] corresponds to \$ω^{ω_3}\$
[[[n,[n,n]],[[0,n],n]],[[[0,n],n],[[0,n],n]]] corresponds to \$ω^{ω^2}\$
[[[[0,n],[n,n]],[[0,n],n]],[[[0,n],n],[[0,n],n]]] corresponds to \$ω^{ω^3}\$
[[0,[0,n]],n] corresponds to \$ω^{ω^ω}\$

Where does the strength comes from? The strength lies in the fact that the binary tree notation corresponds to performing the Middle Growing Hierarchy on ordinals! Here are some examples:

[n,n] corresponds to \$m(ω,n)=n+2^n\$, so [n,n] as an ordinal corresponds to \$ω+2^ω=ω_2\$
[[0,n],n] corresponds to \$m(ω+1,n)=2^{n+2^n}\$, so [[0,n],n] as an ordinal corresponds to \$2^{ω+2^ω}=2^{ω_2}=ω^2\$
[[[0,n],n],[[0,n],n]] corresponds to \$m(ω,m(ω+1,n))=2^{2^{n+2^n}}\$, so [[[0,n],n],[[0,n],n]] as an ordinal corresponds to \$2^{2^{ω+2^ω}}=ω^ω\$
[[0,[0,n]],n] corresponds to \$m(ω+2,n)=2^{2^{2^{n+2^n}}}\$, so [[0,[0,n]],n] as an ordinal corresponds to \$2^{2^{2^{ω+2^ω}}}=ω^{ω^ω}\$

As it turns out, this pattern continues. I'm not going to go through the full analysis, but here are some more ordinal values. Remember that these are ordinals, not functions!

[[1,n],n] corresponds to \$ω^{ω^{ω^{ω^{ω^{ω^ω}}}}}\$
[[n,n],n] corresponds to \$ε_0\$
[[n,[n,n]],n] corresponds to \$ζ_0\$
[[[0,n],n],n] corresponds to \$φ(ω,0)\$
[[[n,n],n],n] corresponds to the BHO

Speed of Notation
Essentially, if a structure \$K\$ corresponds to \$g_a (n)\$ in the slow-growing hierarchy, then the structure [K,n] corresponds to \$m_a (n)\$ in the middle-growing hierarchy. This makes the limit [[[...,n],n],n], which corresponds to the first SGH-MGH catching point, of \$ψ(Ω_ω)\$. For comparison, \$\text{TREE}(n)\$ only corresponds to the ordinal \$ψ(Ω^{Ω^ω})\$, much much smaller. The premise of this notation is essentially nested Goodstein sequences, except it works!
The Middle Growing Hierarchy corresponds closely to the Fast Growing Hierarchy, this is why I put in \$f_{ψ(Ω_ω)}\$ as it is a catching point.
Actual Value of the program
Now that we have gone through the Predecessor function, and how it corresponds to numbers, functions, and ordinals, it is time to return to the value of this program.
To extract a value from a binary tree, such as [[[0,0],0],0], one would have to repeatedly apply the predecessor function until the value crashes down to 0. As we seen before, one would have to apply the predecessor function a massive amount of time, on the order of \$m(ψ(Ω_ω),x)\$
Just to let you know, [[[...,0],0],0] is not degenerate, unlike stuff like \$2 \uparrow\uparrow...\uparrow\uparrow2 = 4\$ in arrow notation. [[[...,0],0],0] will produce a massive number.
Here is the code again:
for(a=b=0;a=b++<9?[a,0]:P(a););b;

First, it sets a and b equal to 0. Then, it starts incrementing b. If b is less than 9, then it sets a to [a,0]. This means at b=9, a would had been already [[[[[[[[[0,0],0],0],0],0],0],0],0],0], which corresponds to a massive number. Then, the predecessor function gets repeatedly applied to a, increasing b by 1 for each application. Eventually, a is going to crash down to 0, but b will be some value far, far greater than \$\text{TREE}(3)\$, or \$\text{TREE}(\text{TREE}(...\text{TREE}(3)...))\$ with \$\text{TREE}(3)\$ nests. Finally, the program returns b.
So what?
One of the best thing about this program is how the notation enumerates the catching points between the SGH and the MGH. This program only reaches the very first catching point, but by a few simple extension, this program is able to formalize a meameamealokkapoowa oompa, surpass Strong Array Notation, and beat every single Ordinal Collapsing Function ever devised. \$ψ(Ω_ω)\$ is still a pathetically small value...

Welcome to the site, and impressive first answer! I've edited in some formatting and Mathjax to make the answer more readable. Feel free to revert or edit anything I've gotten wrong, or that you don't like, and don't hesitate to ping me (using @cairdcoinheringaahing) if you need any help/tips on editing/formatting

This is amazing, getting way higher than BHO this fast is incredible.

Also, you claim that with some simple extentions, this can go much higher. What extentions are these?

@SimplyBeautifulArt looks like you've been dethroned

Maybe this notation is related to extracting ordinals from "tree ordinals", shown here? http://log.chez.com/text/logic/ordinal_notations_v2.pdf#page=53

The 111 bytes can be further reduced to under 53 bytes in a translation to Binary Lambda Calculus, with growth boosted to ψ(Ω_ω+1); see https://github.com/tromp/AIT/blob/master/fast_growing_and_conjectures/patcail.lam

New Ruby, 135 bytes, >> Hψ(φ3(Ω+1))(9)
where H is the Hardy hierarchy, ψ is an extended version of Madore's OCF (will explain below) and φ is the Veblen function.
Try it online!
f=->a,n,b=a{c,d,e=a;a==c ?a-1:e ?a==a-[0]?[[c,d,f[e,n,b]],d-1,c]:c:[n<1||c==0?n:[f[c||b,n-1]],n,n]};h=[],k=9,k;h=f[h,p(k*=k)]while h!=0

Ungolfed: (using functions, not lambdas)
def f(a,n,b)
  c,d,e = a
  if a == c
    return a-1
  elsif e
    if a == a-[0]
      return [[c,d,f(e,n,b)],d-1,c]
    else
      return c
    end
  else
    x = c || b
    if n < 1 || c == 0
      return [n,n,n]
    else
      return [f(x,n-1,x),n,n]
    end
  end
end

k = 9
h = [[],k,k]
while (h != 0) do
  k *= k
  p k
  h = f(h,k,h)
end

Madore's extended OCF:

And (crudely) Veblen's phi function:

Explanation without ordinals:
f(a,n,b) reduces an array recursively. (if no third argument given, it takes the first argument twice.)
f(k,n,b) = k-1, k is a positive int.
f([c,d,0],n,b) = f([c,0,e],n,b) = c
f([c,d,e],n,b) = [[c,d,f(e,n,b)],d-1,c], d ≠ -1 and c ≠ 0

f([a],0,b) = [0,0,0]
f([0],n,b) = [n,n,n]
f([],n,b) = f([b],n,b)
f([a],n,b) = [f[a,n-1,a],n,n]

My program initiates k = 9, h = [[],9,9]. It then applies k = k*k and h = f(h,k) until h == 0 and outputs k.
Explanation with ordinals:
Ordinals follow the following representation: n, [], [a], [a,b,c], where n,d is a natural number and a,c are all ordinals.
x = Ord(y) if y is the syntactic version of x.
a[n,b] = Ord(f(a,n))
ω = Ord([0]) = Ord(f([a],-1,b))
n = Ord(n)
Ω = Ord([])
ψ'(a) = Ord([a])
ψ'(a)[n] = Ord(f([a],n))
φ(b,c) ≈ Ord([[0],b,c])
a(↓b)c = Ord([a,b,c]) (down-arrows/backwards associative hyper operators I designed just for ordinals)

We follow the following FS for our ordinals:
k[n,b] = k-1, k < ω
ω[n,b] = n(↓n)n
(a(↓b)0)[n,b] = (a(↓0)c)[n,b] = a
(a(↓b)c)[n,b] = (a(↓b)(c[n,b]))(↓b[n,b])a, b ≥ 0 and c > 0.
ψ'(a)[0,b] = 0(↓0)0
ψ'(a)[n,b] = (ψ'(a[n-1,a]))(↓n)ω, a > 0 and n ≥ 0. (also note that we've changed from [n,b] to [n,a].)
Ω[n,b] = ψ'(b)[n,b]

ψ'(ω∙α) ≈ ψ(α), the ordinal collapsing function described in the image above.
My program more or less initiates k = 9 and h = Ω(↑9)9, then applies k ← k² and h ← h[k,h] until h = 1 and returns k.
And so if I did this right, [[],9,9] is way bigger than the Bachmann-Howard ordinal ψ(ΩΩΩ...), which is way bigger than ϑ(Ωωω)+1.
ψ(Ω(↓9)9) > ψ(Ω(↓4)3) > ψ(ΩΩΩ)+1 > ψ(ΩΩωω)+1 > ϑ(Ωωω)+1
And if my analysis is correct, then we should have ψ'(ΩΩ∙x) ~= ψ*(ΩΩ∙x), where ψ* is the normal Madore's psi function. If this holds, then my ordinal is approximately ψ*(φ3(Ω+ω)).

Old Ruby, 309 bytes, Hψ'0(Ω9)(9) (see revision history, besides the new one is way better)

I could only test my program for very few values, so do excuse me if I've made a mistake somewhere.

Bleh, slowly but surely trying to think my way through and fixing anything I see wrong. :-( So tedious.

Hmm... so $f_{ψ_0(ψ9(9))}(9)$ means we need at least the $ψ_9(9)$ th weakly inaccessible cardinal level of the fast growing hierarchy with base 9 to get larger than $TREE(3)$

@Secret No, I just wanted to overshoot by a bit, plus working out a closer value to TREE(3) would cost me more bytes to write out. And there are no inaccessible cardinals used here.

@SimplyBeautifulArt I'm trying to understand this but I just don't.

@fejfo It's supposed to be that complicated ;) You can also visit my profile page for some chat rooms where you can try and get more explanation (which I may add into my answer)

I'm pretty sure that before this mathematics didn't know an upper bound for TREE(3) (source: Numberphile video), well done!

@Okx See PyRulez's comment.

@SimplyBeautifulArt the upperbounds I listed where removed from the question, unfortunately.

Unfortunately, the fundamental sequence rules for ordinals up to this level are not so simple.  You can see a definition of fundamental sequences at http://googology.wikia.com/wiki/Buchholz%27s_function

@Deedlit If I am not mistaken, ψ'_0(Ω_2) is the Bachmann-Howard ordinal?

@PyRulez =P Feel free to add them in. Anyways, the second bullet point from the bottom says that I can aim to beat the fgh approximation of TREE(3) instead.

Well, I'm not quite sure how ψ'_a(b) is defined, as it seems to be different from ψ_a(b).  It looks like ψ'_a(n) for n finite is just going to be n, as the recursive process decrements the n each time.  Also, it looks like when you reach a natural number in the recursive process, you decrement the number until it reaches 1, but when it is when you bump it back up to n again.  This problem is avoided when b is just a number, but if say b = [c,d], then d will get decremented down to 1 and then bumped back up repeatedly.  My biggest issue though is that the fundamental sequences are incorrect.

@Deedlit The main change is ψ'_a(b+1) = ψ'_a(b) + ψ'_a(b)

@Deedlit I think I fixed the loop problem with 1 being bounced up to n.

@Deedlit I realize the FS I've laid out above are not the norm, but they seem to align pretty well with Buchholz's function. In any case, what do you think is the supremum of this notation then?

It looks to me like you get a primitive recursive function. The subscripts aren't really being used, so the recursive process comes down to a nesting of ψ's. We have ψ'_a(b+1) = ψ'_a(b)*2, so each inner nesting gets you an exponential. So, tetrational growth? I may be wrong about that, but you definitely aren't getting OCF power here.

@Deedlit At the bottom of this answer, I added some evaluations which I think to be true. Could you look them over?

@Deedlit What do you mean by "the subscripts aren't really being used"? Are you talking about the subscripts on the Ω's or the ψ's? If you are talking about the Ω's, perhaps you missed the step i(n,Ω_c,b) = ψ'_(c-1)(b)[n-1], and if you are talking about the ψ's, then I'm not sure what you mean.

@Deedlit Hm, I suppose the problem is, say, constructing (Ω_1)^2 in my notation... this might be a challenge...

@Deedlit Think I can fix this by allowing nested subscripts e.g. Ω_(Ω_(Ω_1))?

@Deedlit Should be fine now... more or less using my ordinal hyperoperator in an ordinal collapsing function.

In your explanation: f(a) returns false if a is an array and false otherwise. So, it always returns false? I don't think that's right.

@KSmarts Typo in my explanation, thanks!

Golf nitpicks: You can definitely golf a.class!=Array, most idiomatic is !a.is_a? Array but shortest I can think of is a!=[*a]. And the methods can be converted into lambdas: f=->a,n=0,b=a{...}...f[x,y] to save some characters and maybe open up refactoring possibilities using them as first-class objects.

@histocrat Thanks for the tips!

@histocrat Unfortunately, I myself am poorly versed in the language of lambdas. =P Should probably read up on them more sometime.

@histocrat Hopefully I did the lambdas correctly. No idea as to how one would rewrite all of this by seeing them as first-class objects though

Your only one byte away from https://codegolf.stackexchange.com/a/146279/16842

@PyRulez Yup... working on it ;)

@SimplyBeautifulArt I'm gaining in you as well. ;)

@PyRulez D= Guess I'll get working on some super golfing ordinals then.

@PyRulez =P I did it! x'D

@SimplyBeautifulArt congratz!

=D try beating me again @Deedlit

You may be interested in this challenge.

Haskell, 252 Bytes, TREE(3)+1
data T=T[T]Int
l(T n _)=1+sum(l<$>n)
a@(T n c)#T m d=any(a#)m||c==d&&n!m
l@(x:t)!(y:u)=l!u||x#y&&t!u
x!_=null x
a n=do x<-[1..n];T<$>mapM(\_->a$n-1)[2..x]<*>[1..3]
s 0=[[]]
s n=[t:p|p<-s$n-1,t<-a n,(l t<=n)>any(#t)p]
main=print$[x|x<-[0..],null$s x]!!0

Thanks for help from H.PWiz, Laikoni and Ørjan Johansen for help golfing the code!
As suggested by HyperNeutrino, my program outputs TREE(3)+1, exactly (TREE is computable as it turns out).
T n c is a tree with label c and nodes n. c should be 1, 2, or 3.
l t is the number of nodes in a tree t.
t1 # t2 is true if t1 homeomorphically embeds into t2 (based on Definition 4.4 here), and false otherwise.
a n outputs a big list of trees. The exact list isn't important. The important property is that a n contains every tree up to n nodes, with nodes being labelled with 1, 2, or 3, and maybe some more trees as well (but those other trees will also be labelled with 1, 2, or 3). It is also guaranteed to output a finite list.
s n lists all sequences length n of trees, such that the reverse (since we build it backwards) of that sequence is valid. A sequence is valid if the nth element (where we start counting at 1) has at most n nodes, and no tree homeomorphically embeds into a later one.
main prints out the smallest n such that there is no valid sequences of length n.
Since TREE(3) is defined as the length of the longest valid sequence, TREE(3)+1 is the smallest n such that there are no valid sequences of length n, which is what my program outputs.

Python 2, 194 bytes, ~ Hψ(ΩΩΩ)(9)
where H is the Hardy hierarchy, and ψ is the ordinal collapsing function below the Bachmann-Howard ordinal defined by Pohlers.
Thanks to Jonathan Frech for -3 bytes.

def S(T):return 0if T==1else[S(T[0])]+T[1:]
def R(T):U=T[0];V=T[1:];exec"global B;B=T"*(T[-1]==0);return[S(B)]+V if U==1else[R(U)]*c+V if U else V
A=[[[1,1],1],0]
c=9
while A:A=R(A);c*=c
print c

Try it online!
Better spaced version:
def S(T):
  return 0 if T==1 else [S(T[0])]+T[1:]

def R(T):
  U=T[0]
  V=T[1:]
  global B
  if T[-1]==0:
    B=T
  if U==1:
    return [S(B)]+V
  return [R(U)]*c+V if U else V

A=[[[1,1],1],0]
c=9
while A:
  A=R(A)
  c*=c
print c

Explanation:
This program implements a variant of the Buchholz hydra, using just labels of 0 and 1.  Basically, at each step, we look at the first leaf node of the tree, and see if it is labelled with a 0 or a 1.
-If the leaf node is labelled with a 0, then we delete the leaf node, and then copy the tree starting from the parent of the leaf node c times, all of the copies connected to the grandparent of the leaf node.
-If the leaf node is labelled with a 1, then we search back towards the root until we reach an ancestor node labelled with a 0.  Let S be the tree starting from that ancestor node.  Let S' be S with the leaf node relabelled with 0.  Replace the leaf node with S'.
We then repeat the process until we have nothing left but the root node.
This program differs from the normal Buchholz hydra procedure in two ways:  First, after we do the above procedure, we recurse back up the tree, and do the label 0 copy procedure described above for each ancestor node of the original leaf node.  This increases the size of the tree, so our procedure will take longer than the normal Buchholz hydra, and therefore lead to a bigger number in the end; however, it will still terminate because the ordinal associated with the new tree will still be less the the old tree.  The other difference is, rather than start with c = 1 and increasing 1 each time, we start with c = 9 and square it each time, because why not.
The tree [[[1,1],1],0] corresponds to the ordinal ψ(ΩΩΩ), which is considerably bigger than the ordinal ϑ(Ωωω), and so our resulting final number of about Hψ(ΩΩΩ)(9) will definitely exceed TREE(3).

Not so golfy my friend :-)

I know. I don't know how to reduce it further, at least not in Python. Maybe I can try to learn some Ruby.

Is it possible to put R(T) all on one line?

@SimplyBeautifulArt Most likely yes (TIO link), though untested.

@JonathanFrech Thanks for your help!  Unfortunately, when I tried your code it gave an error message "global B is not defined".  I have no idea why this gives an error while the original code does not, so I don't know how to fix it.

@Deedlit The mistake I made involves the statement B=[B,T][T[-1]==0];, as the list tries to evaluate B, even though it is not yet defined. I wrote a three bytes longer, though hopefully working version, which uses string multiplication instead of an if/else statement (the global keyword should only be necessary when setting B, not when reading).

Wouldn't it be better to increment c before decrimenting A?

Julia, 569 bytes, Loader's Number
r,/,a=0,div,0;¬x=x/2;r<s=r?s:0;y\x=y-~y<<x;+x=global r=(x%2!=0)<1+(+¬x);!x=¬x>>+x;√x=S(4,13,-4,x);S(v,y,c,t)=(!t;f=x=r;f!=2?f>2?f!=v?t-(f>v)%2*c:y:f\(S(v,y,c,!x)\S(v+2,t=√y,c,+x)):S(v,y,c,!x)$S(v,y,c,+x));y$x=!y!=1?5<<y\x:S(4,x,4,+r);D(x)=(c=0;t=7;u=14;while(x!=0&&D(x-1);(x=¬x)%2!=0)d=!!D(x);f=!r;x=!r;c==r<((!u!=0||!r!=f||(x=¬x)%2!=0)<(u=S(4,d,4,r);t=t$d);¬f&(x=¬x)%2!=0<(c=d\c;t=√t;u=√u));(c!=0&&(x=¬x)%2!=0)<(t=((~u&2|(x=¬x)%2!=0)<(u=1<<(!c\u)))\(!c\t);c=r);¬u&(x=¬x)%2!=0<(c=t\c;u=√t;t=9)end;global a=(t\(u\(x\c)))\a);D(D(D(D(D(BigInt(99))))))

To save myself a bit of legwork, I decided to port Loader.c to Julia nearly one-for-one and compact it into the block of code above. For those that want to do the comparisons themselves (either to verify my scoring or to help me find mistakes or improve my code), an ungolfed version is below:
r,/,a=0,div,0;
¬x=x/2;
r<s=r?s:0;
y\x=y-~y<<x;
+x=global r=(x%2!=0)<1+(+¬x);
!x=¬x>>+x;
√x=S(4,13,-4,x);
S(v,y,c,t)=(
    !t;
    f=x=r;
    f!=2?
        f>2?
            f!=v?
                t-(f>v)%2*c
                :y
            :f\(S(v,y,c,!x)\S(v+2,t=√y,c,+x))
        :S(v,y,c,!x)$S(v,y,c,+x)
);
y$x=!y!=1?5<<y\x:S(4,x,4,+r);
D(x)=(
    c=0;
    t=7;
    u=14;
    while(x!=0&&D(x-1);(x=¬x)%2!=0)
        d=!!D(x);
        f=!r;
        x=!r;
        c==r<(
            (!u!=0||!r!=f||(x=¬x)%2!=0)<(
                u=S(4,d,4,r);
                t=t$d
            );
            ¬f&(x=¬x)%2!=0<(
                c=d\c;
                t=√t;
                u=√u
            )
        );
        (c!=0&&(x=¬x)%2!=0)<(
            t=((~u&2|(x=¬x)%2!=0)<(u=1<<(!c\u)))\(!c\t);
            c=r
        );
        ¬u&(x=¬x)%2!=0<(
            c=t\c;
            u=√t;
            t=9
        )
    end;
    global a=(t\(u\(x\c)))\a
);
D(D(D(D(D(BigInt(99))))))

No previous counts because I made way too many byte miscounts in the aggressive golfing I've done.

Oh dear. 1 more addition to this madness of a place.

Also, while I've no proof of this, I think that D(D(D(D(99)))) is large enough. :| Maybe D(D(D(99))) is large enough.

If anyone wants to help me here, the next logical plan of attack is to generate a macro to compact "(x=¬x)%2!=0" into a single-letter macro. Can't figure out Julia macros myself, so someone else could be of use here.

Ruby, 140 bytes, ~ Hψ(ΩΩΩ)(81)
where H is the Hardy hierarchy, and ψ is the standard ordinal collapsing function below the Bachmann-Howard ordinal, as defined here.
s=->t{*v,u=t;t==1?[]:v<<s[u]}
r=->t{*v,u=t;$b=t[0][0]?$b:t;u==1?v<<s[$b]:u[0]?v+[r[u]]*$c:v}
$c=9
a=[],[1,[1,1]]
($c*=9;a=r[a])while a[0]
$c

Try it online!
Ungolfed version:

def S(a)
  *v, u = a
  if a == 1
    return []
  else
    return v + [S(u)]
  end
end

def R(t)
  *v, u = t
  if t[0] == []
    $b = t
  end
  if u == 1
    return v + [S($b)]
  elsif u == []
    return v
  else
    return v + [R(u)]*$c
  end
end

$c = 9

a = [[],[1,[1,1]]]

while a != [] do
  $c *= 9
  a = R(a)
end

print $c

This program implements the Buchholz hydra with nodes labelled with []'s and 1's, as described in my Python 2 entry.
The tree [[],[1,[1,1]]] corresponds to the ordinal ψ(ΩΩΩ), which is considerably bigger than the ordinal ϑ(Ωωω) = ψ(ΩΩωω), and so our resulting final number of about Hψ(ΩΩΩ)(81) will exceed TREE(3).

Dang it you and your 149 bytes.

But Ruby for the win :P

Golf nitpick: Rather than writing u==0?v:u==[]?v you could write u==0?||u[0]?v, which saves two bytes.

@SimplyBeautifulArt Thanks for the help!  Balls back in your court. :D

:| Now we're tied.

.... this is.... fun ...

Save a byte: v+[s[$b]] can be changed to v<<s[$b].

I think your latest edit accidentally cut off some stuff.

D:< that 1 byte difference between us is the most frustrating thing ever.

Okay, should be your turn.

Ah, never mind, we're tied now...

You should be able to reduce (...)while ... down to ... while ...

-4 bytes.

Javascript, 511 bytes
I am new to code golf (this is my second time), but certainly not to implementing or inventing large numbers. However this programs takes quite a lot of code to beat TREE(3) :( The program results in \$f_{TFBO+1}(3) = f_{TFBO}(f_{TFBO}(f_{TFBO}(3)))\$ in the fast-growing hierarchy, where \${TFBO}\$ is the Takeuti-Feferman-Buchholz Ordinal \$\psi(\Omega_{\omega+1})\$. It uses Buchholz hydras and implements the BH function. Here is my compressed code, which was done with Naruyoko's Javascript compressor:
_="69{%t.length-1D*6m#{%B]}*6s#{t.splice(m#,14*@n=1;*6e#{7==0/s#;if(9>1/$i=0;i<n;i:t'B-1]4}}7>0&&typeof t==\"number\"/$i=98t[i]<m#8i--/}@s;$j5i8j <= 98j:s't[j]4@?5s;?[j]=?[i]-1;?[l(?)]=0;s#;$k508k <= l(?)8k:t'?[k]4}7==A/B]=n+1Dn += 1;%tD*6b(k/i5[\"+\",0];$l508l < k-28l:i'A)}while(l(i)>=0/i=e(i4%nD*Console.log(b(b(b(3))));#(t)$for(let %return '.push(*\n    /){4)D5 = 6function 7if(m#8; 9l#:++/?sa@var A\"w\"Bt[9D;}";for($ of"DBA@?:987654/*'%$#")with(_.split($))_=join(pop());eval(_)

This is basically incomprehensible, with only fragments of the original code revealing themselves, so here is the original code (still somewhat golfed):
function l(t){return t.length-1;}
function m(t){return t[l(t)]}
function s(t){t.splice(m(t),1);}
var n=1;
function e(t){if(m(t)==0){s(t);if(l(t)>1){for(let i=0;i<n;i++){t.push(t[l(t)-1]);}}}if(m(t)>0&&typeof t=="number"){for(let i=l(t); t[i]<m(t); i--){}var s;for(let j = i; j <= l(t); j++){s.push(t[j]);}var sa = s;sa[j]=sa[i]-1;sa[l(sa)]=0;s(t);for(let k = 0; k <= l(sa); k++){t.push(sa[k]);}}if(m(t)=="w"){t[l(t)]=n+1;}n += 1;return t;}
function b(k){i = ["+",0];for(let l = 0; l < k-2; l++){i.push("w")}while(l(i)>=0){i=e(i);}return n;}
Console.log(b(b(b(3))));

Explanation
This program, as I mentioned earlier implements Buchholz hydras, which are stored as arrays. This is what the code does:
It defines shorthands l(t), the index of the last element of the array, m(t), the last element of the array, and s(t), which chops off the last element of the array (the rightmost head). I also define a counter n which keeps track of how many times the hydra has been expanded.
The biggest block of code is e(t), which expands the hydra. Here is how it works: it checks if the rightmost head (which it will chop off) has label zero. If it does, then it calls s(t), splicing the last item in the array, and checks if l(t)>1, i.e. the rightmost head's parent is not the root. If it is, then it uses a for loop to push n copies of the rightmost head's parent (which is not the root).
Next, if it is not zero, it checks if it is a positive integer. If it is, it uses a for loop to find i such that t[i] has a lower label than the rightmost head. Then it creates a tree s such that everything after (and including) t[i] is in s, i.e. the subtree rooted at t[i]. It also creates sa where the rightmost head is relabeled with sa[i]-1 and the rightmost head of sa is relabeled with 0. It then deletes t's rightmost head and uses a for loop to insert sa into t.
If it is not zero, then it can only be the least limit ordinal omega (represented by the string "w"). If it is, it simply relabels it with n+1. After everything, it increments n by 1 and returns the new version of t.
Next, we have the function b(n), which represents the function BH(n). It sets i to the tree [+,0] and then pushes n-2 copies of omega "w". It then repeatedly applies e to i (expands i) and returns the final output. My large number is then b(b(b(n)))
Size
Why does this produce a large enough number? Well, the original inventor, Wilfried Buchholz, proved that this function eventually dominates (overtakes) any function which is provably total in \$\Pi^1_1\$-comprehension with bar induction (\$\Pi^1_1-CA+BI\$), so the \$BH(n)\$ function is commonly approximated to \$\psi_0(\varepsilon_{\Omega_\omega +1})\$ using the fast-growing hierarchy, so my number is approximately \$f_{ψ(\varepsilon_{\Omega_\omega+1})+1}(3)\$.
The goal is \$\psi_0(\Omega^{\Omega^\omega \omega})\$, which is much less than \$\psi_0(\varepsilon_{\Omega+1})\$, let alone \$\psi_0(\varepsilon_{\Omega_\omega+1})+1\$. In fact, not only does this number defeat TREE(3), it also defeats SCG(13), which is around \$\psi_0(\Omega_\omega)\$, although it still falls massively short of Loader's number.
In terms of size, my entry would come second place, while in terms of length, it would come second-to-last. The latter is what matters more, so this is probably a really bad entry.

Hello again!  I'm noticing that you format most your math in terms of unicode characters. You can use tex here, anything in between \$ and \$ will be rendered as tex.  Also if you'd like to chat about googology on this site I've set up a room for it.  If you are looking for more challenges about big numbers I suggest looking at the [tag:busy-beaver] tag.

Oh, I didn't know you could use TeX, thanks for letting me know. And I will take a look at the busy-beaver tag, thanks for pointing me to it.

JavaScript, 190 bytes, Hψ(εΩ+1)(9)Based off of this analysis
A=[0,1,2];B=[0,1,2];for(F=C=9;F;F--){for(C++,G=0;G<=F;G++)(A[F]||A[F-G]<A[F]-H)&&(B[F]?(I=G,G=F):(H=A[F]-A[F-G],B[F-G]<B[F]&&(I=G,G=F)));for(J=0;J<C*I;J++)A[F]=A[F-I]+H,B[F]=B[F-I],F++;H=0}C

This program is a modified version of this 225B Pair-sequence number translation in JavaScript. For Pair-sequence number and their original code, see here.
The modifications done:

It is in JavaScript instead of BASIC.
No iteration(fψ(Ωω+1)->fψ(Ωω))
The sequence is (0,0)(1,1)(2,2), which corresponds to ordinal ψ(εΩ+1).This is in Hardy-hierarchy ordinal

Python, 359 (184 without whitespace) 224 212 bytes, ~$$H_{ψ(ψ_Ι(0))[7]}(8)$$
*S,n=0,2,9
while S:
 i=r=d=0
 for a in S[::-1]:
  i-=1
  if d<S[-1]-a:
   r=r or i;d+=S[-1]-a-d>1
   if[k+d for k in S[i:]]<S[r:]:break
   p=i+1
 S.pop();n*=n
 if r:S=S[:p]+[d*i+k for i in range(n)for k in S[p:]]

I'm new to codegolf so I'm not sure if all the whitespace here counts. If not, this entry isn't the shortest entry, but vastly dominates patcail's entry in size.
The code here implements Sudden Sequence System (definition here), which is known to have a perfect correspondence to ordinals below $$\psi(\psi_I(0))$$ represented in Extended Weak Buchholz function. The original idea uses sequences lexicographically less than (0,2) to represent ordinals, but to save characters the sequence itself is reversed.
There are actually a few open problems here that we don't know the answer to, but strongly suspect they are true:

Does the limit of Extended Weak Buchholz function equal to limit of Extended Buchholz function?
Is Sudden Sequence System terminating?
Does the correspondence between the two systems hold?

Edit 1:
It's broken due to a silly mistake. Now S is correctly initialized.
Thanks to Naruyoko for a few great optimizations.
Edit 2: Optimized a bit

Hi, welcome to code golf. Nice answer, looks good (I'm not on the laptop to test it out). Take your time reading the Welcome to Code golf if you haven't done so already. Btw, replace spaces with tabs to get shorter. There is also a Python tips page here, you could read it too, if you're interested.

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/


text:
Generate every ASCII string
Description
There are an infinite number of ASCII strings. Write a program that will output every possible ASCII string exactly once.
The ordering does not matter, but you must be able to show that for any possible ASCII string s, there exists an integer n such that s is the nth string in the output. This restriction means that you cannot output 'a', 'aa', 'aaa', 'aaaa', ..., since the string 'b' will never occur.
The simplest ordering (shown here in terms of letters so I don't have to type unprintables) is:
'', 'a', 'b', 'c', ..., 'z', 'aa', 'ab', ..., 'az', 'ba', 'bb', 'bc', ... 'zz', 'aaa', ...

Essentially, this is counting in base 128 using ASCII characters.
Rules

The empty string is required
You may use any valid ordering you want
All possible strings using ASCII must be known to occur in the output
The ordering does not need to be deterministic, as long as you can show that every string will be guaranteed to occur. Be careful if you use randomness for each string, because at some point your bits of entropy may not be enough to guarantee a unique string.

Example orderings
Note that, again, I'm showing only letters for the examples, but you have to include all ASCII characters.
Valid:
'', 'a', 'b', 'c', ..., 'z', 'aa', 'ab', ..., 'az', 'ba', 'bb', 'bc', ... 'zz', 'aaa', ...

'', 'z', 'y', 'x', ..., 'a', 'zz', 'zy', ...

'', 'a', 'b', 'ab', 'ba', 'c', 'ac', 'ca', 'bc', 'cb', ...

Invalid:
'', 'a', 'aa', 'aaa', 'aaaa', 'aaaaa', ...

'', 'a', 'ab', 'abc', 'abcd', ..., 'abc...xyza', ...

This means only printable ascii right?

I actually intended this to be all ASCII.

uhhh should I repr before printing or something?

It's up to you. Maybe for testing purposes. Defining a Python generator expression would also be acceptable.

Related, maybe dupe. In fact, I think a past challenge to output all ASCII strings was closed as a dupe.

*bijective base 128

Can we output the string in bytes (i.e. in Python b'\x01') or must we print the actual character?

It would have been better to use only printable ASCII. It's difficult to output non-printable chars and check they are the correct ones

@xnor Ah. Yeah maybe a dupe. I searched for a good while looking for potential dupes, and I couldn't find that challenge.

And now find a program doing this by Gödel numbering :)

SOGL V0.12, 10 bytes
]¶tēN»─{Rt

Try it Here!
Note that this spams the stack with an extra item every iteration, and with how slow SOGL is, it gets out of hand quickly.

Python 2, 69 62 bytes
a=0
while 1:
 k=a
 while k:print chr(k%128),;k>>=7
 print;a+=1

-7 bytes thanks to @notjagan
Try it online!

-7 bytes.

Proton, 96 bytes
i=0
(p=print)()
while++i for j:cartesianpower(i,0..128)p(j is tuple? ''.join(map(chr,j)):chr(j))

Try it online!

I am sure there's some way to print an empty line that's shorter than (p=print)() but I can't find it if there is

Pyth - 12 bytes
.Vj^sCMS127b

Finite version online.

Ruby, 64 bytes
(f=->a{f[a.flat_map{|s|puts s;(1..127).map{|b|s+b.chr}}]})[['']]

Recursive function that prints the array a then calls itself on a newly constructed array whose contents are (in set notation) { sc | s in a, c in ASCII }. We kick it off with an array containing the empty string.

Mathematica, 44 41 61 bytes
Crossed out 44 is still regular 44...
0//.i_:>(Print@@@Array[FromCharacterCode,128,0]~Tuples~i;i+1)

Prints in the pattern:  "", "a", "b", ... , "z", "aa", "ab", ... , "az", "ba", "bb", ... , "zz", "aaa", "aab", ... (but with \00, \01, ...).
Try it on Wolfram Sandbox
Unfortunately, I could not use the built-in CharacterRange function (which would have reduced 10 bytes) because it cannot generate the null character.

I recommend testing with the version that pauses 0.25 sec between each Print calls:
0//.i_:>((Pause[0.25];Print@##)&@@@Array[FromCharacterCode,128,0]~Tuples~i;i+1)

Python 3, 103 78 bytes
n=0
while 1:print(n.to_bytes(n.bit_length()+7>>3,"big").decode());n+=n+1&128|1

Try it online!


text:
Real base conversion
We've had a few challenges for base conversion, but all of them seem to apply to integer values. Let's do it with real numbers!
The challenge
Inputs:

A real positive number x, expressed in base 10. This can be taken as a double-precision float or as a string. To avoid precision issues, the number can be assumed to be greater than 10−6 and less than 1015.
A target base b. This will be an integer from 2 to 36.
A number of fractional digits n. This will be an integer from 1 to 20.

Output: the representation of x in base b with n fractional digits.
When computing the output expression, the digits beyond the n-th should be truncated (not rounded). For example, x = 3.141592653589793 in base b = 3 is 10.0102110122..., so for n = 3 the output would be 10.010 (truncation), not 10.011 (rounding).
For x and b that produce a finite number of digits in the fractional part, the equivalent infinite representation (truncated to n digits) is also allowed. For example, 4.5 in decimal can also be represented as 4.49999....
Don't worry about floating point errors.
Input and output format
x will be given without leading zeros. If x happens to be an integer you can assume that it will be given with a zero decimal part (3.0), or without decimal part (3).
The output is flexible. For example, it can be:

A string representing the number with a suitable separator (decimal point) between integer and fractional parts. Digits 11, 12 etc (for b beyond 10) can be represented as letters A, B as usual, or as any other distinct characters (please specify).
A string for the integer part and another string for the fractional part.
Two arrays/lists, one for each part, containing numbers from 0 to 35 as digits.

The only restrictions are that the integer and fractional parts can be told apart (suitable separator) and use the same format (for example, no [5, 11] for the list representing the integer part and ['5', 'B'] for the list representing the fractional part).
Additional rules

Programs or functions are allowed, in any programming language. Standard loopholes are forbidden.
Shortest code in bytes wins.

Test cases
Output is shown as a string with digits 0, ..., 9, A, ... , Z, using . as decimal separator.
x, b, n                    ->  output(s)

4.5, 10, 5                 ->  4.50000 or 4.49999
42, 13, 1                  ->  33.0 or 32.C
3.141592653589793, 3, 8    ->  10.01021101
3.141592653589793, 5, 10   ->  3.0323221430
1.234, 16, 12              ->  1.3BE76C8B4395
10.5, 2, 8                 ->  1010.10000000 or 1010.01111111
10.5, 3, 8                 ->  101.11111111
6.5817645, 20, 10          ->  6.BCE2680000 or 6.BCE267JJJJ
0.367879441171442, 25, 10  ->  0.94N2MGH7G8
12944892982609, 29, 9      ->  PPCGROCKS.000000000

Let us continue this discussion in chat.

for 42, 13, 1 can we have 33 instead of 33.0?

@LiefdeWen No, an essential part of the challenge is that the output must have n decimal digits

Jelly, 16 bytes
*×⁵b⁸ḞðṖḣ⁹,ṫø⁹N‘

Try it online!
Note that singletons are printed as the element in the output.

Hey, what happened to your picture?

@LuisMendo some people cannot render it, since it was connected to Facebook

You know you can upload a picture here, right? Those default ones are so impersonal

JavaScript (ES8), 81 74 71 bytes

f=
(x,b,n,g=x=>x.toString(b))=>g(x-x%1)+'.'+g(x%1).substr(2,n).padEnd(n,0)

<input id=x><input type=number min=2 max=36 value=10 id=b><input type=number min=1 max=20 value=10 id=n>

Works for x between 1e-6 and 1e21, b from 2 to 36 (exactly as required) and n from 1 to anything from 10 to 48 depending on the base before floating-point errors creep in. Edit: Saved 7 bytes with help from @Birjolaxew. Saved a further 3 bytes with help from @tsh. Previous 74-byte version also worked with negative numbers:

f=
(x,b,n,[i,d]=`${x.toString(b)}.`.split`.`)=>i+`.`+d.slice(0,n).padEnd(n,0)

<input id=x><input type=number min=2 max=36 value=10 id=b><input type=number min=1 max=20 value=10 id=n>

How does one do base conversion with regex?!?

@EriktheOutgolfer I'm not, it's just a golfier (hopefully) way of extracting up to n "digits" from a string.

Then what is the core logic of your function?

@EriktheOutgolfer Why, JavaScript's built-in base conversion function of course. (Hint: look at where I use the base parameter.)

Oh it says .toString(b)...dumb me >_<

-1 bytes by using \. instead of [.]. -4 bytes by using .split instead of .match.

@Birjolaxew \. doesn't work because it's a string not a regex but I love your idea of appending a .! (You missed some extra savings though.)

@Neil Ah right, my mistake. Good catch on those extra savings - I always forget that you can .split\`` (what even is that anyway :P )

Clever use of $ .split() rather than standard .split(). Otherwise you have to do a short circuit trick and end up gaining one character:
f=(r,b,n,[i,d]=r.toString(b).split.)=>i+'.'+(d||'0').slice(0,n).padEnd(n,0)

(x,b,n,g=x=>x.toString(b))=>g(x-x%1)+'.'+g(x%1).slice(2,n+2).padEnd(n,0)

@tsh Nice but you forgot to use substr.

Python 2, 153 149 144 137 135 109 bytes
def f(x,b,m):
 i=int(x);s=[];t=[]
 while i:s=[i%b]+s;i/=b
 while m:m-=1;x=x%1*b;t+=[int(x)]
 return s or[0],t

Hadn't noticed I can just return the digits as numbers, so that makes it a lot simpler. Returns two lists of digits, first for the integer part, second for the fractional.
Try it online!

In case it helps: I've added a note that you only need to support numbers greater than 1e-6 (and less than 1e15, as before)

Perl 6, 25 bytes
->\x,\b,\n{+x .base(b,n)}

Try it
Expanded:
-> \x, \b, \n {
  +x            # make sure it is a Numeric
  .base( b, n ) # do the base conversion
}

Note that the space is so that it is parsed as (+x).base(b,n)
not +( x.base(b,n) ).

In case it helps: I've added a note that you only need to support numbers greater than 1e-6 (and less than 1e15, as before)

Ruby, 45 bytes
->x,b,n{(x*b**n).round.to_s(b).insert(~n,?.)}

Why?
Since b^n in base b is 10^n, we multiply x by that number, and then add the decimal point where it belongs.
Try it online!

-1 byte + bugfix by replacing .round with .to_i; this fixes the last digit of the output for ones where it doesn't match the test outputs. -1 more byte by using .insert ~n,?., without parenthesis.

Mathematica, 158 bytes
since this challenge allready got a very nice answer in mathematica by @KellyLowder, I tried to produce (with a different approach) the exact results as shown in the test cases
ToUpperCase[""<>Insert[StringReplace[ToString@BaseForm[#,p]&/@PadRight[#&@@(d=RealDigits[#,p=#2]),w=(#3+d[[2]])][[;;w]],"\n "<>ToString@p->""],".",d[[2]]+1]]&

input

[12944892982609, 29, 9]

output

PPCGROCKS.000000000

C (gcc), 157 152 bytes
Needs 64 bits long int for this to work with larger test cases.
-5 bytes thanks to Peter Cordes
#define P r=99;i=l=x;do{z[--r]=48+7*(l%b>9)+l%b;}while(l/=b);printf(z+r)
long i,r,l;char z[99];f(x,b,n)double x;{P;putchar(46);while(n--){x=(x-i)*b;P;}}

Try it online!
edit: a few bytes can be shaved if it's allowed to output two strings separated by a newline separator:
149 bytes:
#define P r=99;i=l=x;do{z[--r]=48+7*(l%b>9)+l%b;}while(l/=b);printf(z+r)
long i,r,l;char z[99];f(x,b,n)double x;{P;puts("");while(n--){x=(x-i)*b;P;}}

edit: this submission is not the longest one, yay!

You can use printf(z+r) if it doesn't contain any % characters.  (This is code-golf; security and good practices go out the window :P).  You could also use puts(z+r) to get a newline for free (saving the puts("") in the second version).

Thanks! I forgot about providing a char* directly as a pattern, this indeed saves quite a few bytes :-)
I cannot use puts(z+r) in the second version since that would mean each decimal will be printed on a newline

Ah, that last part wasn't obvious without an ungolfed version with comments.

float is shorter than double, but it seems the question does require a double or string input.

Using floats produce erroneous results, especially for the last test case.
Also, to handle 10^15 numbers, if I strictly follow C standards, then I should use long long integers. Here I'm just taking advantage of 64 bits compilers ;-)

I was just thinking of taking full advantage of the "Don't worry about floating point errors." in the question.  Of course it reduces precision a lot. :P  Anyway, good point that this isn't just C, it's "C with 64-bit long", which is fine as long as you say so in the answer.  Note that gcc targeting the 64-bit Windows ABI has 32-bit long, because it's a feature of the ABI, not up to the compiler.  (So "gcc" doesn't imply 64-bit long)

Thinking about it, using "64 bits long integers" makes no sense at all and this cannot be justified. I'll edit my answer right now and define proper long long ints.

No need for that.  Some common implementations of C do have 64-bit long, and according to code-golf rules that's all you need for your answer to be valid.  (Also, it's common for C and C++ code-golf answers to assume 64-bit long, since that's what Try It Online uses.)  I'd suggest rolling back your edit, and just adding a note like "long must be 64-bit for this to support the larger test-cases."

SageMath, 68 bytes
def f(n,b,k):y=n.str(b).split('.')+[''];return y[0],(y[1]+'0'*k)[:k]

Try it online!

In case it helps: I've added a note that you only need to support numbers greater than 1e-6 (and less than 1e15, as before)

Mathematica 47 Bytes
TakeDrop@@r[#,#2,#3+Last@(r=RealDigits)[#,#2]]&

Calling RealDigits twice to first figure out the number of digits to the left of the decimal.

In case it helps: I've added a note that you only need to support numbers greater than 1e-6 (and less than 1e15, as before)

I thought the question was just asking for TakeDrop@@RealDigits[##]& but then I realized I had misread things - your solution seems optimal.

Haskell, 188 bytes
f=fromIntegral
g 0 _=[]
g n p=g(div n p)p++[mod n p]
z=(!!)(['0'..'9']++['A'..'Z']++['.'])
h x p l|(i,d)<-properFraction x=z<$>(g i p++[36]++(last$g(floor$d*(f p**f l))p:[0<$[1..l]|d==0]))

Try it online!
g converts a number to a list representing that number in a given base
z maps integers to letters (36 = .)
h applies the previous functions to the integer and fractional part of a number.

Axiom, 127 bytes
g(a)==floor(a)::INT;f(a:Float,b:PI,n:NNI):Any==(b<2 or n>28=>%i;x:=g(a);radix(x,b)+radix(g((a-x)*b^n),b)::RadixExpansion b/b^n)

results
(4) -> f(%e,2,10)
   (4)  10.1011011111
                                                   Type: RadixExpansion 2
(5) -> f(%e,3,10)
   (5)  2.2011011212
                                                   Type: RadixExpansion 3
(6) -> f(%e,35,10)
   (6)  2.P4VBNEB51S
                                                  Type: RadixExpansion 35
(7) -> f(1.4,35,10)
   (7)  1.DYYYYYYYYY
                                                  Type: RadixExpansion 35
(8) -> f(%pi,3,8)
   (8)  10.01021101
                                                   Type: RadixExpansion 3
(9) -> f(%pi,5,10)
   (9)  3.032322143
                                                   Type: RadixExpansion 5
(10) -> f(1.234,16,12)
   (10)  1.3BE76C8B4395
                                                  Type: RadixExpansion 16

It has a little problem for final zero example
 f(4.5,10,5)

Would return '4.5' and not '4.50000'

Axiom, 566 bytes
c:=alphanumeric()::List Character
f(a:INT,b:PI):List Character==(r:=[];repeat(y:=a rem b;r:=cons(c.(y+1),r);a:=a quo b;a=0=>break);r)
g(x)==floor(x)::INT
F(x)==>for i in 1..#x repeat z:=concat(z,x.i)
w(a:Float,b:PI,n:NNI):String==
  z:="";b<2 or b>36 or a<0=>z
  ip:=g(a);    fp:=g((a-ip)*b^n)
  ipb:=f(ip,b);fpb:=f(fp,b);cnt:=n-#fpb
  for i in 1..cnt repeat fpb:=cons(c.1,fpb)
  F(ipb);z:=concat(z,".");F(fpb)
  z

h(a,b,n)==>(n>=0 and b>0=>(nd123:=10+g(n*log_2(b)/log_2(10));mxv123456:=digits(nd123::PI);res78484:=w(a,b,n);digits(mxv123456);res78484);"")

it was particular difficult this question; afther some time in write something, the right results it seems
generate using one macro for preserve digits()... it is not golfed too much...results:
(7) -> h(4.5,10,5)
   (7)  "4.50000"
                                                             Type: String
(8) -> h(42,13,1)
   (8)  "33.0"
                                                             Type: String
(9) -> h(%pi,3,8)
   (9)  "10.01021101"
                                                             Type: String
(10) -> h(%pi,5,10)
   (10)  "3.0323221430"
                                                             Type: String
(11) -> h(1.234,16,12)
   (11)  "1.3BE76C8B4395"
                                                             Type: String
(12) -> h(0.367879441171442,25,10)
   (12)  "0.94N2MGH7G8"
                                                             Type: String
(13) -> h(12944892982609,29,9)
   (13)  "PPCGROCKS.000000000"
                                                             Type: String
(14) -> h(6.5817645,20,10)
   (14)  "6.BCE267JJJJ"
                                                             Type: String

the real target is one function that convert to base 2..36 each Float
[that has k:=digits()] or each calculated number as %pi or %e or the division of
two float/int as in 1./3. ['oo' digits]
(15) -> h(%pi,13,800)
   (15)
  "3.1AC1049052A2C77369C0BB89CC9883278298358B370160306133CA5ACBA57614B65B410020
  C22B4C71457A955A5155B04A6CB6CC2C494843A8BBBBA9A039B77B34CB0C036CAC761129B3168
  B8BAB860134C419787C911812985646C7AAA3025BAA118B3AB8265CB347852065667291482145
  6C533447BC53A5262177C9985455C395626091A2CC3126B395C91B65B654A1804226197528410
  29A8A4A55CC7937B347B77B5A914127B11C6A57A84510775A9A467819A468B6B74339CC1290B2
  24921C6A771BC2AB6AB41735119C2231545A86399483119AAA5AC34B46B7B5C9089946A364860
  9B26CB0BAC0ABCBA182C12881933AA93C3942C71AA664753989A3C82166BA2109796C4A134607
  59725A72C9117AC980556A147557C319438287226C94725B125753B009387A48AA45CB1960A04
  A064052C00A6069371949872B14590895C555CB01A39B7589824B8621618A8B1971841201A2AB
  B04B80C7534CC1CB079581491995B46C679555316288C82665645A1A600C1A669B865651B6B842470C018B03C1115B3C4306C015C0B45C"
                                                             Type: String


text:
Reduce string to a snippet of the alphabet
Given a non-empty string consisting of only lower and upper case alphabetical characters and spaces ([a-zA-Z ]), reduce it to a snippet of the alphabet, starting with the first character.
To reduce a string, begin with the first alphabetical character, then remove every character after it that is not the next letter of the alphabet. Continue doing this until you reach the end of the string.
For example codegolf:
Begin with c, remove o as it is not the next letter of the alphabet.
Keep d as it is the next letter of the alphabet, and keep e as it is the next letter too.
Remove g, o, and l, and keep f.
Your final snippet would then be cdef
Rules

Capitalisation should be maintained, so CodEgolF would result in CdEF
Space is not a letter of the alphabet, and thus should always be removed, even if it is the start of the string
Due to the nature of the reduction, the first alphabetical character of the input will always be the first character of the output.
zZ is the last letter of the alphabet. There are no letters after it, the alphabet does not loop.

Test Cases
codegolf -> cdef
CodEgolf -> CdEf
 codeolfg -> cdefg
ProgrammingPuzzles -> P
Stack Exchange -> St
The quick red fox jumped over the lazy brown dog -> Tuvw
Zebra -> Z
Abcdegfhijkl -> Abcdef

Scoring
This is code-golf, so fewest bytes in each language wins!

From the second last test case, i see that if we reach z We just stop, right?

@Mr.Xcoder Correct, see the last point under "Rules"

Please add a test case with a space at the beginning. Like: <space>codegolf

Can I return an array of the output letters?

Can we return the letters separated by a newline or as an array?

@Mr.Xcoder yes you can

JavaScript (ES6), 66 79 68 67 bytes
f=([c,...s],p)=>c?(p?~parseInt(c+p,36)%37:c<'!')?f(s,p):c+f(s,c):''

How?
Testing consecutive letters
Because converting two characters to their ASCII codes would be a rather lengthy operation in JS, we use the following formula instead:
~parseInt(b + a, 36) % 37

Provided that both a and b are in [a-zA-Z ], the above expression equals 0 if and only if a and b are consecutive letters (i.e. consecutive digits in base 36), no matter the case of the characters.
For instance:
~parseInt("Y" + "x", 36) = ~(36 * parseInt("Y", 36) + parseInt("x", 36))
                         = ~(36 * 34 + 33)
                         = -(36 * 34 + 33 + 1)
                         = -(37 * 34)

Formatted and commented
f = ([c,                              // c = current character
         ...s],                       // s = array of remaining characters
                p) =>                 // p = previous matching letter
  c ? (                               // if there's still at least 1 character to process:
      p ?                             //   if p was already defined:
        ~parseInt(c + p, 36) % 37     //     test if p and c are NON-consecutive letters
      :                               //   else:
        c < '!'                       //     test if c is a space character
    ) ?                               //   if the above test passes:
      f(s, p)                         //     ignore c and keep the current value of p
    :                                 //   else:
      c + f(s, c)                     //     append c to the final result and update p to c
  :                                   // else:
    ''                                //   stop recursion

Test cases

f=([c,...s],p)=>c?(p?~parseInt(c+p,36)%37:c<'!')?f(s,p):c+f(s,c):''

console.log(f("codegolf")) // -> cdef
console.log(f("CodEgolf")) // -> CdEf
console.log(f(" codeolfg")) // -> cdefg
console.log(f("ProgrammingPuzzles")) // -> P
console.log(f("Stack Exchange")) // -> St
console.log(f("The quick red fox jumped over the lazy brown dog")) // -> Tuvw
console.log(f("Zebra")) // -> Z
console.log(f("Abcdegfhijkl")) // -> Abcdef

Python 3, 75 85 84 91 81 77 75 bytes
I think this is as short as it can get in Python 3. It can be shortened by a few bytes in Python 2, as shown in Sisyphus' submission.

EDIT: +10 for fixing a bug
EDIT: -1 by fixing another bug
EDIT: +7 for fixing another bug
EDIT: -10 bytes with help from @Ruud
EDIT: -4 bytes since the OP allowed us to output the letters separated by a newline
EDIT: -2 bytes thanks to @Ruud, back to the original byte count!

s=input().strip();k=0
for i in s:
 if(ord(i)-ord(s[0]))%32==k:k+=1;print(i)

Try it online!

I have ideas for improvement, golfing on mobile soon.

81 bytes. Uppercase and lowercase letters conveniently match when modulated by 32

@Ruud Those are exactly the things I was talking about in my comment, editing.

79 bytes

Also, you can probably switch to Python 2 now and save a byte on the print

@Ruud Thanks for all your help. I will keep it in Python 3 though

I am waiting for the downvoter to explain their reasons.

Python 2, 69 bytes
lambda s:reduce(lambda x,y:x+y*((ord(y)-ord(x[~0]))%32==1),s.strip())

Try it online!
A simple reduction of the string. We simply concatenate the next character if and only if (ord(y)-ord(x[~0]))%32==1. Very ugly check - I am sure it can be improved, but I'm not sure how!

Clever solution! Too bad it's Python 2-only :P

You can make it compatible with Python 3 with from functools import*.

@ThomasWard totallyhuman was just telling others how to make it Python 3 compatible. Btw, import functools as f and f. is much longer than from functools import* for sure, even used once. See this thread for more information.

05AB1E, 13 bytes
áćsv¤yìuÇÆiy«

Try it online!
-1 thanks to Adnan

Can you replace ðK by á?

@Adnan I think so...

Brachylog, 15 bytes
;ṢxS⊇.ḷ~sẠ∧Sh~h

Try it online!
This would be 10 bytes: ⊇.ḷ~sẠ&h~h, if it weren't for the fairly uninteresting "strings can start with spaces" constraint.
Explanation
;ṢxS               S is the Input with all spaces removed
   S⊇.             The Output is an ordered subset of the Input
     .ḷ            The Output lowercased…
        ~sẠ          …is a substring of "abcdefghijklmnopqrstuvwxyz"
           ∧
            Sh     The first char of S…
              ~h   …is the first char of the Output

Since this is fairly declarative, this is also really slow.

Well, at least it beats Jelly! And, on the plus side, I don't think you can really outgolf this...

MATL, 18 16 15 bytes
Thanks to Mr.Xcoder for pointing out a mistake, now corrected
Xz1&)"t@hkd1=?@

Letters in the output are separated by newlines.
Try it online! Or verify all test cases (the footer code displays all output letters on the same line for clarity).
Explanation
Xz       % Implicitly input a string. Remove spaces
1&)      % Push first character and then the remaining substring
"        % For each
  t      %   Duplicate previous character
  @      %   Push current character
  h      %   Concatenate both characters
  k      %   Convert to lowercase
  d      %   Consecutive difference. Gives a number
  1=     %   Is it 1?
  ?      %   If so
    @    %     Push current char
         %   End (implicit)
         % End (implicit)
         % Display stack (implicit)

You forgot to remove the spaces when they are at the beginning of the string: Space is not a letter of the alphabet, and thus should always be removed, even if it is the start of the string.

@Mr.Xcoder Thanks! Corrected

Java (OpenJDK 8), 102 101 74 bytes
s->{char c=0;for(char x:s)if(c<1&x>32|~-x%32==c%32)System.out.print(c=x);}

Try it online!
-27 bytes thanks to @Olivier Grégoire

75 bytes: s->{char c=0;for(char x:s)if(c<33&x>33|~-x%32==c%32)System.out.print(c=x);} (with char[] as input).

C# (Mono), 129 107 93 91 87 86 bytes
s=>{var r=s.Trim()[0]+"";foreach(var c in s)if(r[r.Length-1]%32==~-c%32)r+=c;return r;}

Saved 2 bytes thanks to @Mr. Xcoder.
Saved 4 bytes thanks to @jkelm.
Saved 1 byte thanks to @ceilingcat.
Try it online!

Fails on leading spaces

@Mayube Woops didn't see that, fixed.

91 bytes. In C-like languages and Python, (c-1)%32 is ~-c%32

87 bytes You don't need to reassign the trimmed string because of the checks in the for loop

Suggest r=(~r[r.Length-1]+c&31)<1?r+c:r; instead of if(r[r.Length-1]%32==~-c%32)r+=c;

Pyth, 23 22 21 20  bytes
-1 byte indirectly thanks to @Erik the Outgolfer's trick (-Qd).
-1 byte thanks to @Erik the Outgolfer.
VQIqZ%-CNCh-Qd32N=hZ

Try it here.

Pyth, 21 20 18 bytes
ef&qhThQhxGrT0tyr6

Try it here.
Way more efficient 20-byte version:
.U+b?t-CrZ1Creb1kZr6

Try it here.
-1 thanks to Mr. Xcoder (indirectly).

Equivalent: .U+b?tlrreb1rZ1kZrz6 (I think). That trick helped me though.

@Mr.Xcoder If that was an equivalent I could've saved a byte with .U+b?tlrreb1rZ1kZr6 but unfortunately r <str> 6 means A.strip(), not removing non-leading-or-trailing whitespace.

Oh yeah, I didn't see your solution relies on all the spaces being removed (mine doesn't)

@Mr.Xcoder Umm, you should remove all spaces.

No, I shouldn't, since space has an ASCII value of 32, whilst all the letters have > 64, and thus not affecting the functionality. I think this applies to your answer too.

@Mr.Xcoder Hmm, you may be right.

I am quite sure about that, because I am then guaranteed to take the first letter, and thus spaces will always be falsy. It is a pure port of my Python solution.

Let us continue this discussion in chat.

PHP, 64+1 bytes
while($c=$argn[$i++])$c<A||$n&&($c&_)!=$n||(print$c)&$n=++$c&__;

Run as pipe with -nR or try it online.

Apart from the usual tricks: When $c reaches Z, ++$c results in AA,
and &__ keeps that length untouched; so $n will match no further $c.

Haskell, 106 105 97 bytes
import Data.Char
import Data.List
z=ord.toUpper
a%b|z a+1==z b=b|0<3=a
nub.scanl1(%).filter(>' ')

I tried to use fromEnum + char arithmetic instead of importing Data.Char, but that ended up being longer...
Saved 8 bytes thanks to H.PWiz!
Try it online.

102 bytes with filter

Or 100 bytes with Data.List

@H.PWiz Great! Thanks!

Jelly, 17 bytes
ḟ⁶;ð,ŒuṪ€O_/⁼-ð¡/

Try it online!

q/kdb+, 47 45 bytes
Solution:
{10h$({(x;x,y)1=mod[y-last x;32]}/)7h$trim x}

Examples:
q){"c"$({(x;x,y)1=mod[y-last x;32]}/)7h$trim x}"CodEgolf"
"CdEf"
q){"c"$({(x;x,y)1=mod[y-last x;32]}/)7h$trim x}" codeolfg"
"cdefg"
q){"c"$({(x;x,y)1=mod[y-last x;32]}/)7h$trim x}"ProgrammingPuzzles"
"P"
q){"c"$({(x;x,y)1=mod[y-last x;32]}/)7h$trim x}"The quick red fox jumped over the lazy brown dog"
"Tuvw"

Explanation:
Leveraging the mod 32 trick from existing solutions along with converge function. Iterate over the string, if the difference between the last element of the result (e.g. starts with T for "The quick red fox...") and the current character is 1 (after being mod'd with 32), then we add this to the result (hence taking why we take last x), then cast everything back to a string.
{10h$({(x;x,y)1=mod[y-last x;32]}/)7h$trim x} / the solution
{                                           } / lambda function
                                      trim x  / trim whitespace (leading/trailing)
                                   7h$        / cast string to ASCII (a -> 97)
     ({                         }/)           / converge
                    y-last x                  / y is the next item in the list, x contains results so far
              1=mod[        ;32]              / is the result mod 32 equal to 1
       (x;x,y)                                / if false, return x, if true return x concatenated with y
 10h$                                         / cast back to characters

Japt, 18 17 16 bytes
Saved 1 byte thanks to @Shaggy
x
c
Çc %H¥V%H©V°

Test it online!
Was thinking this would be a good bit shorter, but... Such is life...
Explanation
x    First line: set U to the result.
x    Trim all spaces off of the input. Only necessary to remove leading spaces.

c    Second line: set V to the result.
c    Take the charcode of the first character in U.

 Ç   c %H¥ V%H© V°
UoZ{Zc %H==V%H&&V++}   Final line: output the result.
UoZ{               }   Filter to only the chars in Z where
    Zc                   the charcode of Z
       %H                mod 32
         ==V%H           equals V mod 32.
              &&V++      If true, increment V for the next letter.

Shorter than my 28 byte travesty, at least! :D It looks like you can replace rS with x.

C# (.NET Core), 70 60 + 18 bytes
-10 bytes thanks to TheLethalCoder
a=>{var c=a.Trim()[0];return a.Where(x=>x%32==c%32&&++c>0);}

Byte count also includes:
using System.Linq;

Try it online!
1 byte longer (currently) (not anymore) than TheLethalCoder's so posting for the sake of fun. Different approach, with LINQ.
This takes advantage of two C-like features in C# - a character char variable is implicitly behaving the same as an integer int, and boolean AND operator && doesn't execute right operation if left returns a false. Code explanation:
a =>                                  // Take string as input
{
    var c = a.Trim()[0];              // Delete leading spaces and take first letter
    return a.Where(                   // Filter out characters from the string, leaving those that:
               x => x % 32 == c % 32  // it's the next character in alphabet case-insensitive (thanks to modulo 32 - credits to previous answers)
               && ++c > 0             // If it is, go to the subsequent character in alphabet (and this always has to return true)
           );
}

Remove the .ToArray() by returning as an IEnumerable<char> to save bytes.

@TheLethalCoder right, I just saw the comment under the challenge. Thank you!

Perl 5, 30 + 1 (-n) = 31 bytes
/$b/i&&(print,$b=++$_)for/\S/g

Try it online!
How?
/$b/i        # check if this letter equals the one in $b, ignore case
&&(print,    # output it if so
$b=++$_)     # store the next character to find
for/\S/g     # Looping over all non-whitespace characters

Perl 6, 51 bytes
{S:i:g/\s|(\w){}<([<!before "{chr $0.ord+1}">.]+//}

Test it
Expanded:
{  # bare block lambda with implicit parameter $_

  S                          # substitute implicitly on $_, not in-place
  :ignorecase
  :global
  /

    |  \s                    # match any space

    |  (\w)                  # match a word character
       {}                    # make sure $/ is updated (which $0 uses)

       <(                    # ignore everything before this

       [

           <!before "{       # make sure this won't match after this point
             chr $0.ord + 1  # the next ASCII character
           }">

           .                 # any character

       ]+                    # match it at least once

  //                         # remove what matched
}

Note that <!before …> is a zero width assertion

J, partial solution
I'm posting this for feedback and ideas for improvement more than anything else.
It works, but doesn't handle the capitalization and space edge cases, and is already long for J.
First a dyadic helper verb that tells you if the left and right args are alphabetically adjacent:
g=.(= <:)&(a.&i.)  NB. could save one char with u:

Next a verb that removes the first element which is not part of an alphabetic streak starting from the first element:
f=.({~<^:3@>:@i.&0@(0,~2&(g/\))) ::]

Note we use Adverse :: to return the entire argument unchanged if there is no non-streak element found (ie, if the entire argument is a valid alphabetic streak).
Finally, the solution is given by applying f until convergence:
f^:_ 'codegolf'  NB. => 'cdef'

Try it online!

And here is a parsed version of f for easier reading:
           ┌─ ~ ─── {
           │                              ┌─ <
           │                       ┌─ ^: ─┴─ 3
           │                 ┌─ @ ─┴─ >:
       ┌───┤           ┌─ @ ─┴─ i.
       │   │     ┌─ & ─┴─ 0
       │   │     │
       │   └─ @ ─┤     ┌─ 0
── :: ─┤         │     ├─ ~ ─── ,
       │         └─────┤
       │               │     ┌─ 2
       │               └─ & ─┴─ \ ─── / ──── g
       └─ ]

Side Question: why do the box characters not align perfectly when display on SO (they work in my console):

Retina, 76 bytes

^.
$&$&$&¶
{T`@@L@l`@l@l@`..¶
T`l`L`.¶
(.)(.)((¶).*?(\1|\2)|¶.*)
$5$5$5$4

Try it online! Link includes test cases. Explanation:

Delete spaces.
^.
$&$&$&¶

Triplicate the first character and insert a separator.
{T`@@L@l`@l@l@`..¶
T`l`L`.¶

Convert the second and third characters to lower case and increment them. Convert the latter to upper case. These are now the search characters.
(.)(.)((¶).*?(\1|\2)|¶.*)
$5$5$5$4

Try to match either of the search characters. If found, then triplicate the match, which restarts the loop for the next search. Otherwise, just delete the search characters and the rest of the input.

8th, 114 bytes
Code
: z dup n:1+ 32 bor >r "" swap s:+ . ;
: f s:trim 0 s:@ z ( nip dup 32 bor r@ n:= if rdrop z then ) s:each rdrop ;

Explanation
: z             \ n -- (r: x)
                \ print letter and save on r-stack OR-bitwised ASCII code of following letter
  dup           \ duplicate item on TOS
  n:1+          \ get ASCII code of the following letter
  32 bor        \ bitwise OR of ASCII code and 32
  >r            \ save result on r-stack
  "" swap s:+ . \ print letter
;

: f        \ s --
  s:trim   \ remove trailing whitespace
  0 s:@    \ get 1st letter
  z        \ print 1st letter and save on r-stack OR-bitwised ASCII code of following letter
  ( nip    \ get rid of index
    dup    \ duplicate item on TOS
    32 bor \ bitwise OR of current ASCII code and 32
    r@     \ get value stored on r-stack
    n:=    \ compare values to see if letter is printable or not
    if
      rdrop \ clean r-stack
      z     \ print letter and save on r-stack OR-bitwised ASCII code of following letter
    then
  )
  s:each    \ handle each character in string
  rdrop     \ clean r-stack
;

Example
ok> " The quick red fox jumped over the lazy brown dog" f
Tuvw

C (gcc), 79 78 75 70 bytes
c;f(char*s){for(c=0;*s;s++)*s^32&&!c|c==(*s|32)-1?c=32|putchar(*s):0;}

Try it online!

Proton, 59 bytes
Port of the Python 2 submission.
s=>reduce((x,y)=>x+y*((ord(y)-ord(x[-1]))%32==1),s.strip())

Try it online!

Pyth, 15 bytes
eo,}r0NG_xQhNty

Test suite
Unlike all of the other answers, this doesn't stick together the output, it generates all subsequences of the input, and then orders them to put the desired string at the end, and outputs it.

I think you have to check if the first letter of the output is the first letter of the input too. And I think initial order matters.

@EriktheOutgolfer Sorry, are you saying the answer is wrong? I make sure the sequence whose first character is earliest in the input among all subsequence that are in alphabetical is the one sorted to the end. See the test case starting with a space.

Can you add an explanation please? I may have misunderstood or something...