text:
Two-zero-one-five puzzle
Background
This puzzle is a variation on the four fours puzzle (itself the topic of a past question). Like that puzzle, the aim is to find mathematical expressions for different whole numbers, using only four digits and certain mathematical operators. In this case, however, the permitted digits are just 2, 0, 1 and 5. Each must appear precisely once in the solution and in the correct order. Surprisingly many whole numbers can be represented this way. Solvers are encouraged to try solving it by hand first, as it's strangely enjoyable.
Rules
Constants may be constructed from single or multiple digits:

Integers: e.g. 2, 0, 15, etc.
Decimals: e.g. .2, .01, 1.5, etc.
Repeating decimals: e.g. .2~ (=0.222...), .15~ (=0.1555...), 20.15~~ (=20.1515...)

The following unary operations are permitted:

Unary negation: -x
Square root: sqrt(x)
Integer factorial: x!

The following binary operations are permitted:

Standard arithmetic operators: x+y, x-y, x*y and x/y
Arbitrary exponentiation: x^y
Arbitrary roots: rt[x](y) (= x'th root of y)

Task
Your program should print out expressions for as many of the integers between 0 and 100 as it can, and then output the number of expressions it has produced.

The solutions must be printed in order in the format n=[expr].
The expressions must use all the digits 2, 0, 1, 5, once each in that order.
The expressions must be printed using the notation described above. Unnecessary parentheses are permitted but not required, as is whitespace. The order of operator precedence is unary negation, factorial, exponentiation, multiplication/division and addition/subtraction.
The program need not return solutions for all the numbers. A program that simply outputs 0 is therefore valid; however, see the scoring section below.
The program should run in under 15 minutes on a modern computer.

You may write a program or function. The expressions should be printed to STDOUT (or closest alternative). The number of expressions can be printed to STDOUT or returned as an integer. Standard code golf restrictions apply.
Example output
0=2*0*1*5
10=20*1*.5
42=((2+0!)!+1)!/5!
100=20*1*5
4

Scoring
Update: @orlp has noted a flaw in the scoring system. See http://meta.codegolf.stackexchange.com/questions/5106/way-of-salvaging-two-zero-one-five-puzzle-challenge for a discussion of how or whether this should be fixed.
Solutions are scored first by the number of expressions they produce and then by their code length in bytes. Hence, a 1000 byte program that produce 80 results will beat a 100 byte program that produces only 79 (though the latter could easily be extended to include the missing results).
For those who would like a motivating target, below is a lower bound on the number of expressions that can be represented. I don't plan to submit an entry, so it may well be possible to win with less!

 At least 85 (out of 101), though it may well be higher.

Scoreboard
As an extra incentive, here is a summary of the score progression. Whenever you beat the highest score, feel free to add yourself to the top of the table (or ask someone else to).

0 expressions, 1 byte (Pyth): implementation that just outputs 0

Is .20 a permitted constant?

@Luke: yes, though it can also be represented as (.2 + 0) so it doesn't increase expressivity

Is the root function ever necessary in a solution? rt[0](y) is undefined, rt[1](y) is the same as 1*y, and the square root is unlikely to lead anywhere useful, since any factorial is unlikely to be a square number. You could do rt[2](0-1+5), but that's not as useful as 2*0-1+5.... 20th or 3rd roots are even less likely to be useful, and doing roots with decimals will mostly just lead to numbers that are too big.

Remember that the root function handles arbitrary roots, not just integers. For example, rt-.1 is the same as .5^(1/-.1) which is 1024. That said, I know of only two numbers between 0 and 100 which seem to require the use of roots.

@UriZarfaty Care to gives those numbers (not their expressions)?

Also, you didn't give runtime requirements, so I think we'll be likely to see some absolutely ridiculous heat-death combinatorics solution win.

@orlp One of the numbers was 86. Though the program that produced this made a few simplifying assumptions that may be wrong, so there may be other ways of producing it.

@UriZarfaty You can make a well-optimized exhaustive algorithm, prove a  solution is optimal, then dump the combinatorics solution together with the optimal score.

You wouldn't actually be able to state your score, just that you'd won. Still, I'll add a run time restriction, since this clearly isn't  the i tent of the puzzle.

There seem to be 204 distinct sets of constants: https://gist.github.com/orlp/e76014113ab8a2c29589

@orlp Note that leading zeros and fractions greater than zero don't add any expressivity: e.g. 015 = 0 + 15 and 1.5 = 1 + .5.

I tried building a Python program, but I've kept hitting a block where I can't figure out well enough how to generate expressions using permutations or whatever. I just don't have enough experience with that. I you want though, I can write a program that merely prints the solutions I discovered by hand... So far I have found expressions for 37 of the numbers.

@mbomb007 That's totally fine (as long as the program also outputs the number of expressions). I've also added a scoreboard to the question which you can update with your program once you post it.

This isn't directly linked, but I have a program that I'm using to help turn a repeating decimal into a fraction, and it's giving wrong answers sometimes. I think the unreduced numerator is too large by the amount preceding the decimal. Any help? If not, I can use StackOverflow. http://ideone.com/PU6taR

@mbomb007 That's way too complicated. Here's a quick explanation I wrote: https://gist.github.com/orlp/e92b3b7d26ad9b11378e

@UriZarfaty Then there are 99 distinct useful sets of constants: https://gist.github.com/orlp/eb997e49e41878c76d0a

@orlp You realize that's what my program is trying to do, right? I just have gcd stuff to reduce the fractions. If the user wants to see 0.3~ you don't have a b, so do you make b equal 3 also? If b was zero, it'd represent 0.03~...

@orlp Also, my program cannot divide the numbers like in your explanation, else it'll just turn it into a decimal again. I need the numerator and denominator independently, then reduce them with gcd. Maybe I can use the fraction module...?

@mbomb007 Yes, use the fraction module - it's there exactly for this purpose. Once you have a working solution you might be able to golf it out later, but for now just use it.

Do any of the numbers require an irrationial intermediate result?

@UriZarfaty Is "37" the other number that requires root?

@orlp None that I know of, but I haven't proved that.

@kennytm No: 37 = sqrt(2^(0!/.1))+5

@UriZarfaty: Ok. I found rt[.2](0!+1) = 32 before that.

@kennytm Wrong again - (20*.1)^5.

@orlp: rt[.2](0!+1) = 32 is a partial solution, and rt[.2](0!+1)+5 = 37 and rt[.2](0!+1)-5 = 27. Note that there is no "5" in rt[.2](0!+1). 2^(0+1*5) = 32.

85, ~2400 bytes
I'm a bit sad this is a code golf challenge, as I feel that all my previous efforts have been rather useless now that I'll post this:
  0 = ((2*0)^15)
  1 = ((2^0)^15)
  2 = (2-(0^15))
  3 = (20*.15)
  4 = (20*(1/5))
  5 = (20-15)
  6 = ((.20+1)*5)
  7 = ((20*.1)+5)
  8 = (2*((0-1)+5))
  9 = ((.20/.1~)*5)
 10 = (20/(1/.5))
 11 = ((((2-0)+1))!+5)
 12 = (20*(.1+.5))
 13 = ((-(2)-0)+15)
 14 = (20-(1+5))
 15 = ((2*0)+15)
 16 = ((2^0)+15)
 17 = ((2-0)+15)
 18 = (20-(1/.5))
 19 = (20-(1^5))
 20 = (20^(1^5))
 21 = (20+(1^5))
 22 = (20+(1/.5))
 23 = (((2-0)/.1~)+5)
 24 = ((20-1)+5)
 25 = ((20^1)+5)
 26 = ((20+1)+5)
 27 = (rt[.2](((0)!+1))-5)
 28 = (2*(-((0)!)+15))
 29 = ((((2+(0)!)+1))!+5)
 30 = ((2-0)*15)
 31 = (20+sqrt((1+(5)!)))
 32 = ((20*.1)^5)
 33 = ((.2^-((0)!))/.15~~)
 34 = (2+(((0)!+1)^5))
 35 = (20+15)
 36 = (20*(1/.5~))
 37 = (rt[.2](((0)!+1))+5)
 38 = ((20-1)/.5)
 39 = (-((2^0))+(sqrt(.1~)*(5)!))
 40 = (20*(1/.5))
 41 = (((.2~^-((0)!))/.1~)+.5)
 42 = ((20+1)/.5)
 43 = (-(2)+(((0)!/.1~)*5))
 44 = (20+((-(1)+5))!)
 45 = (20/(1-.5~))
 46 = ((.2+((0)!/.1~))*5)
 47 = (2+(((0)!/.1~)*5))
 48 = (2*(((0-1)+5))!)
 49 = ((((2+(0)!))!/.1~)-5)
 50 = (((2^0)/.1)*5)
 51 = ((.2+((0)!/.1))*5)
 52 = (2+(((0)!/.1)*5))
 54 = (((2+(0)!)/.1)/.5~)
 55 = ((2+((0)!/.1~))*5)
 56 = (((.2-(0)!)+sqrt(.1~))*-((5)!))
 58 = (-(2)+sqrt((((((0)!/sqrt(.1~)))!)!*5)))
 59 = ((((2+(0)!))!/.1~)+5)
 60 = (20/(.1~^.5))
 62 = (2*(-((0)!)+sqrt(rt[-(.1)](.5))))
 64 = ((2-0)^(1+5))
 65 = ((20/sqrt(.1~))+5)
 66 = ((-(((2+(0)!))!)/.1~)+(5)!)
 67 = (((((2+(0)!))!)!*.1)-5)
 69 = ((2^(((0)!/sqrt(.1~)))!)+5)
 70 = (((.2^-((0)!))/-(.1))+(5)!)
 72 = ((2+(0)!)*((-(1)+5))!)
 75 = ((.2^-((0)!))*15)
 76 = (rt[(-(2)^-((0)!))](.1~)-5)
 77 = (((((2+(0)!))!)!*.1)+5)
 78 = (2*(-((0)!)+(sqrt(.1~)*(5)!)))
 80 = (-(20)*(1-5))
 81 = (201-(5)!)
 82 = (2*((0)!+(sqrt(.1~)*(5)!)))
 84 = (((.2-(0)!)+.1)*-((5)!))
 85 = (((((2+(0)!))!)!*.1~)+5)
 86 = (rt[(-(2)^-((0)!))](.1~)+5)
 88 = (rt[.2]((-((0)!)-1))+(5)!)
 90 = ((20/.1~)*.5)
 93 = (((2+(0)!)/-(.1~))+(5)!)
 95 = ((20-1)*5)
 96 = ((.20-1)*-((5)!))
 98 = (-(20)*(.1-5))
 99 = ((-(20)-1)+(5)!)
100 = (20/(1/5))
85

From here on it's just a compression challenge. Maybe I'll compete later, maybe I won't. For me most of the fun was in the challenge to find the most formulas.
A hint for those struggling to write a solver - runtime shouldn't be a problem. If you have too many formulas to check you need better heuristics to throw away hopeless solutions and duplicates. The code I wrote to generate the above runs in ~5 sec on Python.

rt.1 is the 0.1th root of -0.5, not the -0.5th root of 0.1.

Also, I'm beginning to suspect that the winner may well be a compressed text output. Should have thought of a better way to avoid that :-(

@UriZarfaty Oh, I'll fix that in my code and re-run, give me one second.

I'd significantly overestimated how big the output would be compared to program size. Given the small range of characters and superfluous parentheses, I'm guessing the solution will actually compress rather too well.

@UriZarfaty I had an idea for an encoding myself that would end up being around 500 bytes.

Out of curiosity, do you think the code golf aspect is salveagable without being unfair to anyone who's started solving the puzzle in good faith?

@UriZarfaty Post it on the meta I'd say.

@UriZarfaty My biggest problem with questions such as these being golf questions is that the solutions are too big. Sure, I could probably write a <500 byte solution in Pyth, but the amount of headaches it would give me would make it no longer be enjoyable.

I've posted http://meta.codegolf.stackexchange.com/questions/5106/way-of-salvaging-two-zero-one-five-puzzle-challenge.

I salute you @orlp. By hand I "only" got 63 and funnily enough, a lot of my answers differ from yours :)

