Profound

Excerpt from Scott Aaronson's Who Can Name the Biggest Number?

Turing continued to explicate his machine using ingenious reasoning from first principles. [A paper tape], said Turing, extends infinitely in both directions, since a theoretical machine ought not be constrained by physical limits on resources. Furthermore, there’s a symbol written on each square of the tape, like the ‘1’s and ‘0’s in a modern computer’s memory. But how are the symbols manipulated? Well, there’s a ‘tape head’ moving back and forth along the tape, examining one square at a time, writing and erasing symbols according to definite rules. The rules are the tape head’s program: change them, and you change what the tape head does. 

Turing’s august insight was that we can program the tape head to carry out any computation. 

Just as we can classify words by how many letters they contain, we can classify Turing machines by how many rules they have in the tape head. Some machines have only one rule, others have two rules, still others have three rules, and so on. But for each fixed whole number N, just as there are only finitely many distinct words with N letters, so too are there only finitely many distinct machines with N rules. Among these machines, some halt and others run forever when started on a blank tape. Of the ones that halt, asked Rado, what’s the maximum number of steps that any machine takes before it halts?

Conclusion? The sequence of Busy Beaver numbers, BB(1), BB(2), and so on, grows faster than any computable sequence. Faster than exponentials, stacked exponentials, the Ackermann sequence, you name it. Because if a Turing machine could compute a sequence that grows faster than Busy Beaver, then it could use that sequence...The Busy Beaver sequence is non-computable, solely because it grows stupendously fast—too fast for any computer to keep up with it, even in principle.

In 1984, A.K. Dewdney devoted a Scientific American column to Busy Beavers, which inspired amateur mathematician George Uhing to build a special-purpose device for simulating Turing machines. The device, which cost Uhing less than $100, found a five-rule machine that runs for 2,133,492 steps before halting—establishing that BB(5) must be at least as high. Then, in 1989, Heiner Marxen and Jürgen Buntrock discovered that BB(5) is at least 47,176,870. To this day, BB(5) hasn’t been pinned down precisely, and it could turn out to be much higher still. As for BB(6), Marxen and Buntrock set another record in 1997 by proving that it’s at least 8,690,333,381,690,951. A formidable accomplishment, yet Marxen, Buntrock, and the other Busy Beaver hunters are merely wading along the shores of the unknowable. Humanity may never know the value of BB(6) for certain, let alone that of BB(7) or any higher number in the sequence.

We’ve seen that progress in notational systems for big numbers mirrors progress in broader realms: mathematics, logic, computer science. And yet, though a mirror reflects reality, it doesn’t necessarily influence it. Even within mathematics, big numbers are often considered trivialities, their study an idle amusement with no broader implications. I want to argue a contrary view: that understanding big numbers is a key to understanding the world. Imagine trying to explain the Turing machine to Archimedes. The genius of Syracuse listens patiently as you discuss the papyrus tape extending infinitely in both directions, the time steps, states, input and output sequences.

At last he explodes. "Foolishness!" he declares (or the ancient Greek equivalent). "All you’ve given me is an elaborate definition, with no value outside of itself." How do you respond? Archimedes has never heard of computers, those cantankerous devices that, twenty-three centuries from his time, will transact the world’s affairs. So you can’t claim practical application. Nor can you appeal to Hilbert and the formalist program, since Archimedes hasn’t heard of those either. But then it hits you: the Busy Beaver sequence.

You define the sequence for Archimedes, convince him that BB(1000) is more than his 10^63 grains of sand filling the universe, more even than 10^63 raised to its own power 10^63 times. You defy him to name a bigger number without invoking Turing machines or some equivalent. And as he ponders this challenge, the power of the Turing machine concept dawns on him. Though his intuition may never apprehend the Busy Beaver numbers, his reason compels him to acknowledge their immensity. Big numbers have a way of imbuing abstract notions with reality.

Indeed, one could define science as reason’s attempt to compensate for our inability to perceive big numbers. If we could run at 280,000,000 meters per second, there’d be no need for a special theory of relativity: it’d be obvious to everyone that the faster we go, the heavier and squatter we get, and the faster time elapses in the rest of the world. If we could live for 70,000,000 years, there’d be no theory of evolution, and certainly no creationism: we could watch speciation and adaptation with our eyes, instead of painstakingly reconstructing events from fossils and DNA. If we could bake bread at 20,000,000 degrees Kelvin, nuclear fusion would be not the esoteric domain of physicists but ordinary household knowledge. But we can’t do any of these things, and so we have science, to deduce about the gargantuan what we, with our infinitesimal faculties, will never sense.

