durkadurka, you only believe in free will because....(LC)
I don't think that people realize how much philosophy actually influences broader social patterns and the development of thought over time. It may not be immediate, but there is a very strong and noticeable influence on even the most modest of investigations.
For example, considerations of free will are presently leading to research in neuroscience, cognitive science, marketing, ethics, and other related areas to responsibility and decision making.
Philosophy really needs a PR campaign because your view is not uncommon. The problem is that it's largely ignorant of the influence of philosophy but perhaps it's not your fault. Philosophy has a very bad image and it's mostly undeserved.
Part of this is why so many students flock to undergraduate philosophy courses expecting an easy A because it's just opinions and bull****ting, right? They hear the sometimes 'ridiculous' things that philosophers care about and try to argue; they can do that: how hard could it be? Then they get a C and wonder what the hell just happened to them.
For example, considerations of free will are presently leading to research in neuroscience, cognitive science, marketing, ethics, and other related areas to responsibility and decision making.
Philosophy really needs a PR campaign because your view is not uncommon. The problem is that it's largely ignorant of the influence of philosophy but perhaps it's not your fault. Philosophy has a very bad image and it's mostly undeserved.
Part of this is why so many students flock to undergraduate philosophy courses expecting an easy A because it's just opinions and bull****ting, right? They hear the sometimes 'ridiculous' things that philosophers care about and try to argue; they can do that: how hard could it be? Then they get a C and wonder what the hell just happened to them.
I'm not saying that they don't know the difference. I'm saying that YOU think I was making a claim about the descriptive fact that they actually use it. You think that I was saying that they don't use the term. That is false. I was saying that they shouldn't use it because it's just a rhetorical term. They do know the difference between descriptive and prescriptive but they still shouldn't use that term.
I'm suggesting that you've made a mistake for my prescriptive claim thinking that it was descriptive.
I'm suggesting that you've made a mistake for my prescriptive claim thinking that it was descriptive.
You said: "No, the pessimist only applies to incompatibilists IF the deterministic thesis is true. Basically, it's some rhetorical word for the incompatibilist. Calling them a pessimist is unfair. They'd call themselves realists."
It's dead obvious you did not know that it was a near canonical term for a philosophical position. Just like you didn't know there was more than one Strawson who wrote a paper about free will in the last 50 years. "They'd call themselves realists" you said. WHAT? You were really making your "prespective" case there and not not knowing what the **** you were talking about?
That you would say they shouldn't use the term 'pessimistic incompatibilism' is BAT**** INSANE. The label is perfectly appropriate; what could you possibly want out of a philosophical label? I was just about to make the mistake of citing 10 examples of labels for philosophical positions which have a qualifier that I didn't like, but then I realized at this point you are nothing above an idiot.
"prespective" = "prescriptive", typo
That's known as the fallacy of ignorance.
Because I don't know x, then x is false. Fallacy.
Your position may be different in that you may mean: If x is unknowable, then x does not exist.
This is different but still begging the question: why is knowability a necessary condition for existence?
Because I don't know x, then x is false. Fallacy.
Your position may be different in that you may mean: If x is unknowable, then x does not exist.
This is different but still begging the question: why is knowability a necessary condition for existence?
Code:
function findvalue(bean_count) if (bean_count % 3) then return 0 else return 1 endif end function choosebeans(bean_count) take_one = findvalue(bean_count - 1) take_two = findvalue(bean_count - 2) if (take_one > take_two) then return 1 else if (take_two > take_one) then return 2 else return ceiling(random() * 2) endif end
So this meets the criteria.
The if/then program doesn't have any internal representation of the actions. In terms of the action of choosing one bean, that program contains nothing showing what it means, what it looks like, what its value is, etc.
We can start with as few as 2 beans, since that is the minimum required to give more than one action.
Emergence is complexity due to interaction between simple parts that change the future actions of the parts, along with the entire system of simple parts causing stuff that the simple stuff cannot cause by themselves.
The second part is the more important here. It causes something completely new that could not a priori be predicted purely by looking at the parts. There is no a priori modelling possible. There is something new that can be argued
The second part is the more important here. It causes something completely new that could not a priori be predicted purely by looking at the parts. There is no a priori modelling possible. There is something new that can be argued
Every single on of your examples and arguments has led to you making an excellent counterargument to what you appear to by trying to argue.
Seriously, you make decent intuitional first statements, but it is like after that you just want to be abused.
Seriously, you make decent intuitional first statements, but it is like after that you just want to be abused.
I guess I don't see how a chess simulation "significantly resembles or corresponds" to the action of moving a chess piece then. It's not like the computer is modeling the action of moving your hand, picking up a chess piece, and moving it to another square. It sounds like this is what you are wanting my simple circuit to model with respect to turning on a light.
I know. I was pointing out the fact that you reworded "turning on a light" to "state of the light being on/off" simply so you can say: "See! it's not even an action!"
An action is a transition from one state to another, a single state is not itself an action. Nothing in your circuit represents the transition from on to off, nor the transition from off to on. A chess computer does recognize the transition from the initial board position to the final board position, including the game rules restricting the movement of various pieces (and the alternating movement of white and black).
It is a fundamental aspect of information theory that the logic of something like a chess game can be programmed into a circuit. Again, that's how computers work. If the game situation is simple enough (like say there are only 2 legal moves and checkmate follows), it is trivial to program the logic of such a game into a circuit. And it would only take a simple variation of my light bulb circuit to program this.
OK, I'm really really curious as to what defining criteria you are using for a model then. As in, how do you tell whether X is a model or not a model.
Again, what the heck distinguishes a model from not a model then. It's trivial to program a circuit (a simple circuit; like mine with some simple variations) to analyze a situation where there are two outcomes, the values of these outcomes, and the actions of arriving at those outcomes (e.g. checkmate/draw). This is like the entire point of the field of information theory. The only reason you would need a full computer to model the chess game is if it got more complicated (and then, you'd obviously just be adding more circuit components).
How on earth does a blank picture meet any sort of defining criteria for a map?
Isn't this the reasoning you're using for your circuit?
I'm not clear on where it's hard to parse. A choice would be something like:
The model for taking one bean here is "bean_count - 1" and the model for taking two beans is "bean_count - 2". Each modeled action is assigned a value. The values of the actions are then weighed, and the action with higher value is picked.
So this meets the criteria.
The if/then program doesn't have any internal representation of the actions. In terms of the action of choosing one bean, that program contains nothing showing what it means, what it looks like, what its value is, etc.
Code:
function findvalue(bean_count) if (bean_count % 3) then return 0 else return 1 endif end function choosebeans(bean_count) take_one = findvalue(bean_count - 1) take_two = findvalue(bean_count - 2) if (take_one > take_two) then return 1 else if (take_two > take_one) then return 2 else return ceiling(random() * 2) endif end
So this meets the criteria.
The if/then program doesn't have any internal representation of the actions. In terms of the action of choosing one bean, that program contains nothing showing what it means, what it looks like, what its value is, etc.
I would say that the function call of findvalue and the "else" clause are all extraneous. Do you agree?
Code:
function findvalue(bean_count) if (bean_count % 3) then return 0 else return 1 endif end function choosebeans(bean_count) take_one = findvalue(bean_count - 1) take_two = findvalue(bean_count - 2) if (take_one > take_two) then return 1 else if (take_two > take_one) then return 2 else return ceiling(random() * 2) endif end
We could also get rid of the variables. It's the process that matters. Specifically (in terms of a typical computer) using some process to create an object in memory to meaningfully represent each action (modeling), and then running some separate process on the basis of these objects in memory to determine a particular action from the group (evaluation), and only then the actual instruction to take the action.
I'm not sure what you mean by this.
You were the one who reworded it. Go back and read the posts - I objected that a switch in a particular position isn't a model of an action, you claimed that it is a model of a state.
An action is a transition from one state to another, a single state is not itself an action. Nothing in your circuit represents the transition from on to off, nor the transition from off to on. A chess computer does recognize the transition from the initial board position to the final board position, including the game rules restricting the movement of various pieces (and the alternating movement of white and black).
The "game" you're discussing isn't chess.
Either a "simple" circuit is capable of containing more information than a simple "on/off," or you're wrong.
It's a flat representation of an area. It's just like other maps, except with fewer details.
Isn't this the reasoning you're using for your circuit?
Isn't this the reasoning you're using for your circuit?
madnak,
If I wrote a computer program that contained the logic:
If switch = closed, then light = on.
If switch = open, then light = off.
Would it be modeling the action of turning on/off a light? Why or why not?
Edit: As to the "weigh and rank" part of your definition you gave earlier for choice.... If my program stated to rank light = on higher if switch = closed but to rank light = off higher if switch = open, it is weighing and ranking the potential actions right?
If not, can you contrast this with a computer program that ranks move Y1 higher if the board is in position X1 vs. ranking move Y2 higher if board is in position X2, showing why the chess computer is "weighing and ranking" but the light program isn't?
If I wrote a computer program that contained the logic:
If switch = closed, then light = on.
If switch = open, then light = off.
Would it be modeling the action of turning on/off a light? Why or why not?
Edit: As to the "weigh and rank" part of your definition you gave earlier for choice.... If my program stated to rank light = on higher if switch = closed but to rank light = off higher if switch = open, it is weighing and ranking the potential actions right?
If not, can you contrast this with a computer program that ranks move Y1 higher if the board is in position X1 vs. ranking move Y2 higher if board is in position X2, showing why the chess computer is "weighing and ranking" but the light program isn't?
By this, I mean that I misread the code.
I do, anything purely notational can be dumped.
We could also get rid of the variables. It's the process that matters. Specifically (in terms of a typical computer) using some process to create an object in memory to meaningfully represent each action (modeling), and then running some separate process on the basis of these objects in memory to determine a particular action from the group (evaluation), and only then the actual instruction to take the action.
We could also get rid of the variables. It's the process that matters. Specifically (in terms of a typical computer) using some process to create an object in memory to meaningfully represent each action (modeling), and then running some separate process on the basis of these objects in memory to determine a particular action from the group (evaluation), and only then the actual instruction to take the action.
Code:
function findvalue(bean_count) if (bean_count % 3) then return 0 else return 1 endif end function choosebeans(bean_count) take_one = findvalue(bean_count - 1) take_two = findvalue(bean_count - 2) if (take_one > take_two) then return 1 else if (take_two > take_one) then return 2 else return ceiling(random() * 2) endif end
Code:
function findvalue(bean_count) if (bean_count % 3) then return 0 else return 1 endif end function choosebeans(bean_count) take_one = findvalue(bean_count - 1) take_two = findvalue(bean_count - 2) if (take_one > take_two) then return 1 else return 2 endif end
Code:
function findvalue(bean_count) if (bean_count % 3) then return 0 else return 1 endif end function choosebeans(bean_count) if (bean_count = 3) then take_one = findvalue(3 - 1) take_two = findvalue(3 - 2) if (take_one > take_two) then return 1 else return 2 endif endif if (bean_count = 2) then take_one = findvalue(2 - 1) take_two = findvalue(2 - 2) if (take_one > take_two) then return 1 else return 2 endif endif if (bean_count = 1) then take_one = findvalue(1 - 1) take_two = findvalue(1 - 2) if (take_one > take_two) then return 1 else return 2 endif endif end
Code:
function choosebeans(bean_count) if (bean_count = 3) then take_one = 0 take_two = 0 if (take_one > take_two) then return 1 else return 2 endif endif if (bean_count = 2) then take_one = 0 take_two = 1 if (take_one > take_two) then return 1 else return 2 endif endif if (bean_count = 1) then take_one = 1 take_two = 0 if (take_one > take_two) then return 1 else return 2 endif endif end
Code:
function choosebeans(bean_count) if (bean_count = 3) then if (0 > 0) then return 1 else return 2 endif endif if (bean_count = 2) then if (0 > 1) then return 1 else return 2 endif endif if (bean_count = 1) then if (1 > 0) then return 1 else return 2 endif endif end
Code:
function choosebeans(bean_count) if (bean_count = 3) then return 2 endif if (bean_count = 2) then return 2 endif if (bean_count = 1) then return 1 endif end
Here.
You didn't just remove the function call, you removed both the model ("bean_count - 1") and the evaluation (assigning values based on an internal process) in one fell swoop.
The program isn't assigning values based on the analysis of a model. The values are hardcoded.
If you want to remove the function call, you have to preserve the important processing, like so:
And of course, you'd need an interpreter or compiler that would preserve the relevant processing. Stage 2 probably makes that hopeless - virtually any program parsing this code is going to remove choice as a superfluous element.
You didn't just remove the function call, you removed both the model ("bean_count - 1") and the evaluation (assigning values based on an internal process) in one fell swoop.
The program isn't assigning values based on the analysis of a model. The values are hardcoded.
If you want to remove the function call, you have to preserve the important processing, like so:
Code:
if (bean_count = 3) then if ((bean_count - 1) % 3) then take_one = 0 else take_one = 1 endif if ((bean_count - 2) % 3) then take_two = 0 else take_two = 1 endif if (take_one > take_two) then return 1 else return 2 endif endif
And I'd love to hear how a simple circuit models the logic, consequences, and transition.
You mean like the transition from light on -> off or light off -> on?
I gave Aaron a simple representation of a model for a transition. It included three important elements. The simplest expression is the following: "3 - 1 = 2."
It has a representation of the final condition (2), a representation of the initial condition (3), and a representation of the route by which the initial condition leads to the final condition (- 1).
I won't say that all modeled actions necessarily include each of these elements, but it's a damned good start. Show me where your simple circuit stores each of these elements.
So when you have an end game in chess where there are only 2 legal moves and one results in mate, it stops being chess...
It is capable of containing more information, obviously.
What area is it representing, and what information does it contain to make it a map. I'm not seeing how a blank pictures meets any defining criteria for a map, and what this has to to with my reasoning for the circuit.
A blank image is like a map in that it is also a flat image. However, it doesn't contain any information corresponding to any area, so you don't want to call it a map.
Similarly, a circuit may be superficially similar to a model composed of circuits. But it doesn't contain any information corresponding to any action, so I don't want to call it a model of an action.
Here.
You didn't just remove the function call, you removed both the model ("bean_count - 1") and the evaluation (assigning values based on an internal process) in one fell swoop.
The program isn't assigning values based on the analysis of a model. The values are hardcoded.
You didn't just remove the function call, you removed both the model ("bean_count - 1") and the evaluation (assigning values based on an internal process) in one fell swoop.
The program isn't assigning values based on the analysis of a model. The values are hardcoded.
Edit: As to the "weigh and rank" part of your definition you gave earlier for choice.... If my program stated to rank light = on higher if switch = closed but to rank light = off higher if switch = open, it is weighing and ranking the potential actions right?
The actual action in this case is the moving of the switch - that is what must be assigned a value.
If not, can you contrast this with a computer program that ranks move Y1 higher if the board is in position X1 vs. ranking move Y2 higher if board is in position X2, showing why the chess computer is "weighing and ranking" but the light program isn't?
The computer is ranking an action - the transition from an initial position to a final position by means of a process. If the computer is only evaluating the initial position and the final position, without modeling the process by which one leads to the other, then it isn't choosing.
If a chess program had every possible board position analyzed (with the results hardcoded), then it wouldn't be choosing.
I don't consider choice a matter of inputs and outputs, but a matter of processing. It is theoretically possible for a computer program to output the same results that Deep Blue outputs, without making choices. (Even though I believe the real Deep Blue makes choices.)
Also a behavioral zombie of a human, etc.
The library of positions is used as an aid in evaluating moves.
If a chess program had every possible board position analyzed (with the results hardcoded), then it wouldn't be choosing.
I don't consider choice a matter of inputs and outputs, but a matter of processing. It is theoretically possible for a computer program to output the same results that Deep Blue outputs, without making choices. (Even though I believe the real Deep Blue makes choices.)
Also a behavioral zombie of a human, etc.
If a chess program had every possible board position analyzed (with the results hardcoded), then it wouldn't be choosing.
I don't consider choice a matter of inputs and outputs, but a matter of processing. It is theoretically possible for a computer program to output the same results that Deep Blue outputs, without making choices. (Even though I believe the real Deep Blue makes choices.)
Also a behavioral zombie of a human, etc.
Also, I guess I'm having a hard time understanding what you mean by
We could also get rid of the variables. It's the process that matters.
Also, I guess I'm having a hard time understanding what you mean by
When I got rid of the variables, you told me I did it wrong. Can you rewrite the code so that the variables are removed?
When I got rid of the variables, you told me I did it wrong. Can you rewrite the code so that the variables are removed?
Code:
function choosebeans(bean_count) if (countbeans() = 3) then if ((3 - 1) % 3) then if ((3 - 2) % 3) then return ceiling(random() * 2) else return 2 endif else if ((3 - 2) % 3) then return 1 else return ceiling(random() * 2) endif endif endif if (countbeans() = 2) then if ((2 - 1) % 3) then if ((2 - 2) % 3) then return ceiling(random() * 2) else return 2 endif else if ((2 - 2) % 3) then return 1 else return ceiling(random() * 2) endif endif endif if (countbeans() = 1) then if ((1 - 1) % 3) then if ((1 - 2) % 3) then return ceiling(random() * 2) else return 2 endif else if ((1 - 2) % 3) then return 1 else return ceiling(random() * 2) endif endif endif end
Out of curiosity, why do you keep putting in random statements? It feels like you're intentionally making things more complicated, whereas the stated goal is simplicity.
And why do you introduce a "countbeans" function when you have the bean_count?
And why do you introduce a "countbeans" function when you have the bean_count?
Code:
function choosebeans(bean_count) if (countbeans() = 3) then if ((3 - 1) % 3) then if ((3 - 2) % 3) then return ceiling(random() * 2) else return 2 endif else if ((3 - 2) % 3) then return 1 else return ceiling(random() * 2) endif endif endif if (countbeans() = 2) then if ((2 - 1) % 3) then if ((2 - 2) % 3) then return ceiling(random() * 2) else return 2 endif else if ((2 - 2) % 3) then return 1 else return ceiling(random() * 2) endif endif endif if (countbeans() = 1) then if ((1 - 1) % 3) then if ((1 - 2) % 3) then return ceiling(random() * 2) else return 2 endif else if ((1 - 2) % 3) then return 1 else return ceiling(random() * 2) endif endif endif end
Code:
function choosebeans(bean_count) if (bean_count = 2) then if ((2 - 1) % 3) then if ((2 - 2) % 3) then return 2 endif else if ((2 - 2) % 3) then return 1 endif endif endif if (bean_count = 1) then if ((1 - 1) % 3) then if ((1 - 2) % 3) then return 2 endif else if ((1 - 2) % 3) then return 1 endif endif endif end
What if I perform the subtractions?
Code:
function choosebeans(bean_count) if (bean_count = 2) then if (1 % 3) then if (0 % 3) then return 2 endif else if (0 % 3) then return 1 endif endif endif if (bean_count = 1) then if (0 % 3) then if (-1 % 3) then return 2 endif else if (-1 % 3) then return 1 endif endif endif end
Feedback is used for internal purposes. LEARN MORE