Can you share your Python generation code?

@mbomb007 I made no attempts to clean it up whatsoever, and I think the code in the current state is broken - try uncommenting some things: https://gist.github.com/orlp/878da16b5b7c650ebd09 .


text:
Make the largest infinity that you can!

The ordinal number system is a system with infinite numbers. A lot of infinite numbers. So many infinite numbers that it literally does not have an infinity to represent its own infiniteness. The image above gives a little idea of how they work. An ordinal number (Von Neumann construction) is a set of previous ordinals. For example, 0 is the empty set, 1 is the set {0}, 2 is the set {0, 1} and etc. Then we get to ω, which is {0, 1, 2, 3 ...}. ω+1 is {0, 1, 2, 3 ... ω}, ω times two is {0, 1, 2 ... ω, ω + 1, ω + 2...} and you just keep going like that.
Your program will output a set of ordinals, such {0, 1, 4}. Your score will then be the least ordinal more than all the ordinal in your set. For {0, 1, 4} the score would be 5. For {0, 1, 2 ...}, the score would be ω.
How do you output your ordinals you ask. Code of course. Namely, your program will output a potentially infinite list of other programs, in quotes, one on each line (use the literal string "\n" to represent new lines). A program corresponds to its score as indicated above. For example, if you output
"A"
"B"
"C"

where A, B, and C are themselves valid answers and have scores {0, 1, 4}, the score of your program would be 5. Note that A, B, and C, have to be full programs, not fragments.
Based on the above rules, a program that outputs nothing has a score of 0 (the least ordinal greater than all {} is 0). Also, remember a set cannot contain itself, via the axiom of foundation. Namely, every set (and therefore ordinal) has a path down to zero. This means the a full-quine would be invalid as its not a set.
Also, no program is allowed to access outside resources (its own file, the internet etc...). Also, when you list your score, put the cantor normal form of the score alongside it if it isn't in cantor normal form already, if you can (if not, someone else can).
After taking all the above into account, the actual answer you post must be under 1,000,000 bytes (not counting comments). (This upper bound will likely only come into play for automatically generated code). Also, you get to increment your score for each byte you don't use (since we are dealing with infinities, this will probably only come into account when ordinals are very close or the same). Again, this paragraph only applies to the posted answer, not the generated ones, or the ones the generated ones generate, and so on.
This has the quine tag, because it may be helpful to generate at least part of the sources own code, for use in making large ordinals. It is by no means required though (for example, a submission with score 5 would probably not need its own source code).
For a worked out and annotated example, see here.

Does it mean it should not terminate to output infinite number of cardinals? And where is the restricted-source part? I think this tag isn't for code length limitations. Requiring both quoted and newlines converted to \n seemed redundant to me, should other built-in list formats be allowed?

@user23013 It may, at your option, never terminate to output an infinite number of ordinals. Although quoting and escaping newlines is redundant, many languages have built in facilities for just that task. What do you mean by other list formats?

I meant any list or array format recognizable by the used language. Or just make converting \n optional. A quick fix in many languages is to just not use any newlines, though.

@user23013 You mean storing the sources in arrays instead of outputting them? Unless your language doesn't write to stdout, probably not. Also, the quoting and escaping is meant to make it easier. Many languages have this facility, like pythons string.repr, and haskells show.

I meant the string ["...","..."] in python, but now I think it is a bad idea because it is hard to output infinite number of strings. But at least for a single string, many language's that facility outputs a variant of this format, like using single quotes (I think Python does so), or doesn't escape newlines (CJam), or use two consecutive quotes to represent the quote character, or escape many more characters (Bash and Tcl, etc). Should we only use your format?

@user23013 Unless you can't, yes. Besides, unless you want a finite answer, you need infinite outputs, which most languages don't support for lists or arrays.

Should \  be always escaped like \\ , or are they only needed to be escaped if the next character is " or n or \ ?

Image is broken. What does "set cannot can it" mean? "the actual answer you post must be under 1,000,000 bytes" is far weaker than the actual limit, because StackExchange won't allow an answer of more than 30000 characters.

I don't really understand the question, is it about generating programs which generate programs which generate programs etc.?

This kind of question makes me feel like we need a simple.codegolf.se for idiots like me that haven't ever taken above high school maths...

Isn't this in some sense unwinnable?  Whatever the current leader is, I can create a program that prints out her source code, and now I score one point more than her.  Unless we run into the one-megabyte limit... so maybe this is really a Kolmogorov complexity problem in disguise.

Incidentally, a nice little exercise: prove that the score of any program is necessarily a countable ordinal.  This is not quite obvious because there are uncountable ordinals with countable cofinality.  Hint: fhccbfr abg naq pbafvqre gur yrnfg hapbhagnoyr beqvany juvpu pna or fpberq.

@NateEldredge simply printing it won't, since you get +1 points for characters not used.

@PyRulez: Ah, I missed that.  But maybe I can quine it somehow to outscore the current leader by ω.  Must think some more...

@NateEldredge probably. I suspect that the best possible answer is 1,000,000 bytes and is also an incompressible string, and represents an insanely huge ordinal.

@NateEldredge The current leader has been outscored.

@NateEldredge Worded differently, prove that a computable ordinal must be countable.

@NateEldredge While what you say is certainly possible, it is very unsportsman-like, and I will be quite unhappy if that's what you decide to try and do.

@NateEldredge Also, they could do the same to your answer, until you hit the 1,000,000 byte limit.

Why the quine tag when quines are specifically not allowed?

Haskell: ψ(ΩΩω) + 999672 points
main=print$f++shows f"$iterate(Z:@)Z";f="data N=Z|N:@N deriving Show;r=repeat;s Z=[];s(a:@Z)=r a;s(Z:@b)=($u b)<$>h b;s(a:@b)=do(f,c)<-h b`zip`s a;f<$>[c:@b,a]\nh=scanl(flip(.))id.t;t(Z:@Z)=r(:@Z);t(Z:@b)=((Z:@).)<$>t b;t(a:@b)=flip(:@).(:@b)<$>s a;u Z=Z;u(Z:@b)=u b;u(a:@_)=a;g f=mapM_$print.((f++shows f\"$s$\")++).show;main=g"

329 bytes of code with ordinal ψ(ΩΩω) + 1. Uses a tree-based representation of ordinals discovered by Jervell (2005). The tree with children α, β, …, γ is denoted α :@ (β :@ (… :@ (γ :@ Z)…)). This left-to-right order agrees with Jervell, although note that Madore flips it right-to-left.
Haskell: Γ0 + 999777 points
main=print$f++shows f"$iterate((:[]).T)[]";f="data T=T[T]deriving(Eq,Ord,Show);r=reverse;s[]=[];s(T b:c)=(++c)<$>scanl(++)[](b>>cycle[fst(span(>=T b)c)++[T$r d]|d<-s$r b]);g f=mapM_$print.((f++shows f\"$s$\")++).show;main=g"

224 bytes of code with ordinal Γ0 + 1. This is based on a generalization of Beklemishev’s Worm to ordinal-valued elements, which are themselves recursively represented by worms.
Haskell: ε0 + 999853 points
main=print$f++shows f"$map(:[])[0..]";f="s[]=[];s(0:a)=[a];s(a:b)=b:s(a:fst(span(>=a)b)++a-1:b);g f=mapM_$print.((f++shows f\"$s$\")++).show;main=g"

148 bytes of code with ordinal ε0 + 1. This is based on Beklemishev’s Worm. The list
map(+1)α ++ [0] ++ map(+1)β ++ [0] ++ ⋯ ++ [0] ++ map(+1)γ

represents the ordinal (ωγ + ⋯ + ωβ + ωα) − 1. So the second-level outputs [0], [1], [2], [3], … represent 1, ω, ωω, ωωω, …, the first-level output represents ε0, and the initial program represents ε0 + 1.
Haskell: ε0 + 999807 points
main=print$f++shows f"$iterate(:@Z)Z";f="data N=Z|N:@N deriving Show;s Z=[];s(Z:@b)=repeat b;s(a:@Z)=scanl(flip(:@))Z$s a;s(a:@b)=(a:@)<$>s b;g f=mapM_$print.((f++shows f\"$s$\")++).show;main=g"

194 bytes of code with ordinal ε0 + 1.
Z represents 0, and we can prove by transfinite induction on α, then on β, that α :@ β ≥ ωα + β. So there are second-level outputs at least as big as any tower ωω⋰ω, which means the first-level output is at least ε0 and the initial program is at least ε0 + 1.

Nice answer. Do you think you could explain it more? I like your idea of using a well-ordered type.

Specifically, which ordinals is it producing as output?

Also, do you know the Cantor's normal form of these ordinals?

@PyRulez Cantor normal form is not helpful for describing these ordinals. ψ(Ω^Ω^ω), Γ₀, and ε₀ are all epsilon numbers, so while we can write uselessly similar circular equations for their “single-level” Cantor normal form (ψ(Ω^Ω^ω) = ω^ψ(Ω^Ω^ω), Γ₀ = ω^Γ₀, ε₀ = ω^ε₀), we cannot write them as expressions where every exponent is recursively in Cantor normal form.

Hence why you should use a Veblen-like normal form for ordinal collapsing functions :p. As such, you would write Γ₀ = ψ(Ω^Ω) and ε₀ = ψ(0).

Ruby, ψ0(ψX(ψM+1(ΩM+1ΩM+1))(0)) + 999663 points
Assuming I understand my program properly, my score is ψ0(ψX(ψM+1(ΩM+1ΩM+1))(0)) + 999663 points where ψ is an ordinal collapsing function, X is the chi function (Mahlo collapsing function), and M is the first Mahlo 'ordinal'.
This program is an extension of the one I wrote on Golf a number bigger than TREE(3) and utterly trumps all of the other solutions here for now.
z=->x,k{f=->a,n,b=a,q=n{c,d,e=a;!c ?q:a==c ?a-1:e==0||e&&d==0?c:e ?[[c,d,f[e,n,b,q]],f[d,n,b,q],c]:n<1?9:!d ?[f[b,n-1],c]:c==0?n:[t=[f[c,n],d],n,d==0?n:[f[d,n,b,t]]]};x==0??p:(w="\\"*k+"\"";y="";(0..1.0/0).map{|g|y+="x=#{f[x,g]};puts x==0??p:"+w+"#{z[f[x,g],k*2+1]}"+w+";"};y)};h=-1;(0..1.0/0).map{|i|puts "puts \"#{z[[i,h=[h,h,h]],1]}\""}