Who can name the bigger number? Whoever has the deeper paradigm. Are you ready? Get set. Go.

That's cool

Ruby has no interfaces, but let's see what we can do:

module FooInterface
def bar(a,b) raise "bar(a,b) must be overridden"; end
end

class FooClass
include FooInterface
def bar(a,b) a+b; end
end

It's not particularly robust, but ehh, this isn't Java.

Studying is going well, thanks for asking

I made a Dominion tracker for myself, but anyone can use it if they want.

It's hosted here, courtesy Will.

It may very well turn out like that time in Settlers where I calculated my expected values for all the resources and then watched helplessly as I was unable to do anything about it despite the game unfolding exactly as predicted.

But you have more control in Dominion, so who knows.

As with anything open-source, I'm giving no documentation, what, are you an idiot or something?

Naturally it doesn't take into account a lot of things, in particular the expected handsize algorithm makes me very unhappy.

So if any CO majors would like to formulate some better equations for me *cough*Dani*cough* I would be happy to make the changes.

Applied Math

If I spend $20 a day and get $10 a day and I have a control volume of $100 a day, then that's like I'm losing $10 a day and I'd be out of money in 10 days.

Now lets say I have chocolate coins. If I get twenty coins a day and eat ten, and then I end up with ten coins in my pocket everyday. Except I don't except because some of the coins will melt together, so we add a reaction term.

Now, we can't use it in this form because it's too complex. What we can do is we combine it with what we've empirically determined in Fick's Law. Fick's Law to the rescue!

"Does anyone else get the feeling like they understand everything in this class and at the same time-"

"Absolutely nothing at all? Yes."

The alpha and the beta

Stats 101, just so everyone's on the same page: there are 2 types of errors.

Type-1 (alpha) error is a detection (false-rejection) error.

Type-2 (beta) error is a rejection (false-detection) error.

What does this mean for our lives?

Let's pretend there exists a social welfare program for people whose houses spontaneously combusted. In order to determine if they should be granted restitution, their situation is quantified on a scale by some means. Of course there will be people who burn their houses down to scam money and we would seek to exclude them from this system. In an ideal world, we would imagine a distribution of scammers and non-scammers on the scale as such:


Yes, prepare for a lot of bad MSPaint diagrams because I can't be assed to work with Illustrator.

So in this ideal world, it's simple. We set P as the cut-off point and exclude everyone who scores higher than P on the scale and accept everyone who scores less than P. Done!

Except no.

By central limit theorem, we would expect normal distributions of both populations centered around separate means (if this test has any amount of effectiveness):


At point Q is how the average Spontaneous Combustor shows up and point R is the average Scammer. Under the two bells are how the populations of both categories are expected to be distributed. Notice though, how they overlap! I guess you can argue that a better test would space the curves further apart, but realistically you rarely see that kind of thing in real life in any meaningful way even in stochastic processes that don't involve one set of sentient beings trying to appear like the other. What you can do, is tighten the acceptance criteria and shift P left, or relax it and shift P right.

Okay, here's where the math gets a bit sketchy with assumptions, but bear with me. You can decide if it makes sense or not (it does to me), but doesn't affect my core premises either way.

The population of Scammers is much less than the population of Spontaneous Combustors so our distributions actually look like this:


Now if P is where % alpha is equal for both hypotheses, the absolute alpha and beta for our leftmost graph is:


I might've eyeballed P too far right actually, but no matter. As you can see, because one group is larger than the other, even if we accidentally accept the same percentage of blue as we reject red, the absolute alpha is much bigger than beta.

So a huge part of social policy is really all about where we want to move P. We will never know absolutely how big each slice is because obviously if we had a foolproof way to detect it, we wouldn't be committing these errors in the first place! The question is in which direction do we want to err?

In every aspect of our social systems, Conservatives are so frightened of Type-2 errors that they cripple them to beyond usability for many people with legitimate needs for them. Whether this be something like unemployment insurance, disability insurance, or even something as fundamental to democracy as voting.

Realistically some number people in real need is going to look exactly like some number of people that aren't in whatever system you're using the quantify "need". I would argue the number of the former is much greater than the number of the latter in whatever confidence interval we're using, but for the sake of argument let's say it's 1:1.

You have 2 applicants to social welfare program x. One who is in dire need through no fault of his own and another one who is scamming for money.

