I really like this. I think there’s two different vibes here I like: (1) evaluation of arguments should compare to other possible arguments within some reference class rather than being based solely on the properties of the argument, and (2) more tangentially, the truth value of a system of statements need not just be “true” or “false”, “consistent” or “inconsistent”.
I don’t really have much more to say about (1) other than that I liked your explanations of the loopy blue universe and tessellating beetles. Both are absurd, but have explanatory power. I would like to explore more about the relationship of arguments to their reference classes and the structure of possible argument reference classes.
I like thinking about (2) as digraphs where each node is a statement and arrows are references to other statements, then each statement has a set of possible truth values which either makes the graph inconsistent or not. Some graphs may have a single, or multiple consistent sets of truth values, but there is more to be said about inconsistent ones than merely that they are inconsistent. If at each iteration you “updated” the truth value for the node corresponding to each inconsistent arrow, you would get patterns of propagation based on the starting state. Further, an obvious way to force an inconsistent graph is to have cycles in the graph with an odd number of “bit flip” arrows, which assert some reference is false, and so must be false if the referent is true. Then you can ask about the other possible structures which introduce forced inconsistency.
( I’m sure people have focused on this, but I’m not sure what it would be called… )
One application for this might be that if you could throw out all inconsistency forcing structures you could (perhaps) find the subset of programs for which the halting problem doesn’t apply.
I like your “tralsity” terminology. I think I was thinking about this differently from you. I was thinking from a computer science or graph theory perspective, where the “solution” to an argument would b the set of families of state transitions for statements when the truth values are updated iteratively.
This is more related to arguments, systems of statements, being valid or invalid, tautological, or contradictory… although I think the ideas would need to be extended in some way to apply to arguments with cyclic form, as opposed to the more normal form of having premises and conclusions.
It seems like tralsity, which you are talking about, is more focused on assigning valid tralse values to statements regardless of them having logical contradictions. I think this is an interesting thing to be trying to do. I think I prefer the argument structure and state transition approach because it would point out which states are valid and what is causing the state to be invalid when it is invalid.
So rather than “this statement is false” going to “x=-x” and being solved as 0, it would go to “x<--x” and the solution would be the sequence ”...-1,1,-1,1,-1,1...” which is unrolled from a state transition that might look something like {( x=1 --> x=-1 ), ( x=-1 --> x=1)}, or something similar. That creates a single connected transition graph with two nodes, one representing the state “x=1” and one representing the state “x=-1″ with each pointing at the other. And that is the only system of transitions this argument can take. But other arguments might have disconnected transition graphs. Only states in transition graphs that only point to themselves would be valid, but the different kinds of subgraphs with more than one node would tell you about the way they are invalid.
Haha… sorry, this isn’t fully thought through so I apologize if it isn’t clear or easy to follow.
I think there’s probably a relationship between this idea of assigning tralsity to states vs looking at transition graphs for arguments, but I’m not sure exactly what that relationship would be.
It is reminding me of the book “Topoi: the categorical analysis of logic” which I have not gotten into far enough to know if it is related at all or not.
The halting problem is the problem of looking at the structure of a program and using it to determine whether or not the program would halt if you ran it. There is a proof by contradiction that you can’t have such a program (from the wikipedia page for the halting problem):
def g() → None:
if halts(g):
loop_forever()
This is a contradiction because if halts returns true then it shouldn’t have, because g will loop forever based on halts returning true, but if halts returns false then g will return None and halt, and so halts should have returned true.
But learning about this annoyed me, because it’s obvious what’s going on, halts is being forced into self reference, and a contradiction is only forced if halts is forced to return true or false. If it instead returned “I am embedded in a program with a 2 state logical contradiction” then that would be a better answer.
I think this is also Russell’s paradox in set theory, and might be related to Godel’s incompleteness. Basically the thing seems to be “self referential statements break our languages” and my feeling is just “create your languages so they talk about the nature of self reference! You’re creating a problem where there does not need to be a problem”… but obviously I haven’t fully understood the ideas or thought through all the implications, so it would be rash for me to make such a statement, but it is a feeling that I get.
I really like this. I think there’s two different vibes here I like: (1) evaluation of arguments should compare to other possible arguments within some reference class rather than being based solely on the properties of the argument, and (2) more tangentially, the truth value of a system of statements need not just be “true” or “false”, “consistent” or “inconsistent”.
I don’t really have much more to say about (1) other than that I liked your explanations of the loopy blue universe and tessellating beetles. Both are absurd, but have explanatory power. I would like to explore more about the relationship of arguments to their reference classes and the structure of possible argument reference classes.
I like thinking about (2) as digraphs where each node is a statement and arrows are references to other statements, then each statement has a set of possible truth values which either makes the graph inconsistent or not. Some graphs may have a single, or multiple consistent sets of truth values, but there is more to be said about inconsistent ones than merely that they are inconsistent. If at each iteration you “updated” the truth value for the node corresponding to each inconsistent arrow, you would get patterns of propagation based on the starting state. Further, an obvious way to force an inconsistent graph is to have cycles in the graph with an odd number of “bit flip” arrows, which assert some reference is false, and so must be false if the referent is true. Then you can ask about the other possible structures which introduce forced inconsistency.
( I’m sure people have focused on this, but I’m not sure what it would be called… )
One application for this might be that if you could throw out all inconsistency forcing structures you could (perhaps) find the subset of programs for which the halting problem doesn’t apply.
Comment erased
I like your “tralsity” terminology. I think I was thinking about this differently from you. I was thinking from a computer science or graph theory perspective, where the “solution” to an argument would b the set of families of state transitions for statements when the truth values are updated iteratively.
This is more related to arguments, systems of statements, being valid or invalid, tautological, or contradictory… although I think the ideas would need to be extended in some way to apply to arguments with cyclic form, as opposed to the more normal form of having premises and conclusions.
It seems like tralsity, which you are talking about, is more focused on assigning valid tralse values to statements regardless of them having logical contradictions. I think this is an interesting thing to be trying to do. I think I prefer the argument structure and state transition approach because it would point out which states are valid and what is causing the state to be invalid when it is invalid.
So rather than “this statement is false” going to “x=-x” and being solved as 0, it would go to “x<--x” and the solution would be the sequence ”...-1,1,-1,1,-1,1...” which is unrolled from a state transition that might look something like {( x=1 --> x=-1 ), ( x=-1 --> x=1)}, or something similar. That creates a single connected transition graph with two nodes, one representing the state “x=1” and one representing the state “x=-1″ with each pointing at the other. And that is the only system of transitions this argument can take. But other arguments might have disconnected transition graphs. Only states in transition graphs that only point to themselves would be valid, but the different kinds of subgraphs with more than one node would tell you about the way they are invalid.
Haha… sorry, this isn’t fully thought through so I apologize if it isn’t clear or easy to follow.
I think there’s probably a relationship between this idea of assigning tralsity to states vs looking at transition graphs for arguments, but I’m not sure exactly what that relationship would be.
It is reminding me of the book “Topoi: the categorical analysis of logic” which I have not gotten into far enough to know if it is related at all or not.
Alas, so much math, so little time.
Comment erased
The halting problem is the problem of looking at the structure of a program and using it to determine whether or not the program would halt if you ran it. There is a proof by contradiction that you can’t have such a program (from the wikipedia page for the halting problem):
This is a contradiction because if halts returns true then it shouldn’t have, because g will loop forever based on halts returning true, but if halts returns false then g will return None and halt, and so halts should have returned true.
But learning about this annoyed me, because it’s obvious what’s going on, halts is being forced into self reference, and a contradiction is only forced if halts is forced to return true or false. If it instead returned “I am embedded in a program with a 2 state logical contradiction” then that would be a better answer.
I think this is also Russell’s paradox in set theory, and might be related to Godel’s incompleteness. Basically the thing seems to be “self referential statements break our languages” and my feeling is just “create your languages so they talk about the nature of self reference! You’re creating a problem where there does not need to be a problem”… but obviously I haven’t fully understood the ideas or thought through all the implications, so it would be rash for me to make such a statement, but it is a feeling that I get.