Try it online!
Ruby, ψ0(ψI(II)) + 999674 points
z=->x,k{f=->a,n,b=a{c,d,e,q=a;a==c ?a-1:e==0||d==0?(q ?[c]:c):e ?[[c,d,f[e,n,b],q],f[d,n,b],c,q]:[n<1?9:d&&c==0?[d]:d ?[f[c,n],d]:[f[b,n-1],f[c,n,b]],n,n]};x==0??p:(w="\\"*k+"\"";y="";(0..1.0/0).map{|g|y+="x=#{f[x,g]};puts(x==0??p:"+w+"#{z[f[x,g],k*2+1]}"+w+");"};y)};h=0;(0..1.0/0).map{|i|puts("puts(\"#{z[h=[h,h,h,0],1]}\")")}

Try it online! (warning: it won't do much, since clearly (0..1.0/0).map{...} cannot terminate. It's how I print infinitely many programs as well.)
Ruby, ψ0(ψI(0)) + 999697 points
z=->x,k{f=->a,n,b=a{c,d,e=a;a==c ?a-1:e==0||d==0?c:e ?[[c,d,f[e,n,b]],d-1,c]:[n<1?9:d&&c==0?[d]:d ?[f[c,n-1],d]:[f[b,n-=1],f[c,n,b]],n,n]};x==0??p:(w="\\"*k+"\"";y="";(0..1.0/0).map{|g|y+="x=#{f[x,g]};puts(x==0??p:"+w+"#{z[f[x,g],k*2+1]}"+w+");"};y)};h=0;(0..1.0/0).map{|i|h=[h];puts|i|puts("puts(\"#{z[hz[h=[h],1]}\")")}

Try it online!
A more reasonable test program that implements (0..5).map{...} instead:
z=->x,k{f=->a,n,b=a{c,d,e=a;a==c ?a-1:e==0||d==0?c:e ?[[c,d,f[e,n,b]],d-1,c]:[n<1?9:d&&c==0?[d]:d ?[f[c,n-1],d]:[f[b,n-=1],f[c,n,b]],n,n]};x==0??p:(w="\\"*k+"\"";y="";(0..5).map{|g|y+="x=#{f[x,g]};puts(x==0??p:"+w+"#{z[f[x,g],k*2+1]}"+w+");"};y)};h=0;(0..5).map{|i|h=[h];puts("puts(\"#{z[h,1]}\")")}

Try it online!
Unfortunately, even with (1..1).map{...}, you will find this program to be extremely memory intensive. I mean, the length of the output exceeds things like SCG(13).
By using the simpler program, we may consider a few values:
a = value you want to enter in.
z=->x,k{f=->a,n,b=a{c,d,e=a;a==c ?a-1:e==0||d==0?c:e ?[[c,d,f[e,n,b]],d-1,c]:[n<1?9:d&&c==0?[d]:d ?[f[c,n-1],d]:[f[b,n-=1],f[c,n,b]],n,n]};x==0??p:(w="\\"*k+"\"";y="x=#{f[x,k]};puts(x==0??p:"+w+"#{z[f[x,k],k*2+1]}"+w+");";y)};puts("puts(\"#{z[a,1]}\")")

Try it online!
It basically prints the same program repeatedly, in the format of:
x=...;puts(x==0??p:"...");

where the initialized x records the ordinal the program is related to, and the "..." holds the programs after x has been reduced. If x==0, then it prints
p

which is a program that prints nothing with a score of zero, hence
x=0;puts(x==0??p:"p");

has a score of 1, and
x=1;puts(x==0??p:"x=0;puts(x==0??p:\"p\");");

has a score of 2, and
x=2;puts(x==0??p:"x=1;puts(x==0??p:\"x=0;puts(x==0??p:\\\"p\\\");\");");

has a score of 3, etc., and my original program prints these programs in the format
puts("...")

where ... are the programs listed above.
My actual program actually prints these programs in the format
x=0;puts(x==0??p:"p;p;p;p;p;...");

Infinitely many times, and for values such as ω, it does something akin to
x=ω;puts(x==0??p:"(x=0 program); (x=1 program); (x=2 program); ...")

And thus, the score of the program
x=(some_ordinal);puts(x==0??p:"...")

is 1+some_ordinal, and the score of
puts("x=(some_ordinal);puts(x==0??p:\"...\")")

is 1+some_ordinal+1, and the score of
z=->x,k{f=->a,n,b=a{c,d,e=a;a==c ?a-1:e==0||d==0?c:e ?[[c,d,f[e,n,b]],d-1,c]:[n<1?9:d&&c==0?[d]:d ?[f[c,n-1],d]:[f[b,n-=1],f[c,n,b]],n,n]};x==0??p:(w="\\"*k+"\"";y="";(0..1.0/0).map{|g|y+="x=#{f[x,g]};puts(x==0??p:"+w+"#{z[f[x,g],k*2+1]}"+w+");"};y)};puts("puts(\"#{z[some_ordinal,1]}\")")

is 1+some_ordinal+2.

Explanation of ordinals:
f[a,n,b] reduces an ordinal a.
Every natural number reduces to the natural number below it.
f[k,n,b] = k-1

[c,0,e] is the successor of c, and it always reduces down to c.
f[[c,0,e],n,b] = c

[c,d,e] is a backwards associative hyperoperation, are reduces as follows:
f[[c,d,0],n,b] = c
f[[c,d,e],n,b] = [[c,d,f[e,n,b]],f[d,n,b],c]

[0] is the first infinite ordinal (equivalent to ω) and reduces as follows:
f[[0],0,b] = [9,0,0]
f[[0],n,b] = [n,n,n]

[c] is the cth omega ordinal and reduces as follows:
f[[c],0,b] = [9,0,0]
f[[c],n,b] = [[f[b,n-1,b],f[c,n,b]],n,n]
Note the two-argument array here.

[c,d] is ψd(c) and reduces as follows:
f[[c,d],0,b] = [9,0,0]
f[[0,d],n,b] = [[d],n,n]
f[[c,d],n,b] = [[f[c,n,c],d],n,n]

[c,d,e,0] is basically the same as [c,d,e], except it enumerates over the operation [c] instead of the successor operation.
f[[c,0,e,0],n,b] = [c]
f[[c,d,0,0],n,b] = [c]
f[[c,d,e,0],n,b] = [[c,d,f[e,n,b],0],f[d,n,b],c,0]

According to the Googology wikia, I is the first inaccessible cardinal, nor first inaccessible ordinal.

@PyRulez Yes, though it makes more sense to have an ordinal here instead of a cardinal. Usually one says that I is the ordinal that relates to the first inaccessible cardinal, just as ω relates to aleph null.

Java + Brainf***, ω+999180 points
A java program that produces infinitely many Brainf*** programs, of which each produces the last as output.
Why? Because I can.
Any improvements to the Brainf*** generation part are definitely welcome.
import java.io.*;import java.util.*;import static java.lang.System.*;
class O{
    static String F(String s){
        String t="++++++++++++++++++++";
        List<Character> c=Arrays.asList('+','-','.','<','>','[',']');
        t+="[->++>++>++>+++>+++>++++>++++<<<<<<<]>+++>+++++>++++++>>++>+++++++++++>+++++++++++++";
        for(int x=0,i=6;x<s.length();x++){
            int d=c.indexOf(s.charAt(x)),k=d;
            while(d>i){d--;t+=">";}
            while(d<i){d++;t+="<";}
            t+=".";i=k;
        }return t;
    };
    static void p(String a){
        int i=48;while(i<a.length()){out.println(a.substring(i-48,i));i+=48;}
        out.println(a.substring(i-48));out.println();
    }
    public static void main(String[]a) throws Exception{setOut(new PrintStream("o.txt"));String b="";while(true)p(b=F(b));}
}

To your taste, of course, but using the real name makes it easier to search. :)

@luserdroog Not true. Since I'm sure you know how to include multiple search terms, it's of equal difficulty to search for BF programs with different namings.

@mbomb007 are you suggesting that typing "brainfuck|brainf*ck|brainfcuk|brainf**k|brainf***|brain****|brainfu*k|..." is of equal difficulty to typing "brainfuck"?

@Sparr StackExchange uses * as a wildcard character, so just type brainf***, or brainf. All of those variations come up in the search results. https://codegolf.stackexchange.com/help/searching

@mbomb007 thanks, I didn't know that

Literate Haskell (GHC 7.10): ω² + 999686 points.
This will serve as an example answer. Since its an example, it only makes sense to use literate programming. It won't score well though.
The birdies will decrease my score, but oh well.
First, let's make a helper function s. If x is an ordinal, s x = x+1, but we find unexpected uses of s.
> s x="main=putStrLn "++show x

The show function luckily does all the string sanitization for us.
Its also worth making 0. Zero is not the successor of anything, but s"" will equal "main=putStrLn """, which equals 0.
> z=s""

Now we will make a function that takes n, and returns ω*n.
> o 0=z
> o n=q++"\nmain=putStrLn$unlines$map show$iterate s$o "++show(n-1)

It works by making ω*n by {ω*(n-1), ω*(n-1)+1, ω*(n-1)+2, ...}.
What is this q? Why, its the reason we have a quine tag. q is the above helper functions so far.
> h x = x ++ show x
> q = h "s x=\"main=putStrLn \"++show x\nz=s\"\"\no 0=z\no n=q++\"\\nmain=putStrLn$unlines$map show$iterate s$o \"++show(n-1)\nh x = x ++ show x\nq = h "

Note that only o n needs q, not any of its successors (s(o(n)), s(s(o(n)))), since they don't need the helper functions (except indirectly from o n.)
Now we only have to output all of ω*n for finite n.
> main=mapM(print.o)[0..]

There we go. ω^2
Having used only 314 code character, I claim a final bonus of 999686, giving me a final score of ω^2 + 999686, which is already in cantor's normal form.
First four lines of output (0, ω, ω*2, ω*3):
"main=putStrLn \"\""
"s x=\"main=putStrLn \"++show x\nz=s\"\"\no 0=z\no n=q++\"\\nmain=putStrLn$unlines$map show$iterate s$o \"++show(n-1)\nh x = x ++ show x\nq = h \"s x=\\\"main=putStrLn \\\"++show x\\nz=s\\\"\\\"\\no 0=z\\no n=q++\\\"\\\\nmain=putStrLn$unlines$map show$iterate s$o \\\"++show(n-1)\\nh x = x ++ show x\\nq = h \"\nmain=putStrLn$unlines$map show$iterate s$o 0"
"s x=\"main=putStrLn \"++show x\nz=s\"\"\no 0=z\no n=q++\"\\nmain=putStrLn$unlines$map show$iterate s$o \"++show(n-1)\nh x = x ++ show x\nq = h \"s x=\\\"main=putStrLn \\\"++show x\\nz=s\\\"\\\"\\no 0=z\\no n=q++\\\"\\\\nmain=putStrLn$unlines$map show$iterate s$o \\\"++show(n-1)\\nh x = x ++ show x\\nq = h \"\nmain=putStrLn$unlines$map show$iterate s$o 1"
"s x=\"main=putStrLn \"++show x\nz=s\"\"\no 0=z\no n=q++\"\\nmain=putStrLn$unlines$map show$iterate s$o \"++show(n-1)\nh x = x ++ show x\nq = h \"s x=\\\"main=putStrLn \\\"++show x\\nz=s\\\"\\\"\\no 0=z\\no n=q++\\\"\\\\nmain=putStrLn$unlines$map show$iterate s$o \\\"++show(n-1)\\nh x = x ++ show x\\nq = h \"\nmain=putStrLn$unlines$map show$iterate s$o 2"