You can choose to shut neither or both out. Which do you choose? Which do you think is the appropriate choice for a developed democratic society?

Either the CPC thinks that a token amount of infringement is unbearably galling that they would rather shut the door on someone who has paid into the social system in the expectation of being protected when luck turns sour or they are just looking for an excuse to Not Give a Damn.

Pathetic. Or evil. You decide.

Additional food for thought: Engineering stats begins at the CLT whereas that's about the point after the stats most math students take ends. It's almost as though they said to themselves, "whoa, we better stop now or else they might learn something useful!".

I dimension the die!

What's the functional difference between rolling a 12 sided die and two 6 sided die? Well, for one you can't roll a 1 with two dice. More importantly though, you'll see a stronger regression to the mean with more dice.

Let's say theoretically we have a 10-sided die numbered [0,9]. Your probability of rolling a 5 is 10%.

If you have three 4-sided dice numbered [0,3], the probability of rolling a 5 suddenly becomes 19%.

If you flip 9 coins, the probability of landing 5 heads is now 25%. Moreover, the probability of rolling either 5 or 6 (the expected value is 5.5) is 49%. Of the 10 possible numbers, half the time you'll only get 2 of them!

I assume this is why a lot of boardgames roll two dice, because it normalizes the probabilities; you're 6 times more likely to roll a middle value like 7 over something extraordinary like 2 or 12.

With Betrayal, the rolls consist of up to eight 6-sided dice with two faces each numbered 0, 1 and 2. Basically 3-sided dice. Therefore we should see some strong regressions to the mean; for instance, if we were to roll five such dice the probability of getting at least a 4 is 79%. To roll 3 or lower and be beaten by a roll with 3 dice has a probability of 11%. To do so twice in a roll is literally a 1 in 100 proposition.

So basically Michael really sucks at rolling.

Someone should show this to Keyar

Schooling Math

There are always people giving talks about math education.

I always hear, the way math is taught is boring.

Boring boring boring.

No, some people find it boring. But others will enjoy mastering the system.

The truth is, you can make math the Amazing Race and some people will hate it. The point is there are some things everyone needs to know, and if you have a good teacher, he/she will make sure everyone knows it.

Everybody should be able to understand up to fractions and algebra. It should be expected in that we expect everybody to be able to write coherent sentences. No, not everyone can do it with the same amount of effort, but that's just a matter of applying oneself.

Why? Because you literally need to know 8 things:

1) Addition and subtraction
2) Multiplication and division
3) What a numerator and a denominator is
4) Multiplication of fractions and inverse multiplication of fractions
5) Finding common factors; how addition and subtraction apply to fractions
6) You want to isolate the unknown in an algebra statement
7) If you move something to the other side, invert the operation
8) How to translate a word problem into algebra

From grade 1 to 8, we have eight years to teach this! EIGHT YEARS! Fractions might be hard for some people, but not literally "can't memorize 4 rules in a year of practice" difficult!

Look at the mathematical proficiency in China. India. Japan. Are their kids smarter? No, they're told to suck it up and work harder. Are their systems the best? Definitely not in all ways but with respect to math, it gets the material taught and it proves that the material can be taught.

What about people who need to know more math than that? Well anyone who needs to know more math than that is going to need to know a lot more math than that, and when you get to higher levels, looking at "boring equations" and learning "boring rules" is not going to go away.

Aiming to teach people how to formulate their own solutions sounds clever, but when your problem is fluid dynamics, nobody has the time or energy to rediscover the Navier-Strokes equations on their own. You get your stupid equations, you get your stupid rules on how to use them and you learn to plug numbers in. If you can't handle that, look into doing something else.

The curriculum is fine; if you want to overhaul the educational system it always comes down to finding the best teachers and attracting them. Overhaul that instead.

Anecdote of the Day

Differentiating things in Matlab will often give you fucked up results depending how you phrase the input.

But integrating in Matlab will usually give a fairly clean result that is often identical regardless of input. And one that's usually nicer than what you get manually.

Which is good because integrating is a hell of a lot harder by hand.

P = NP, casually

My startling MSN treatise on what NP is, and its implications.

Crobert: Does anyone believe that P = NP?

Peter: Probably less than the number of people who believe in perpetual energy

Crobert:
Wtf is a non-deterministic turing machine?
Wtf is a turing machine?
It's a gigantic tape ticker right?

Peter: It's a computer that stores data on infinite ticker tape

Crobert:
Ok, I kind of know what a turing machine is
What's a non-deterministic turing machine?

Peter:
There's an artistic representation of a turing machine on Wiki
That wasn't there before
Where's this about non-deterministic turing machines?

Crobert:
NP stands for non-deterministic polynomial
I'm just not interested in complexity theory at all

Peter:
I am not interested in Star Trek
...and I end up reading its Wiki nonetheless

Crobert:
Is Star Trek like Gundam?
Where it works out in theory-
...but not in practice?

Peter:
No, it doesn't work out in theory either
Like, warp 10 was supposed to be unachievable asymptotic bound
Except in one episode they managed to do it in a shuttle

Crobert: Wtf

Peter:
They ended up everywhere in the universe at once
...and began speed evolving into lizard people

Crobert: Wtf

Peter:
Not even kidding
Okay, so non-deterministic turing machines
Pick the correct possibility everytime, assuming it exists

Crobert:
Hax
Time travel => P = NP
You also need to be able to travel time in polynomial time

Peter:
Lmao
Okay, I get it
Non-deterministic polynomial time means
The problem's in polynomial time if you make the right guess
Everytime

Crobert: That's so lame

Peter: Which means solutions can be verified in polynomial time

Crobert: Well yeah

Peter:
So the problems that you can't even verify in polynomial time
I guess those are fucked forever

Crobert: Yes

Peter: k

Crobert: What is such a problem?

Peter: Chess

Crobert: Source

Peter: # ^ Aviezri Fraenkel and D. Lichtenstein (1981). "Computing a perfect strategy for n×n chess requires time exponential in n". J. Comb. Th. A (31): 199–214.

Crobert: o ok

Peter: k, chess is fucked

Crobert: Is chess solved?

Peter: No, it's fucked.

Axiom

Mark has bad taste in movies.

Can't prove it.

But I suppose most people assume it to be true.

Life

J: "I just discovered that solving non-linear modulus equations is NP-complete"
P: "At any other hour, I might be interested"
K: "Why is this surprising? Everything in life always turns out to be NP-complete. Like grocery shopping."
J: "Yeah, path finding!"
P: "I was thinking knapsack problem."
T: "This is why grocery shopping with you guys always takes forever."

Rude awakenings

You know those things that you knew once but forgot later in order to make room for other things? Like that time you deleted common tropical fish illnesses in order to learn about humanist typefaces?

Okay that was probably just me.