Now go write a serious solution :-)

GolfScript, ε₀+1 + 999537 points
{{
{"{"lib`+"}:lib~~"@++"~"+p}:output;
{{}}:nothing;
{{1{).2$`+output 1}do}}:list;
{{\.(`2$`+" iter"+@`if output}}:iter;
{{1${@`@(2$`{rep~}+++\}{;;}if~}}:rep;
{\`\+}:combine;
{{\@@~}}:swap;
{{1${1$(1$`{rangemap~}+[+@@[\\]]{~}/+}{;;}if}}:rangemap;
{`{}+}:wrap;
}}:lib~~
nothing {iter combine list~} {rep combine} {~swap combine combine} rep combine swap combine combine {~list~} combine rangemap {~~} combine combine swap combine combine swap combine combine list~

It can probably be better, but I became too lazy to debug and prove larger ordinals.
Smaller ordinals
#ω^ω^ω
#nothing {iter combine list~} {rep combine swap combine combine list~} {rep combine swap combine combine swap combine combine list~} rep combine swap combine combine swap combine combine swap combine combine list~
#ω^ω^2
#nothing {iter combine list~} { {rep combine swap combine combine list~} rep combine swap combine combine swap combine combine list~} rep combine swap combine combine swap combine combine list~
#ω^nω
#nothing {iter combine list~} 2 { {rep combine swap combine combine list~} rep combine swap combine combine swap combine combine list~} rep~
#ω^ω
#nothing {iter combine list~} {rep combine swap combine combine list~} rep combine swap combine combine swap combine combine list~
#ω^n
#nothing {iter combine list~} 3 {rep combine swap combine combine list~} rep~
#ω^3
#nothing {{iter combine list~} rep combine swap combine combine list~} rep combine swap combine combine list~
#ω^2
#nothing {iter combine list~} rep combine swap combine combine list~
#nω
#nothing 3 {iter combine list~} rep~
#2ω
#nothing iter combine list combine iter combine list~
#ω
#nothing iter combine list~
#finite
#2 nothing iter~

Javascript (Nashorn), ω2+999807 points
Nashorn is the Javascript engine which comes built into Java. This may also work in Rhino, but I haven't tested it in that yet.
c="(b=function(a){print(a?\"(b=\"+b+\")(\"+(a-1)+\")\":\"c=\\\"(b=function(a){print(a?'(b='+b+')'+'('+(a-1)+')':'')})(\\\";a=0;while(++a)print(c+a+\\\")\\\")\")})(";a=0;while(++a)print(c+a+")")

Is it 2ω or ω²?

@kamoroso94 FYI 2ω = ω.

Okay, ω•2, my bad.

source: Stack Exchange

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

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

sort: votes


text:
Help My Brother Work on his Tan(gent)!
This challenge is entirely fictional. There is no time limit for this challenge.
My little brother is terrible with computers! He saved up all of his money to buy a new one, and within half an hour the hard drive was wiped and the only software left is a lousy BF interpreter. The worst part of it is, he has a huge Geometry test tomorrow and needs help!
The Challenge
There's no way I'm going to let him touch my machine, so I'm going to need a fast way to write BF programs that solve his problem. He's learning about finding the area of regular polygons, and writing a new BF program for every calculation is a massive task. I need a fast way to generate BF programs! That's where you come in...
The Input
Your program or function will receive an integer 2 < N <= 100 which shall represent the number of sides of a regular polygon. You may receive input from function arguments, command line arguments, STDIN, or your language's closest alternative. If necessary, you may additionally require trailing or leading whitespace.
The Output
Your program should generate a separate BF program that takes input of a single positive integer 0 < a <= 10^10 that shall represent the length of the apothem of a regular polygon. When run, the BF program should output the area of a polygon with N sides and an apothem of a. More specifically:

Assume that the BF interpreter is set up such that , takes a number as input and . outputs a value as a number, not a character. An input of 12 does not translate to the characters '1' '2' in memory, rather the literal number 12. Similarly, when a value of 48 is output, it outputs '48', not the character '0'.
Assume also that each value on the tape of the BF program may contain an infinitely large integer -- the value will never wrap to 0.
Assume that the tape of the BF spans infinitely to the right, but has no negative indices. The pointer starts at 0.
My brother is as careless with numbers as he is with computers. As such, the BF code should output the area rounded to the nearest integer.

The Rules
In a separate and unrelated incident, my brother downloaded so much garbage onto my primary programming machine that I have virtually no hard drive space left. As such, your original program may not exceed 512 bytes.
Your score in this challenge is the length of all BF programs generated by your program for values of N from 3 to 100 inclusive.
Standard loopholes are disallowed.

So, you don't allow him to touch your computer, but he somehow clugged up your computer with garbage? Maybe clean it up.

@Bálint If this is not humorous, then you're wrong. He might have installed all that garbage there before bying the new PC.

@EʀɪᴋᴛʜᴇGᴏʟғᴇʀ Don't worry, I was

@Bálint You were wrong or the comment was humorous?

@EʀɪᴋᴛʜᴇGᴏʟғᴇʀ The comment was humorous

@Bálint Typo + Spellchecker = MESS!

Python, 23938 score
from math import*
def apothem(n):
 c=int(n*tan(pi/n)/2*10)

 s=',>' + '+'*c
 m=">[-]>[-]<<[>>+<<-]>>[<<<[>+>+<<-]>>[<<+>>-]>-]<<"*2
 p=">>[-]<[-]<+++++<[-]++++++++++"
 d=">[>+<-]>[<<[>>>+>+<<<<-]>>>>[<<<<+>>>>-]<[>+<<-[>>[-]>+<<<-]>>>[<<<+>>>-]<[<-[<<->>[-]]+>-]<-]<<+>]"
 o="<."
 print s+m+p+d+o

the area of a regular polygon is nsa/2 width n given in Python and a later in BF. s is the sidelength of the polygon, which can be computed from a and n
c is a constant, such that the area is (aac+5)/10, so only this formula must be coded into BF. c is between 15 and 25.
s is the starting point for the BF code: read the apothem and write c
m does c=ca twice, so in the cell formaly holding c there is aac
p prepares for the final operation, clearing temporary cells, adding 5 to aac and setting the first cell to 10
d division
o output

This is my first writing in BF, so all algorithms are from this page.

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


text:
Draw a Random ASCII Art Quilt
For this challenge, an ASCII art quilt will be a block of text 24 characters wide and 18 lines tall, containing the characters =-<>/\ in a quilt-like pattern that is horizontally and vertically symmetrical.
Example quilt:
========================
------------------------
//\\//\\\//\/\\///\\//\\
<<><<>>>>><<>><<<<<>><>>
/\\/\\\\/\/\/\/\////\//\
------------------------
/\/////\\///\\\//\\\\\/\
\///\/\/\\\\////\/\/\\\/
\///\/\/\\\\////\/\/\\\/
/\\\/\/\////\\\\/\/\///\
/\\\/\/\////\\\\/\/\///\
\/\\\\\//\\\///\\/////\/
------------------------
\//\////\/\/\/\/\\\\/\\/
<<><<>>>>><<>><<<<<>><>>
\\//\\///\\/\//\\\//\\//
------------------------
========================

All quilts have the same form:

They are always 24 by 18.
The top line (line 1) and bottom line (line 18) are = all the way across.
Lines 2, 6, 13 and 17 are - all the way across.
Lines 4 and 15 are the same random horizontally symmetric pattern of < and >.
All other lines (3, 5, 7, 8, 9, 10, 11, 12, 14, 16) are filled with / and \ in a completely random way such that the entire quilt remains horizontally and vertically symmetric.

Notice that when folding the quilt exactly in half, either vertically or horizontally, the shapes of the characters exactly match up. Don't get this confused with the characters themselves matching up. e.g. line 3 and line 16 are not identical, they are vertical mirror images.
Challenge
Write a program or function that will print or return a random ASCII art quilt.
Due to the many hardcoded lines and the symmetry, the only real randomness comes from the first 12 characters on lines 3, 4, 5, 7, 8, 9:

The first 12 characters on line 4 should be able to be any length 12 string of the characters < and >.
The first 12 characters on lines 3, 5, 7, 8, 9 should be able to be any length 12 string of the characters / and \ (independent of each other).
These random strings are then mirrored accordingly to make the entire quilt.

The shortest answer in bytes wins. Tiebreaker is earlier post.
You may use pseudorandom number generators. (No, you don't need to prove that all 12 char string of <> or /\ can be generated with you language's PRNG.)
The output may optionally contain a trailing newline, but no trailing spaces or other characters besides what's necessary for the quilt.

can we take input as a random seed?

CJam, 61 60 58 55 54 52 51 bytes
Shortened a bit with some help from Sp3000 and Optimizer.
"=-/</-///"{C*1{"<\/>"%1$W%\_W%er}:F~+mrC<1FN}%s3F(

Test it here.
Explanation
As usual with these symmetric ASCII art challenges, I'm generating one quadrant and then expand it to the full thing by two appropriate mirroring operations.
For this explanation I should start with the function F, which I'm defining somewhere along the way, because it's used in three places for three different things:
{"<\/>"%1$W%\_W%er}:F

This expects an integer on the top of the stack, and a string beneath that. Its purpose is to reverse the string and also swap some characters, to get the mirroring right. The integer is either 1 or 3 and indicates whether (1) both brackets and slashes should be swapped or (3) only brackets should be swapped. Here is how it works:
"<\/>"            "Push a string with all four relevant characters.";
      %           "% applied to a string and an integer N (in any order) selects every
                   Nth character, starting from the first. So with N = 1 this just
                   leaves the string unchanged, but with N = 3 it returns a string
                   containing only < and >.";
       1$         "Copy the string we want to mirror.";
         W%       "% also takes negative arguments. Giving it -1 reverses the string.";
           \_     "Swap the two strings and duplicate the <\/> or <> string.";
             W%   "Reverse that one. Due to the symmetry of this string, we'll now
                   have the characters to be swapped at corresponding indices.";
               er "Perform element-wise transliteration on the reversed input string
                   to complete the mirroring operation.";

Now for the rest of the code:
"=-/</-///"                            "This string encodes the 9 different line types.
                                        Note that for the /\ and <> lines we only use
                                        one of the characters. This idea is due to
                                        Sp3000. Thanks! :)";
           {                   }%      "Map this block onto the characters.";
            C*                         "Repeat the character 12 times, turning it into
                                        a string.";
              1{...}:F~                "Define and call F on the resulting string. The
                                        reversal doesn't do anything, but the character
                                        swapping creates strings containing both \/ and
                                        <>.";
                       +mr             "Add the two halves together and shuffle them.";
                          C<           "Truncate to 12 characters. We've now got our
                                        random half-lines.";
                            1F         "Call F again to mirror the half-line.";
                              N        "Push a newline.";
                                 s     "Join all those separate strings together by
                                        converting the array to a string.";
                                  3F   "Perform one more mirroring operation on the
                                        half-quilt, but this time only swap < and >.
                                        This yields the correct full quilt, except
                                        there are two newlines in the centre.";
                                    (  "This slices the leading newline off the second
                                        half and pushes it onto the stack.";

The two halves and that single newline are then printed automatically at the end of the program.

Python 3, 257 229 192 185 176 149 143 bytes
from random import*
k,*L=80703,
while k:s=eval("''"+".join(sample('--==<>\/'[k%4*2:][:2],2))"*12);L=[s]+L+[s[::(-1)**k]];k//=4
*_,=map(print,L)

With help from @xnor, we've finally caught up with JS!
Sample output:
========================
------------------------
///////////\/\\\\\\\\\\\
>><<<>><<<><><>>><<>>><<
/\/\\/\/\\/\/\//\/\//\/\
------------------------
//\\////\\/\/\//\\\\//\\
/////\\\/\/\/\/\///\\\\\
/\\//\\/////\\\\\//\\//\
\//\\//\\\\\/////\\//\\/
\\\\\///\/\/\/\/\\\/////
\\//\\\\//\/\/\\////\\//
------------------------
\/\//\/\//\/\/\\/\/\\/\/
>><<<>><<<><><>>><<>>><<
\\\\\\\\\\\/\///////////
------------------------
========================

Explanation
(Slightly outdated, will update later)
"444046402" encodes the rows, with each digit referring to the starting index of the relevant 2-char substring of '--==\/<>'. Each individual row is built inside-out via repeated shuffling of the two chars (using sample(...,2), since random.shuffle is unfortunately in-place) and string joining.
A simplified example of what the expansion might look like for the fourth row is:
''.join(['<','>']).join(['>','<']).join(['>','<']).join(['<','>']).join(['>','<'])

which would yield ><>><><<><:
               ''
    <>         .join(['<','>'])
   >  <        .join(['>','<'])
  >    <       .join(['>','<'])
 <      >      .join(['<','>'])
>        <     .join(['>','<'])

The overall quilt is also built inside-out, as construction begins with the 9th/10th rows, working outward. To do this we start with an empty list L, which we add rows to the front and back of as we go via
L=[s]+L+[[s,s[::-1]][n<"5"]]

The n<"5" condition is to check whether we have a row consisting of ><, in which case we append an identical row to the back, otherwise its reverse.
Finally, *_,= is to force the evaluation of map so printing occurs, and is just a shorter way to do print("\n".join(L)).
For a long time I had the function
g=lambda s:s.translate({60:62,62:60,92:47,47:92})

which takes a string and converts /\>< to \/<> respectively, but I've finally managed to get rid of it :)

The spec says as long as it can generate all the possible carpets, it's fine.

Python 2, 300 bytes
This program uses join, lambda, replace, sample, import and other verbose functions, so it will not be winning any golf awards.
from random import*
f=lambda a,b,t:t.replace(a,'*').replace(b,a).replace('*',b)
k=lambda a:''.join(sample(a*12,12))
c='-'*24
e=k('<>')
h=e+f('<','>',e[::-1])
j=[d+f('/','\\',d[::-1])for d in[k('\\/')for i in'quilt']]
g=['='*24,c,j[0],h,j[1],c]+j[2:]
print'\n'.join(g+[f('/','\\',d)for d in g[::-1]])

The code before the auto-golfer got hold of it:
from random import *

change = lambda a,b,t: t.replace(a,'*').replace(b,a).replace('*',b)
pick = lambda a: ''.join(sample(a*12, 12))

innerline = '-' * 24
line4h = pick('<>')
line4 = line4h + change('<', '>', line4h[::-1])
diag = [d + change('/', '\\', d[::-1]) for d in [pick('\\/') for i in 'quilt']]

quilt = ['='*24, innerline, diag[0], line4, diag[1], innerline] + diag[2:]
print '\n'.join(quilt + [change('/', '\\', d) for d in quilt[::-1]])

A sample output:
========================
------------------------
\\\\/\////\\//\\\\/\////
<><<>>>><><><><><<<<>><>
/\\\\////\\\///\\\\////\
------------------------
\\\\//\///\\//\\\/\\////
//\//\\\\/\/\/\////\\/\\
\/\\\\/\//\/\/\\/\////\/
/\////\/\\/\/\//\/\\\\/\
\\/\\////\/\/\/\\\\//\//
////\\/\\\//\\///\//\\\\
------------------------
\////\\\\///\\\////\\\\/
<><<>>>><><><><><<<<>><>
////\/\\\\//\\////\/\\\\
------------------------
========================

Not the shortest, but hey, with 7 more bytes you've got a program worthy of your name :D

I see what you did there.

Auto-golfer? Aint nobody got time for golfing by hand?

You know us hackers. If I have to do a 3 minute task more than once, I will spend 10 hours writing a program to automate it. I am all about efficiency ;-)

PHP, 408, 407, 402, 387, 379 bytes
I am not a good golfer, but this problem sounded fun so I gave it a try.
<?$a=str_replace;$b=str_repeat;function a($l,$a,$b){while(strlen($s)<$l){$s.=rand(0,1)?$a:$b;}return$s;}$c=[$b('=',12),$b('-',12),a(12,'/','\\'),a(12,'<','>'),a(12,'/','\\'),$b('-',12)];while(count($c)<9){$c[]=a(12,'/','\\');}for($d=9;$d--;){$c[$d].=strrev($a(['/','<','\\','>',1,2],[1,2,'/','<','\\','>'],$c[$d]));$c[]=$a(['/','\\',1],[1,'/','\\'],$c[$d]);}echo implode("
",$c);

Ungolfed code
<?php

    function randomString($length, $a, $b) {
        $string = '';
        while(strlen($string) < $length) {
            $string .= rand(0, 1) ? $a : $b;
        }
        return $string;
    }

    if(isset($argv[1])) {
        srand(intval($argv[1]));
    }

    $lines = [
        str_repeat('=', 12),
        str_repeat('-', 12),
        randomString(12, '/', '\\'),
        randomString(12, '<', '>'),
        randomString(12, '/', '\\'),
        str_repeat('-', 12)
    ];
    while(count($lines) < 9) {
        $lines[] = randomString(12, '/', '\\');
    }

    for($index = count($lines); $index--;) {
        $lines[$index] .= strrev(str_replace(['/', '<', '\\', '>', 1, 2], [1, 2, '/', '<', '\\', '>'], $lines[$index]));
        $lines[] = str_replace(['/', '\\', 1], [1, '/', '\\'], $lines[$index]);
    }

    echo implode("\n", $lines) . "\n";

?>

The ungolfed version has a little bonus: You can pass it an integer to seed rand() and get the same quilt each time for a seed:
php quilt.php 48937

This results, for example, in this beautiful, hand woven quilt:
========================
------------------------
/\\\////\\\/\///\\\\///\
><>><>><<<><><>>><<><<><
/\\\///\//\/\/\\/\\\///\
------------------------
/\\/\\\/\\/\/\//\///\//\
/\\\\/\//\\/\//\\/\////\
\/\\/\/\////\\\\/\/\//\/
/\//\/\/\\\\////\/\/\\/\
\////\/\\//\/\\//\/\\\\/
\//\///\//\/\/\\/\\\/\\/
------------------------
\///\\\/\\/\/\//\///\\\/
><>><>><<<><><>>><<><<><
\///\\\\///\/\\\////\\\/
------------------------
========================

Edit: Turns out my first version did not return a correct quilt. So I fixed it. Funny enough, the fix is even shorter.

You can do many things to golf this: ['/','<','\\','>','a','b'] can be replaced with ['/','<','\\','>',a,b] (notice the missing quotes around a and b),  @$s can be replaced with $s, you can store str_repeat('-',12) and str_repeat('=',12) in global variables/constants, for($b=8;$b>=0;$b--) can be replaced with for($b=9;$b--;), str_repeat and repeated functions can be shortened by giving their name to a global variable (e.g.: global$R,$V;$R=str_repeat;$V=strrev;$V($R('=',12))) and newlines (\n) may be replaced by a multi-line string.

Here is a shorter version: http://pastebin.com/2TabUqbA (373 bytes). I've changed a few tips: removed the global variables, lets strrev unchanged, removed 1 space and a few small changes.

I think you need line 4 and line 15 (the <>><>< lines) to be the same.

Sorry, here's a 357-bytes long solution: http://pastebin.com/TugNDjjL I forgot to reduce some things.

@IsmaelMiguel Thanks for your help. I took some of your advice, but some of it results in a notice getting thrown.

@LarsEbert Ignore the notices. If you run it on http://writecodeonline.com/ it won't throw notices.

@IsmaelMiguel Still feels dirty.

@LarsEbert That's the goal! Here, we don't care if you play dirty. At a certain level. You can do anything in the code, as long as it doesn't throw errors (warnings aren't errors) and does exactly what is supposed to do. The code I gave doesn't trigger any fatal error or similar. Just a bunch of warnings. If you prove it works in 1 situation, that is enought.

APL (53 58)
It's not quite as symmetrical as I thought it was, unfortunately. Fix cost me 5 characters and now I'm out of the running.
L←+,3-⌽⋄'==--/\<><'[↑(732451451260688⊤⍨18/8)+L{L?12⍴2}¨⍳9]

Explanation:

L←+,3-⌽: L is a function that returns its argument followed by 3 - the reverse of its argument
L{L?12⍴2}¨⍳9: generate 9 lines of 12 random values from [1,2] plus their reverse, then the reverse of those 9 lines
732451451260688⊤⍨18/8: generate the list 0 2 4 6 4 2 4 4 4 4 4 4 2 4 _7_ 4 2 0 (that's where the damn asymmetricality is)
+: for each line, add the corresponding number to each value
↑: format as matrix
'==--/\<><'[...]: for each of the numbers in the matrix, select the character from the string at that position

Output:
========================
------------------------
///////\\///\\\//\\\\\\\
<<><<><><<<<>>>><><>><>>
\\\\\//\/\\\///\/\\/////
------------------------
/\///\\/\/\/\/\/\//\\\/\
\////////\//\\/\\\\\\\\/
\\/\\\//\///\\\/\\///\//
//\///\\/\\\///\//\\\/\\
/\\\\\\\\/\\//\////////\
\/\\\//\/\/\/\/\/\\///\/
------------------------
/////\\/\///\\\/\//\\\\\
<<><<><><<<<>>>><><>><>>
\\\\\\\//\\\///\\///////
------------------------
========================

I had +1ed because the algorithm you posted was interesting and original, but I've just noticed that your <> lines are not vertically symmetrical as you use your swap table when making the vertical mirror as well. (Thanks for posting  the output btw, makes figuring out if APL works much easier ;p )

@FryAmTheEggman: shit, didn't notice that. I'll probably have to scrap the whole algorithm now, since there's one line that's not like the others. Well, thanks for telling me rather than just downvoting.

@FryAmTheEggman: well, it's fixed (by adding another < to the end of the string, and incrementing the second line once more, thereby swapping it twice). Didn't even have to scrap the whole thing, though it won't win anymore now. (Perhaps next time I should't post the output :P)

That solution is quite clever, you can keep the +1 :)

@Calvin'sHobbies: fix one thing, break another. Now it's really fixed.

JavaScript (ES6) 169 195 201
Edit 6 bytes saved thx @nderscore. Beware, the newline inside backquotes is significant and counted.
Edit2 simplified row building, no need of reverse and concat
F=(o='')=>[...z='/\\/-/<\\-='].map((c,i,_,y=[z,'\\/\\-\\>/-='],q=[for(_ of-z+z)Math.random(Q=k=>q.map(v=>r=y[v^!k][i]+r+y[v^k][i],r='')&&r+`
`)*2])=>o=Q()+o+Q(i!=5))&&o

Run snippet to test (in Firefox)

F=(o='')=>[...z='/\\/-/<\\-='].map((c,i,_,y=[z,'\\/\\-\\>/-='],q=[for(_ of-z+z)Math.random(Q=k=>q.map(v=>r=y[v^!k][i]+r+y[v^k][i],r='')&&r+`
`)*2])=>o=Q()+o+Q(i!=5))&&o

Q.innerHTML=F()
<pre id=Q style='font-size:9px;line-height:9px'>

-6 bytes: Remove parenthesis around definition of z. Move definition of Q inside of the Math.random call. Replace '\n' with template string of newline. |0 integer casting is not needed, as the values will be xor-ed later on.

What does this for(_ of-z+z) mean?

@Derek I need to iterate 12 times and the best I have is a 9 char string. z is not numeric so -z is NaN (not a number) NaN converted to string is "NaN" and 3 chars + 9 chars are 12.

Ruby, 162 155
I like this one because it made me learn to abuse backslashes in both string literals and String#tr. The code isn't terribly clever otherwise, just compact.
a='/\\'
b='\\\/'
t=Array.new(9){x=''
12.times{x+=a[rand(2)]}
x+x.reverse.tr(a,b)}
t[0]=?=*24
t[1]=t[5]=?-*24
t[3].tr!a,'<>'
puts t,((t.reverse*'
').tr a,b)

Welcome to Programming Puzzles & Code Golf Stack Exchange! Here are a couple of Ruby-specific tips: I don't think you need to escape the / in a and b. The first tr can probably also do without parentheses. Single-character strings like '=' can be written ?=. And .join can be replaced by *.

@MartinBüttner Thanks for the welcome and the tips! The character literals and join synonym save me 6 bytes. I can't remove the parentheses in x+x.reverse.tr(a,b) because + takes precedence over , though. I'm also not actually escaping the slashes in my strings - I'm failing to escape one backslash in each. A second \ is necessary in b because of the way tr works, though I now realize the first \ in a is superfluous, so there's another byte.

Pyth, 57 59 61
J"\<>/"K"\/"L+b_mXdK_Kbjbym+d_XdJ_JmsmOk12[\=\-K-JKK\-KKK

J"\<>/"K"\/"jbu++HGXHK_Km+d_XdJ_JmsmOk12[KKK\-K-JKK\-\=)Y

Thanks a lot to @Jakube for coming up with these 57 byte versions.
Algorithm very similar to Martin's. (Revised) Explanation to come.
Try it online
Explanation:
=G"\<>/"                            : Set G to be the string "\<>/"
K"\/"                               : Set K to be the string "\/"
Jm+d_XdG_GmsmOk12[\=\-K"<>"K\-KKK;  : Set J to be the top half of the carpet
                 [\=\-K"<>"K\-KKK;  : Make a list of possible chars for each row
          msmOk12                   : for each element of that list,
                                    : make a list of 12 randomly chosen characters
                                    : from it, then join them
Jm+d_XdG_G                          : for each element of that list,
                                    : make a new list with the old element,
                                    : and its horizontal reflection
jb+J_mXdK_KJ                        : Print the whole carpet
     mXdK_KJ                        : For each element of J make its vertical reflection

Very nice. Shouldn't have thrown in the towel. 1 char save by replacing "<>" with -GK

And another one by either using lambda J"\<>/"K"\/"L+b_mXdK_Kbjbym+d_XdJ_JmsmOk12[\=\-K-JKK\-KKK or reduce J"\<>/"K"\/"jbu++HGXHK_Km+d_XdJ_JmsmOk12[KKK\-K-JKK\-\=)Y

@Jakube Thanks! Both of those are quite clever optimizations. I really like how the lambda lets you put the list at the end.

J, 56 54 bytes
'=/\<>--></\'{~(-,|.)0,(3(2})8$5,3#1)+(,1-|.)"1?8 12$2

Usage:
   '=/\<>--></\'{~(-,|.)0,(3(2})8$5,3#1)+(,1-|.)"1?8 12$2
========================
------------------------
///\\\\/\///\\\/\////\\\
><<><><>><>><<><<><><>><
\\/\//\\/\//\\/\//\\/\//
------------------------
\/\/\//////\/\\\\\\/\/\/
/\/\\//\//\\//\\/\\//\/\
//\\\\/////\/\\\\\////\\
\\////\\\\\/\/////\\\\//
\/\//\\/\\//\\//\//\\/\/
/\/\/\\\\\\/\//////\/\/\
------------------------
//\/\\//\/\\//\/\\//\/\\
><<><><>><>><<><<><><>><
\\\////\/\\\///\/\\\\///
------------------------
========================

1 byte thanks to @FUZxxl.
Explanation coming soon.
Try it online here.

Save one character: Replace 5 1 3 1 5 1 1 1 with (3(2})8$5,3#1).

@FUZxxl Great! I tried a ton of alternatives but haven't found this. (CJam got away in score overnight so J will not reach them. :P)

Javascript (ES7 Draft) 174 168 146
Some inspiration taken from @edc65
Edit: Thanks to edc65 for some ideas to optimize building of rows.
F=(o='')=>[for(i of'555357531')(z=[for(_ of c='==--/\\<>golf')Math.random(r=x=>z.reduce((s,y)=>c[w=i^y^x]+s+c[w^1],'')+`
`)*2],o=r()+o+r(i<7))]&&o

Demonstration: (Firefox only)

F=(o='')=>[for(i of'555357531')(z=[for(_ of c='==--/\\<>golf')Math.random(r=x=>z.reduce((s,y)=>c[w=i^y^x]+s+c[w^1],'')+`
`)*2],o=r()+o+r(i<7))]&&o

document.write('<pre>' + F() + '</pre>');

Commented:
// define function, initialize output to ''
F = (o = '') =>
    // loop through character indexes of first 9 lines
    [
        for (i of '555357531')(
            // build array of 12 random 0/1's, initialize character list
            z = [
                for (_ of c = '==--/\\<>golf')
                    Math.random(
                        // define function for generating lines
                        // if x is true, opposite line is generated
                        r = x =>
                            z.reduce(
                                (s, y) =>
                                    c[w = i ^ y ^ x] + s + c[w ^ 1],
                                ''
                            ) + `\n`
                    ) * 2
            ],
            // build new lines and wrap output in them
            // x true in the second line for indexes < 7 (not character '>')
            o = r() + o + r(i < 7)
        )
    ]
    // return output
    && o

See my edit, it's good for your solution too

@edc65 nice idea! I've implemented something similar now.

Python 295 287 227 bytes
Not that great but I'll post it anyway:
from random import*
m,d=[],dict(zip("\/<>=-","/\><=-"))
v=lambda w:[d[x]for x in w]
for e in '=-/>/-///':f=[choice([e,d[e]])for x in[0]*12];t=''.join(f+v(f[::-1]));print t;m+=''.join(e=='/'and v(t)or t),
print'\n'.join(m[::-1])

If you want an explanation just ask me.

@Sp3000 Thanks for pointing it out, I fixed it. A shame it came if even longer though...

Here's a bunch of golfs which are too long to fit in a comment. You might be able to get it down even more if you put = and - in d.

@Sp3000 Thanks a lot for all the advice. A lot of it was pretty obvious (spaces, removing reversed) as I'm not the greatest golfer (both code and irl), but I learned some new python too (so again thanks). Removing the if statement by including = and - in the dict turned out to be a very good idea. P.S. would you mind explaining how a recursive quilt is made in so few code (decrypting translate sucks)

Pharo 4, 236
|s i f v h|s:='====----/\/\/<><<>'.f:=[:c|s at:(s indexOf:c)+i].v:=#(),'=-/</-///'collect:[:c|h:=(String new:12)collect:[:x|i:=2atRandom.f value:c].i:=1.h,(h reverse collect:f)].i:=3.String cr join:v,(v reverse collect:[:k|k collect:f])

or formatted normally:
|s i f v h|
s:='====----/\/\/<><<>'.
f:=[:c|s at:(s indexOf:c)+i].
v:=#() , '=-/</-///'
  collect:[:c|
    h:=(String new:12)collect:[:x|i:=2atRandom.f value:c].
    i:=1.
    h,(h reverse collect:f)].
i:=3.
String cr join:v,(v reverse collect:[:k|k collect:f])

Explanation:
The string s:='====----/\/\/<><<>' together with the block f:=[:c|s at:(s indexOf:c)+i] are here both for tossing the characters and for reversing the patterns...

For i=1, it performs horizontal reversion (/ <-> \ , < <-> > ).
For i=3, it performs vertical reversion (/ <-> \)
For i=1 or 2 atRandom, it toss among / or \, < or >

'=-/</-///' encodes the character type c that will feed the block f for the 9 first lines.
#() , '=-/</-///' is a concatenation trick for transforming the String into an Array and thus collecting into an Array.
The rest is simple concatenation after applying the horizontal/vertical symetry.
========================
------------------------
\\/\/\\\\/\/\/\////\/\//
>>>><><><>><><<><><><<<<
\/\/\//\///\/\\\/\\/\/\/
------------------------
/\//\/\/////\\\\\/\/\\/\
\\//\//\\\/\/\///\\/\\//
////\\/\/\//\\/\/\//\\\\
\\\\//\/\/\\//\/\/\\////
//\\/\\///\/\/\\\//\//\\
\/\\/\/\\\\\/////\/\//\/
------------------------
/\/\/\\/\\\/\///\//\/\/\
>>>><><><>><><<><><><<<<
//\/\////\/\/\/\\\\/\/\\
------------------------
========================

Squeak 4.X, 247
|r s h m n p|s:='==--/\<>'.r:=(1<<108)atRandom.h:=''.m:=0.(16to:0by:-2),(0to:16by:2)do:[:i|n:=3bitAnd:28266>>i.p:=0.(11to:0by:-1),(0to:11)do:[:j|h:=h,(s at:n*2+1+(r-1>>(6*i+j)+(101>>(3-n*4+m+p))bitAnd:1)).j=0and:[p:=1]].i=0and:[m:=2].h:=h,#[13]].h

Or formatted:
|r s h m n p|
s:='==--/\<>'.
r:=(1<<108)atRandom.
h:=''.
m:=0.
(16to:0by:-2),(0to:16by:2) do:[:i|
  n:=3 bitAnd: 28266>>i.
  p:=0.
  (11to:0 by:-1),(0to:11) do:[:j|
    "h:=h,(s at:n*2+1+((r-1bitAt:6*i+j+1)bitXor:(101bitAt:3-n*4+m+p))). <- originally"
    h:=h,(s at:n*2+1+(r-1>>(6*i+j)+(101>>(3-n*4+m+p))bitAnd:1)).
    j=0and:[p:=1]].
  i=0and:[m:=2].
  h:=h,#[13]].
h

Explanations:
s:='==--/\<>'. obviously encodes the four posible pairs.
r:=(1<<108)atRandom. toss 108 bits (in a LargeInteger) for 9 rows*12 columns (we toss the == and -- unecessarily but performance is not our problem).
h:=''is the string where we will concatenate (Schlemiel painter because a Stream would be too costly in characters).
(16to:0by:-2),(0to:16by:2)do:[:i| is iterating on the rows (*2)
(11to:0by:-1),(0to:11) do:[:j| is iterating on the columns
28266 is a magic number encoding the pair to be used on first 9 lines.
It is the bit pattern 00 01 10 11 10 01 10 10 10, where 00 encodes '==', 01 '--', 10 '/\' and 11 '<>'.
101 is a magic number encoding the horizontal and vertical reversion.
It is the bit pattern 0000 0000 0110 1010, encoding when to reverse (1) or not (0) the first (0) or second (1) character of each pair '==' '--' '/\' and '<>', for the vertical symetry and horizontal symetry.
n:=3 bitAnd: 28266>>i gives the encoding of character pair for row i/2 (0 for '==', 1 for '--', 2 for '/\' and 3 for '<>').
(r-1 bitAt: 6*i+j+1) pick the random bit for row i/2 column j (1 is the rank of lowest bit thus we have a +1, k atRandom toss in interval [1,k] thus we have a -1).
(101 bitAt: 3-n*4+m+p) pick the reversal bit: (3-n)*4 is the offset for the group of 4 bits corresponding to the pair code n, m is the vertical reversion offset (0 for first 9, 2 for last 9 rows), p is the horizontal reversion offset (0 for first 12, 1 for last 12 columns)+1 because low bit rank is 1.
bitXor: performs the reversion (it answer an offset 0 or 1), and s at:2*n+1+bitXor_offset pick the right character in s.
But (A>>a)+(B>>b) bitAnd: 1 costs less bytes than (A bitAt:a+1)bitXor:(B bitAt:b+1)thus the bitXor was rewritten and offset +1 on p is gone...
h,#[13] is an ugly squeakism, we can concatenate a String with a ByteArray (containing code for carriage return).
========================
------------------------
/\/\\\/\//\/\/\\/\///\/\
><>><<>>>><<>><<<<>><<><
////\\////\\//\\\\//\\\\
------------------------
/\\\/\\/\\//\\//\//\///\
\/\\/\//////\\\\\\/\//\/
\\\//\\\////\\\\///\\///
///\\///\\\\////\\\//\\\
/\//\/\\\\\\//////\/\\/\
\///\//\//\\//\\/\\/\\\/
------------------------
\\\\//\\\\//\\////\\////
><>><<>>>><<>><<<<>><<><
\/\///\/\\/\/\//\/\\\/\/
------------------------
========================


text:
Tips for golfing in Element
Since my use of Element has increased recently, I am interested in tips for golfing programs written in it.
What general tips do you have for golfing in Element? I'm looking for ideas that can be applied to code golf problems in general that are at least somewhat specific to Element.
Please post one tip per answer.

Element being such common word, search engines not really help finding its home page. Could you please add a link?

I threw a link in because I found it, but if you'd rather put it somewhere else in the post I won't be offended if you revert it.

Thanks for adding the link.  I didn't see your comments until now since I was working on an answer.

@manatwork Always check https://esolangs.org for the language. It's like wikipedia for esoteric programming languages. Here's Element: https://esolangs.org/wiki/Element

@mbomb007 I actually did not realize that there was an Esolangs page for it.

Ah, you updated the documentation. Nice.

Ways to put extra 0s on the stack
A lot of times, you will be faced with the following 4-character piece of code:
0 2@

Element's stack-item-movement operator @ is very general-purpose, sometimes too much so for golfing, since it always takes two arguments, which may need to be separated by a space.  So, it can take several characters to perform a single movement.
Usually, there is a better way to do this.
You can often produce empty values from the hash.  The code  2:0 2@ can almost always be shortened to 3:~2@ to save one character because chances are that nothing is stored in the hash for that particular key.
If the top thing on the stack is the input, you can sacrifice the newline at the end of it like so:
_0 2@
_)2@

In a limited number of cases, usually with 0 1@, you don't need the @ at all.  This works with input or when putting a constant on the stack.
_0 1@
'_"

text 0 1@
'text"

Performing logic operations on a list of numbers.
Let's say you had a simple task: Take a list of 5 numbers and verify that all of them are multiples of 7.  (You can replace "multiple of 7" with any other test.)  You will soon run into a problem: in order to perform a loop, you must put a value on the control stack, but this this can interfere with the logic that you are performing on the list of numbers.
The following solution does not work because the value 5 is accidentally included as one of the arguments in the chain of ORs.
5'[_7%?|]!"`  #does not work

There are a few ways to overcome this.
5'0[_7%+]?!"` #self-contained
5'[_7%+]?!"`  #if main stack is empty
5'[_7%?!&]"`  #main stack untouched, but consumes the 5

If the numbers you need to compare are already on the stack, then the above approach will not work.
2 3 7 4 8 5'[7%?|]!"`  #does not work
2 3 7 4 8 5'[!7%?|!]"` #works
2 3 7 4 8 5'[7%?!&]"`  #shorter, notice the | -> &
5'2 3 7 4 8[7%?!&]"`   #can save a space in some cases

Using the hash as an array
Element does not have native support for arrays, but the hash can be used as a makeshift array for simple operations.  This is done by using numbers as keys.  The following code initializes an array [7,32,12,8,3]
7 0;32 1;12 2;8 3;3 4;

For a much larger array, this is a more compact way to go:
7 32 12 8 3 13 5 1 0 67 12 54 11 13'["1-+2:';]

As you can tell, using the hash to hard-code an array is a measure of last resort.  They work nicer when the array is created in a less hard-coded fashion.  Here is code that can take as input an array size and a list of values and put it in an array.
_'0[2:_)1@;1+]

Retrieving a value is easy though and can be where this convoluted scheme pays off.  If i contains the index you want to retrieve, then the code is simple:
i~~

To give an array a name, you can append a single letter to the index when storing and retrieving.

"Factoring Out" things from If-Else constructions
If you ever have the code
?[...]![..]

Then you probably have an If-Else construction.  You really want to minimize the amount of duplicate code you put in these things.  Generally speaking, if V W X Y Z are blocks of code, then the following compression should be tried:
?[WXVZ]![WVYZ]
?W[X]V![Y]Z

This usually works even if V/W/Z is a ~`; type of operator, but probably does not work if V/W/Z is ".


text:
Minimum base to count to a string
The Challenge
Input: alphanumeric string. You can assume that the string will only contain the characters [0-9A-Z]. This can come from a parameter, command line, or STDIN. Digits are always before letters in terms of the base. Think like an extended version of HEX.
Output X,Y Such that Y is the minimum base required to parse the string and X is the decimal value of the input string in that base.
Examples

Input: "1"
Output: 1,2

Input: "HELLOWORLD"
Output: 809608041709942,33

Scoring: This is a golf, so shortest code in bytes wins.

Borderline dupe of Base X to base Y conversion. (And probably one or more of the other 370 existing questions which talk about bases).

@PeterTaylor I would argue that this is different from the Base X to Y conversion, primarily because you are not supplied with the start base. It is an additional calculation the program must make. As for the search link, that is why this is specifically tagged as base-conversion.

I said it was borderline dupe, not identical (although it does only take 5 or 6 chars in golfing languages to extract the base, so it's not exactly a non-trivial difference), and held back from casting a supervote to see whether others agreed. Since no-one else has cast a close vote yet, I'll post an answer.

Related: http://codegolf.stackexchange.com/q/40416/21348 (should it be tagged base-conversion?)

Pyth, 23 bytes
Jmx+jkUTGdrz2KheSJ,iJKK

Try it online: Pyth Compiler/Executor
      UT       create the list [0, 1, 2, ..., 9]
    jk         join them, creates the string "0123456789"
   +    G      G is initialized with the alphabet, add both strings
               creates "0123456789abcdefghijklmnopqrstuvwxyz"
 m        rz2  maps each charater d of input().lower() to:
  x      d         the index of d in "012...xyz"
J              store the resulting list of indices in J

   SJ          sorted(J) (doesn't sort J in place, but gives you a sorted copy)
  e            last element (=maximum)
 h             + 1
K              store result in K

 iJK           convert J from base K to base 10
,   K          create the tuple (iJK, K) and prints

Pyth, 16 bytes (?)
I'm not sure if this counts. The functionality I'm using was in Pyth for quite a while, but didn't work because of one stupid little bug. So the following code didn't work when the question was asked, although the docs said that it does.
DeGJ1#~J1#R,iGJJ

This defines a function e. Try it online.
This one was based a submission by @Reticality. He uses a different algorithm now though.
DeG               Define a function e(G):
   J1               J = 1
     #              while True:
      ~J1             J += 1
         #            try:
            izJ         convert z (=input) from base J into base 10
          R,izJJ        return tuple(base_10, J)
                      if exception (converting failed) do nothing

Python 2, 74 64 56 55 53 bytes
def f(x):a=ord(max(x))-54;a+=7*(a<8);print int(x,a),a

Call the function (i.e. f("HELLOWORLD")) and outputs to stdout (809608041709942 33)
This is case-sensitive, requiring upper case letters, and crashes for invalid input (e.g. "$^$%!(&£%)())
This code gets the max letter in the string (z>x>y>...>b>a>9>8>...>2>1>0) and gets the largest base needed to represent it.
Change the 54 into a 76 to make it work for lowercase (but no longer upper case).

Does Python not have a ++ operator? That'd save you 2 bytes

@ColeJohnson It does not.

You can shorten if a<8:a+=7 to a+=7*(a<8).

Would a+=7*(8>a=ord(max(x))-54); work? It does in PHP.

APL (24)
{(B⊥D-1),B←⌈/D←⍵⍳⍨⎕D,⎕A}

This is a function that takes a string and returns two values, the value and the base.
      {(B⊥D-1),B←⌈/D←⍵⍳⍨⎕D,⎕A} 'DEADBEEF'
3735928559 16

Explanation:

⎕D,⎕A: digits followed by letters
D←⍵⍳⍨: store in D the 1-based index of each character of ⍵ in the string of digits followed by letters
B←⌈/D: store in B the highest value in D. (which is the base to use)
(B⊥D-1): subtract 1 from each value in D (making them the values of the digits), and decode them as a base-B number.

The question specified bytes but it looks like you've counted characters.

The APL character set fits in a byte with room to spare. Here's IBM's standard. They don't have to be Unicode bytes.

Pure Bash, 48
for((b=37;$[--b]#$1;)){ :;}
echo $[$[++b]#$1],$b

Output
$ ./minbase.sh HELLOWORLD
./minbase.sh: line 1: ((: 32#HELLOWORLD: value too great for base (error token is "32#HELLOWORLD")
809608041709942,33
$ ./minbase.sh HELLOWORLD 2>/dev/null
809608041709942,33
$ ./minbase.sh 1 2>/dev/null
1,2
$

I'm taking advantage of this meta answer - specifically that warnings output to STDERR may be ignored.

J - 50 char
Worry not, Martin, I have come to restore order.
(>./@i.(u:(47+i.11),65+i.26&)(,&.":,[)'b',tolower)

The u:(47+i.11),65+i.26 portion creates the string /0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ, and we want the slash so that when we find the largest digit of HELLOWORLD with >./@i., we  correct an off-by-one error at no extra charge.
Then we use J's built-in base conversion by evaling e.g. 33bhelloworld; J has this weird internal language for specifying numbers, so we exploit that to do the base interpretation for us.
   (>./@i.(u:(47+i.11),65+i.26&)(,&.":,[)'b',tolower) 'HELLOWORLD'
809608041709942 33
   f =: (>./@i.(u:(47+i.11),65+i.26&)(,&.":,[)'b',tolower)
   f '1'
1 2
   f 'POTATO'
627732894 30
   f '1FISH2FISH'
22338345482731 29

J, 31 bytes
3&u:(-47+7*60<]@)(>./(#.,[)<:@)

Usage:
   f=.3&u:(-47+7*60<]@)(>./(#.,[)<:@)

   f 'POTATO'
627732894 30
   f '1FISH2FISH'
22338345482731 29

1 byte thanks to @FUZxxl.
Try it online here.

Use u: instead of a.&i. I guess.

@FUZxxl Right, 3&u: works. (The self-written adverbs got my full attention. I just understood them properly and they are quite useful for golfing.)

CJam (25 chars)
q{i48-_9>7*-}%_:e>):Zb',Z

Online demo
It's 28 chars in GolfScript, mainly because base doesn't have a one-char alias:
{48-.9>7*-}%.$-1=):^base','^

Mathematica, 55 bytes
Hmmm, beating J with Mathematica? Something's fishy...
Print[f=FromDigits;f[#,y=f/@Max@Characters@#+1],",",y]&

This defines an unnamed function, which takes the string as a parameter and prints the result. You can either give it a name or use it directly:
Print[f=FromDigits;f[#,y=f/@Max@Characters@#+1],",",y]&@"HELLOWORLD"

The idea is pretty simple. Mathematica's integer parser supports bases up to 36 out of the box, so we only need to figure out the minimum base. We do that with
y=f/@Max@Characters@#+1

where # is the function's parameter and we've defined f as an alias of FromDigits. Note that FromDigits normally reads things in base 10, but that doesn't change the value of a single digit. Then we just use that to parse the string with f[#,y...] and the print the result, a comma and y.

JavaScript, 100 89 bytes
Thanks to nderscore for saving 10 bytes!
Works for base-2 to base-36; that's all bases JavaScript's parseInt supports.
function b(s){for(i=1;(x=parseInt(s,++i))!=x|!x.toString(i)[s.length-1];);return x+","+i}

The code uses a for loop starting from 1 and tries to parse the int on base-N (I use N here as i + 1; i is incremented before parsing the number) is the current number in the loop. It checks whether the parsed int is not NaN (x==x is the shortest way, and it works because NaN != NaN). It also checks that the integer converted to base-N equals the original string; this is necessary because when JavaScript parses an int, only the first part has to be valid, so parseInt would be able to parse "abc" on base-11 because "a" is a valid base-11 integer (while "b" and "c" are not). If the input cannot be parsed in base-N, then the for loop continues until it finds the correct base; after the for loop, the function returns the base-10 number and the original base.
Ungolfed code:
function getBase(str) {
    for (var base = 1;
    (parsed = parseInt(s, ++base)) != parsed | !parsed.toString(base)[str.length - 1];);
    return parsed + "," + base;
}

-10 bytes: function b(s){for(i=1;(x=parseInt(s,++i))!=x||!x.toString(i)[s.length-1];);return x+","+i}

@nderscore Nice, thanks! Now I could actually get -11 bytes, because the || operator can be shortened to the bitwise | operator, which still gives the same results here.

Rust (1.0 beta), 81 80 bytes
let f=|a|loop{for i in 2..{if let Ok(m)=u64::from_str_radix(a,i){return(m,i)}}};

Test:
fn main() {
    let f=|a|loop{for i in 2..{if let Ok(m)=u64::from_str_radix(a,i){return(m,i)}}};
    assert_eq!(f("1"), (1, 2));
    assert_eq!(f("POTATO"), (627732894, 30));
    assert_eq!(f("HELLOWORLD"), (809608041709942, 33));
    println!("ok!");
}

This is similar to all other answers, we try to parse the string into an integer using the internal function u32::from_str_radix, and start from base 2 and return immediately.
Rust is static-typed, and it requires all reachable branches to return the same type of value. The for loop is not infinite, so Rust would require a return value after the for loop. In order to make the type-checker happer, an outer infinite loop is added to make sure there is no other exit point. This saves 1 byte compared with returning a default value.

J (61)
Explicit funcions in J can be... Somewhat hard to read.
3 :'(+/i*b^|.x:i.#y),b=.>:>./i=.(y i.~a.{~(48+i.10),65+i.26)'

Example usage:
   f=: 3 :'(+/i*b^|.x:i.#y),b=.>:>./i=.(y i.~a.{~(48+i.10),65+i.26)'
   f 'POTATO'
627732894 30

JavaScript (ES6) 70 72
The base is 1 more than the biggest digit in the string, so sort and find it.
Edit Save 2 bytes thx @nderscore (particularly, shame on me for using >= instead of >)

F=s=>(b=[...s].sort().pop().charCodeAt()-47,[parseInt(s,b-=b>8&&7),b])
// TEST:
C.innerHTML=F('1') + '\n' + F('HELLOWORLD')+ '\n' + F('POTATO')

-2: F=s=>(b=[...s].sort().pop().charCodeAt()-47,[parseInt(s,b-=b>8&&7),b])

Vyxal, 74 bitsv2, 9.25 bytes
⇩:fGkrḟ›…β,

Try it Online!

Doesn't pass the test cases - looks like Vyxal's base conversion function doesn't work.

@MTN fixed it, i forgot to dupe the string/increment and remove a space i added

8.375 bytes

man i was looking for the force output flag....

Swift, 105
Not very short and can probably be improved
func n(x:String) {var m=64;for c in x.utf8{m=max(Int(c),m)};println("\(strtoul(x,nil,10+m-64)),\(m-54)")}

Haskell, 97 bytes
import Data.Char
j x|x>64=x-54|1<2=x-47
l=j.ord
m=l.maximum
f x=(foldl(\a b->a*m x+l b-1)0 x,m x)

Example run:
*Main> map f ["HELLOWORLD", "POTATO", "1"]
[(809608041709942,33),(627732894,30),(1,2)]

It's so long because I need do import Data.Char for ord and I don't have a built in read function for integers of arbitrary base.

PHP (>=5.4), 90
(-2 for an anoynomous function in PHP 7; 74 for a snippet)
function f($s){$b+=7*(8>$b=ord(max(str_split($s)))-54);return[base_convert($s,$b,10),$b];}

Thanks @user34736 for the -54(+8) idea; saved two bytes on my -54/-47 approach.
The function returns an array instead of printing the result.
+/-0 for printing:
function f($s){$b+=7*(8>$b=ord(max(str_split($s)))-54);echo base_convert($s,$b,10),",$b";}

but a return value is easier to test:
function test($x,$y,$e){static $h='

input	output	expected	ok?
';echo"$h
$x	$y	$e	",(strcmp($y,$e)?'N':'Y'),"
";$h='';}
foreach([1=>'1,2','HELLOWORLD'=>'809608041709942,33','ILOVECODEGOLF'=>'21537319965321352644,32','POTATO'=>'627732894,30','1FISH2FISH'=>'22338345482731,29']as$x=>$e)test($x,implode(',',f($x)),$e);echo'
';

Pascal, 217 B
Extended Pascal (as specified by ISO standard 10206) allows you to write (in your source code) integer literals up to base 36 (for example −16#fF denotes the value −255 decimal).
To be functionally consistent, all number literals that are allowed in Pascal source code are allowed as user input, too:
Therefore the built‑in procedures read/readLn/readStr accept strings constituting valid number literals in your Pascal source (and in fact all numeric representations defined by ISO standard 6093).
The task can be boiled down to determining the minimal base:
program p(input,output);var U,P:string(65);Y,X:integer;begin read(U);Y:=2;for X:=1 to length(U)do
Y:=card([1..Y,1..index('0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ',U[X])]);writeStr(P,Y:1,'#',U);readStr(P,X);write(X,Y)end.

Ungolfed:
program minimumBaseToCountToAString(input, output);
    const
        { Pascal does not make any assertion with regard to character encoding
          (except that `'A' < 'Z'`/`'a' < 'z'` (subject to availability) and
          digit characters `'0'` through `'9'` are consecutive and ascending).
          Hence another mechanism needs to be sought. }
        digit = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ';
    type
        { A `type` range restriction will cause an error
          should we attempt to assign values outside of this range. }
        base = 2‥36;
    var
        unprocessed: string(62);
        { This size is sufficient for `'2#1010…0101'` on a 64‑bit system.
          However, it will not prevent `'36#ZZZ…ZZZ'` overflow mistakes. }
        prefixed: string(65);
        { Stores the value of the largest digit found + 1 (a. k. a. base). }
        minimumBase: base value 2;
        { Cannot reuse variable since `minimumBase` needs to be printed, too. }
        number: integer;
    begin
        { Reads up to `unprocessed.capacity` characters from `input`
          and discards the remainder of the line. }
        readLn(unprocessed);
        { In Pascal `string` indices are `1`-based. }
        for number ≔ 1 to length(unprocessed) do
        begin
            { Determines the maximum of two values without calculating
              the potential new maximum multiple times.
              The Extended Pascal function `index` returns `0`
              if `representation[number]` is not found in `digit`. }
            minimumBase ≔ card([1‥minimumBase,
                                1‥index(digit, unprocessed[number])]);
        end;
        { The `:1` is necessary so the base specification does not get padded
          with an implementation-defined default number of space characters
          (possibly causing /trailing/ characters to spill over). }
        writeStr(prefixed, minimumBase:1, '#', unprocessed);
        { This performs the actual conversion honoring `minimumBase`. }
        readStr(prefixed, number);
        { I can count to potato! }
        writeLn(number, minimumBase);
    end.

Ruby -n, 46 bytes
x=0
1until(x=Integer($_,$.+=1)rescue p)
p x,$.

Attempt This Online!

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