There was also that other time I learned calculus and promptly discarded all my knowledge on completing the square ('haha' I said to myself, I'll find my quadratic vertexes through derivatives now!).

Then shit like ∫1/sqrt(3x² - 2x + 1) dx started showing up and suddenly I wished I hadn't started just throwing past mathematical knowledge out willy-nilly.

I can still tell my Fluvals from my Filstars though. Ask me about canister filters sometime.

And my CS adventure of the day

Today I suddenly realized that I could curry in Ruby (I was using the 1.8.6 framework at the time, so I'd have to write my own method).

Currying is basically the concept that you can decompose a function...

e.g. f(x,y,z) = x + 2y + 3z

...into...

g(x) = x + h(y)
where h(y) = 2y + i(z)
where i(z) = 3z

Now obviously I feel a need to show off my new found skills, so I thought to myself, when would this ever be useful? I asked around and nobody seemed to have a good answer. At that point, Google was my only recourse and to my delight it actually returned a thread on Ruby Forum.

Apparently Ruby 1.9.1 has a curry method built-in (also some new syntax, which is nice) and people there were trying to figure out what it's good for.

"It's not difficult at all,
proc {|x, y, z| x + y + z }.curry
returns the proc object equivalent to
proc {|x| proc {|y| proc {|z| x + y + z } } }"

"Uh, how do we call that?
...proc{...}.call(x).call(y).call(z)
What problem does that solve?"

"this one:
plus_five = proc {|x,y,z| x + y + z }.curry.call(2).call(3)
plus_five[10] #=> 15"

I gave a good chortle at this point, because the not retarded way of doing the same thing would just be:

sum = proc{|x,y,z| x + y + x}
plus_five = proc{|x| sum[x,2,3]}
plus_five[10] #=> 15

Which is pretty much what people have been doing since forever in imperative languages. It's also more flexible because plus_five doesn't have to be {|x| sum[x,2,3]}, it could just as easily be {|y| sum[2,y,3]}.

So where does this leave me? Well, I still have no idea what use currying is for. I hope someone can give me a practical example outside of Lisp, because being able to do this:

f = proc{|a,b,c| a + b + c}.curry
g = f[1][2]
puts g[3] #=> Outputs 6

...is actually pretty cool.

Itt: Lies

People often talk about how readable Ruby is, how a person who's never seen a computer program could just about understand what's happening. After all, the clean syntax is what initially attracted me to Ruby. As it turns out though, that's only true if you're writing in the imperative.

For instance, this is how you'd be expected to write a summation function in something like Java:

def summation1 (n)
  if n == 0
    return 0
  else
    return n + summation1(n-1)
  end
end

puts summation1(3) #Outputs 6

That's readable even to the layperson right? Except spoilers: nobody actually uses Ruby that way. Let's try something else then:

def summation2 (n)
  a = Array.new
  n.times {|x| a << x)
  return a.inject {|x,y| x+y }
end

puts summation2(3) #Outputs 6

Okay, I admit that was a bit contrived. But you can see where this is leading:

summation3 = lambda {|x| (1..x).inject {|x,y| x+y }}
p summation3[3] #Outputs 6

What. Did I get hit by the Haskell train or something?

Basically what I'm trying to say is, Ruby is a very concise and elegant language. But with so many shortcuts built in, its general readability does suffer. At least for people not familiar with this kind of functionality. That said, condensing 8 lines of code into 2 only makes me enjoy Ruby more, not less.

Note: That is not a typo in example 3, there is indeed a shortcut for puts. People don't tend to use it so much though, or at least I don't.

Math ∩ Reality

CS.

I don't think I've ever had such an intense argument about Big O.

Specifically whether an algorithm that is performed polynomial time constitutes being efficient.

I take my opposition's argument to be as such, it is considered technically feasible to solve any problem of NP class complexity (see Cobham's Thesis), therefore it could be considered a threshold for defining efficiency. In other words, it's a necessary condition.

My position is that Big O is simply a tool for analysis. Since there's so much context involved, an algorithm can't be considered efficient just because it computes in polynomial time. That is, not sufficient and not even a necessary condition. I'm not going to strawman here, so let's assume whatever program in question isn't racking up unnecessary cycles with a do{ }while(i<99999) or something equally asinine like that.

Case 1: If an algorithm has worst case O(k^n), but the chances of the worst case are 1 in a thousand, it may still be practical to take it over something with with a fixed O(n^2) time. Plus, in real life you can often choose to avoid worst case scenarios. For instance, a set may be sorted initially with a Quicksort implementation, but additional elements are added by Insertion.

Case 2: Coefficients are omitted from Big O, that's understandable from a mathematical stand point. From optimizing the algorithm (not with respect to hardware, just to itself), you might shave off a fraction of the computational time, but if you switch processors from a 386 to a Yorkfield cluster, the time is going to be reduced by magnitudes. That is what the coefficient represents. But you can't ignore coefficients in real life. Say your hardware performs a certain operation much faster than others and you're getting bottlenecked, it might be worthwhile to organize small chunks of your input even with an exponential time function because you're going to gain back that time in the end. In similar fashion, say you're bottle necked by memory and not processing power, it might make sense to write something that takes O(k^n) computing power and O(n log n) memory as opposed to something that takes O(n^2) of both.

As a minor point, my opponent argues that in an infinite set, polynomial time will always trump exponential time and for small sets efficiency doesn't matter anyways. But see, efficiency isn't relevant for small sets because the coefficient is 10 to the power of such a large magnitude (unless you're using a Celeron LOLOL) that it dwarfs everything else. If the coefficient makes that big of an impact, then it stands to say there may still be a large set less than infinity that computes faster with a routine in exponential time than one in polynomial time, depending on how it takes advantage of the hardware.

And realistically speaking, if your set is large enough to seriously look at Big O and your best case is O(n^3), you're probably in trouble anyways. Not to say you're not just as screwed with O(k^n), but now I'm back at the shot in the head vs shot in the chest analogy (see: last post).

For the record, the debate was ended by, "you see, I don't care about real life".

1. I know both Insertion sort and Quicksort are polynomial time operations. What I'm saying is, the latter averages O(n log n) while the former averages O(n^2), yet the former remains more efficient in some cases.

2. I also know Big O usually only refers to worst case, but lets not miss the forest for the trees shall we?

3. That is not to say computational analysis is useless. That's like saying what's the point of ideal gas law if gases aren't ideal? Well, if you're looking at nitrogen at 1 atm, 20°C you can guess that it's going to be a fairly accurate model. Ramp it up 400atm though, and it might be a good idea to break out the compressibility charts. ;)

4. I just wanted to put that chem analogy there. The fact is, the majority of the time polynomial time is preferable to exponential time in every way and Big O holds. But that's not what I'm arguing against.

The road to all healing begins

...with just accepting that dy/dx is a fraction.

I know I've jeered my physics prof in the past for doing such a thing, but I'm seeing the benefits of his approach. For instance, now it doesn't take any special manipulations to find error, just multiply both sides by dx (or ∂x, depending)!

No more stupid math arguments with my roommate at 1 in morning! It's like I've fully declared my intention to ignore all proper conventions in favour of shortcuts and he gets the smug satisfaction that I'm not doing real math.

Instead I have stupid arguments about American automakers at 1 in the morning. Which ended with an analogy relating GM and Ford to a man getting shot in the head and a man getting shot in the chest, respectively.

Semantics.

They're both screwed.

As an addendum, my roommate is like a puritan when it comes to math. As in accepting nothing other than set theory to be "real" math. That's like saying Ruby isn't real programming because I'm not personally ferrying bits around like a deliveryman.

On math and Key

If I were to plot my feelings of despair and sadness versus time as I watch Clannad, the plot would only span R² whereby it is sad everywhere and the level of despair resembles Dirichlet's function.

I talk like this in real life too.

This really is the best way to start a conversation:

crobert [{}]:
what the fuck; if you have nonunique decimal expansion then the tree isnt bijective with the set of all reals

Alternatively, this is the reason I'm not in the Pure Math Club.

...ergo propter hoc

So here's my issue, what is the functional difference between cum hoc ergo propter hoc and post hoc ergo propter hoc?
_____

crobert: post = after, cum = with
crobert: post implies causation while cum just implies a correlation
Peter: thank you
Peter: no, I meant what is the functional difference
crobert: post needs a strict chronological sequencing
crobert: while in cum they just need to be related
Peter: in what example
Peter: would there not be some kind of chronological sequence
Peter: if causation were implied?
_____

Naturally, Wikipedia was the first source to be consulted.
_____

crobert: ok i'll just steal one from wiki
crobert:

"Sleeping with one's shoes on is strongly correlated with waking up with a headache.
Therefore, sleeping with one's shoes on causes headache. "

crobert: here you have "sleeping" and "with shoes on"
crobert: one doesnt happen after another
crobert: in fact, they're going on at the same time
crobert: as opposed to

"i saw a black cat, then crashed my car. therefore seeing black cats cause car crashse"

Peter: there is clearly a chronological sequence
Peter: Sleep with shoes ---> wake up with head ache
Peter: arrow is time

crobert: ok say you had
crobert: number of lung cancer cases has been steadily increasing
crobert: and
crobert: number of cigarettes sold has been steadily increasing
crobert: so you falsely conclude that they are related
crobert: one doesnt necessarily happen after the other
_____

So basically, I'm not seeing it. If you're implying that a causes b, then D[b(t)] must equal kD[a(t+x)]. Where t = time and {x|x ∈ R, x > 0}. The k could even be a function of a(t) or something, but you can't just say they're both positive and therefore correlate. If your k value ends up looking like a Weierstrass function, your correlation is garbage in the first place without even getting into the causation part.

Any philosophers reading this, feel free to drop me a line.

Unless your name is Kant. In which case: don't.

update:
_____
Peter: I thought of something
Peter: dead people are old
Peter: therefore time causes death
Peter: I think this is the only way around the chronological factor
crobert: <_<
crobert: you're just thinking it wrong
crobert: it works, you just think it doesnt
crobert: you have two simultaneous events
crobert: the fallacy is that one is dependent on the other
Peter: how can a cause b if they both happen at once
Peter: unless one of them is time
crobert: protip: it doesnt
crobert: that's why it's a fallacy
Peter: this is a shitty fallacy
...
crobert: what part of it dont you get
crobert: you understand that it's a fallacy right <_<
Peter: so cum hoc is the universal set
crobert: yeah i sort of said that already
Peter: but pos hoc' = half diminished
Peter: That's the crux of my issue
Peter: maybe I'm looking at this wrong
Peter: maybe it's stating the obvious
Peter: AKA 2 simultaneous events can't cause each other because it's simultaneous
Peter: AKA this is a shitty fallacy
crobert: all fallacies are shitty
crobert: give me a nonshitty fallacy
Peter: naturalistic fallacy is alright
Peter: I am going to eat my GM foods and enjoy them