Just pointing out that language tends to describe things as having properties. For example, "the flag is red." But that isn't really accurate; it's more that we perceive the flag as red. The flag doesn't actually possess the property of redness.

Just pointing out that language tends to describe things as having properties. For example, "the flag is red." But that isn't really accurate; it's more that we perceive the flag as red. The flag doesn't actually possess the property of redness.

Just pointing out that language tends to describe things as having properties. For example, "the flag is red." But that isn't really accurate; it's more that we perceive the flag as red. The flag doesn't actually possess the property of redness.

Just pointing out that language tends to describe things as having properties. For example, "the flag is red." But that isn't really accurate; it's more that we perceive the flag as red. The flag doesn't actually possess the property of redness.

Have some thoughts, which might be way off. But interested in your response. It seems to me that "hard-to-vary" is itself the criterion that a theory should be as programmable as possible. As you note, the goal of a theory should be to make it as explicit as possible, and a program is explicitness in its most complete form. Any theory with ambiguous components automatically has a breaking point that is changeable without detection. A programmable theory has strict causal relations all the way from the axioms to the prediction, which makes any change to the components detectable. In other words: a theory is hard to vary to the extent that its components and the couplings between them can be specified as a program. If a theory is vague, you cannot tell when it has been varied.

This gives a concrete operationalization. A breaking point is any place in the formalization where the chain stops being programmable: a primitive with no implementable type, a coupling between components that cannot be specified, or a step that requires implicit theories to fill the explanatory gaps. A mathematical theory with no remaining gaps has zero breaking points and is maximally hard to vary. A theory in natural language is already worse, because words carry ambiguity and vary from mind to mind. This does not rule out better and worse theories in natural language, since we can use more or less ambiguous words and relations. But it does create a hierarchy of hard-to-vary explanations, where the share of the explanation that is programmable, or at least unambiguous, forms the basis for the criterion.

This is probably too crude a formalization. But evaluating the two theories of Demeter's emotions and axial tilt as explanations, you could check how much of each is programmable. Detecting seasons is programmable in both cases through temperature and changes in weather. Demeter's emotions and the causal link from them to the weather, which is the entire explanation, are not programmable. In the axial tilt theory, every component is. So on this measure Demeter scores 25% and axial tilt scores 100%.

Have some thoughts, which might be way off. But interested in your response. It seems to me that "hard-to-vary" is itself the criterion that a theory should be as programmable as possible. As you note, the goal of a theory should be to make it as explicit as possible, and a program is explicitness in its most complete form. Any theory with ambiguous components automatically has a breaking point that is changeable which is hard to detect. A programmable theory has strict causal relations all the way from the axioms to the prediction, which makes any change to the components detectable. In other words: a theory is hard to vary to the extent that its components and the couplings between them can be specified as a program. If a theory is vague, you cannot tell when it has been varied.

This might give a concrete operationalization. A breaking point is any place in the formalization where the chain stops being programmable: a primitive with no implementable type, a coupling between components that cannot be turned into a function, or just a step that requires implicit theories to fill the explanatory gaps. A mathematical theory with no remaining gaps has zero breaking points and is maximally hard to vary. A theory in natural language is already worse, because words carry ambiguity and vary from mind to mind. This does not rule out better and worse theories in natural language, since we can use more or less ambiguous words and relations. But it does create a hierarchy of hard-to-vary explanations, where the share of the explanation that is programmable, or at least unambiguous, forms the basis for measuring the "hard-to-vary" criterion.

This is probably too crude a formalization. But evaluating the two theories of Demeter's emotions and axial tilt as explanations, you could check how much of each is programmable. Detecting seasons is programmable in both cases through temperature and changes in weather. Demeter's emotions and the causal link from them to the weather, which is the entire explanation, are not programmable. In the axial tilt theory, every component is. So on this measure Demeter scores 25% and axial tilt scores 100%.

It seems to me that "hard-to-vary" is itself the criterion that a theory should be as programmable as possible. As you note, the goal of a theory should be to make it as explicit as possible, and a program is explicitness in its most complete form. Any theory with ambiguous components automatically has a breaking point that is changeable without detection. A programmable theory has strict causal relations all the way from the axioms to the prediction, which makes any change to the components detectable. In other words: a theory is hard to vary to the extent that its components and the couplings between them can be specified as a program. If a theory is vague, you cannot tell when it has been varied.

This gives a concrete operationalization. A breaking point is any place in the formalization where the chain stops being programmable: a primitive with no implementable type, a coupling between components that cannot be specified, or a step that requires implicit theories to fill the explanatory gaps. A mathematical theory with no remaining gaps has zero breaking points and is maximally hard to vary. A theory in natural language is already worse, because words carry ambiguity and vary from mind to mind. This does not rule out better and worse theories in natural language, since we can use more or less ambiguous words and relations. But it does create a hierarchy of hard-to-vary explanations, where the share of the explanation that is programmable, or at least unambiguous, forms the basis for the criterion.

This is probably too crude a formalization. But evaluating the two theories of Demeter's emotions and axial tilt as explanations, you could check how much of each is programmable. Detecting seasons is programmable in both cases through temperature and changes in weather. Demeter's emotions and the causal link from them to the weather, which is the entire explanation, are not programmable. In the axial tilt theory, every component is. So on this measure Demeter scores 25% and axial tilt scores 100%.

Have some thoughts, which might be way off. But interested in your response. It seems to me that "hard-to-vary" is itself the criterion that a theory should be as programmable as possible. As you note, the goal of a theory should be to make it as explicit as possible, and a program is explicitness in its most complete form. Any theory with ambiguous components automatically has a breaking point that is changeable without detection. A programmable theory has strict causal relations all the way from the axioms to the prediction, which makes any change to the components detectable. In other words: a theory is hard to vary to the extent that its components and the couplings between them can be specified as a program. If a theory is vague, you cannot tell when it has been varied.

This gives a concrete operationalization. A breaking point is any place in the formalization where the chain stops being programmable: a primitive with no implementable type, a coupling between components that cannot be specified, or a step that requires implicit theories to fill the explanatory gaps. A mathematical theory with no remaining gaps has zero breaking points and is maximally hard to vary. A theory in natural language is already worse, because words carry ambiguity and vary from mind to mind. This does not rule out better and worse theories in natural language, since we can use more or less ambiguous words and relations. But it does create a hierarchy of hard-to-vary explanations, where the share of the explanation that is programmable, or at least unambiguous, forms the basis for the criterion.

This is probably too crude a formalization. But evaluating the two theories of Demeter's emotions and axial tilt as explanations, you could check how much of each is programmable. Detecting seasons is programmable in both cases through temperature and changes in weather. Demeter's emotions and the causal link from them to the weather, which is the entire explanation, are not programmable. In the axial tilt theory, every component is. So on this measure Demeter scores 25% and axial tilt scores 100%.

I'm not a programmer, so the code below is 100% AI-generated. But here is an attempt. If we normalize a theory into the parts that can be put on a computer, the types it uses, the nodes (specific values) it commits to, and the functions between them, we can score the theory by how many of those parts run.

from dataclasses import dataclass

@dataclass
class Item:
name: str
kind: str # "type", "node", or "function"
programmable: bool # does it compile and run?

@dataclass
class Theory:
name: str
items: list[Item]

1
2
3
4
5

def score(self) -> float:
    if not self.items:
        return 0.0
    ok = sum(1 for i in self.items if i.programmable)
    return ok / len(self.items)

def compare(a: Theory, b: Theory) -> None:
print(f"{a.name:<20} {a.score():.0%}")
print(f"{b.name:<20} {b.score():.0%}")

Demeter theory

demeter = Theory("Demeter", [
Item("Latitude", "type", True),
Item("Temperature", "type", True),
Item("Goddess", "type", False),
Item("Emotion", "type", False),
Item("Demeter", "node", False),
Item("emotionstate", "node", False),
Item("emotionat", "function", False),
Item("emotion_weather", "function", False),
])

Axial tilt theory

axialtilt = Theory("Axial tilt", [
Item("Latitude", "type", True),
Item("Temperature", "type", True),
Item("Angle", "type", True),
Item("Insolation", "type", True),
Item("axialtilt", "node", True),
Item("solarconstant", "node", True),
Item("solarangle", "function", True),
Item("insolation_at", "function", True),
Item("temperature", "function", True),
])

compare(demeter, axial_tilt)

Output metrics:
Demeter 25%
Axial tilt 100%

If we normalize a theory into the parts that can be put on a computer, the types it uses, the nodes (specific values) it commits to, and the functions between them, we can score the theory by how many of those parts run.

The program goes through each item in a theory, counts how many are marked True, and divides by the total. That fraction is the score of how hard the theory is to vary.

An item is True if it can be put on a computer, either by reusing an existing type (Float, Int) or by defining a new one that compiles. It is False if no working type system can express it. The user fills in the labels; the program just counts.

Demeter: 2 of 8 items program (Latitude and Temperature). Demeter, her emotions, and the functions linking them to weather can't. So the score is 25%.

Axial tilt: 9 of 9 items program. Standard types, measured constants, and functions from standard physics. So the score is 100%.

If we normalize a theory into the parts that can be put on a computer, the types it uses, the nodes (specific values) it commits to, and the functions between them, we can score the theory by how many of those parts actually run.

from dataclasses import dataclass

@dataclass
class Item:
name: str
kind: str # "type", "node", or "function"
programmable: bool # does it compile and run?

@dataclass
class Theory:
name: str
items: list[Item]

1
2
3
4
5

def score(self) -> float:
    if not self.items:
        return 0.0
    ok = sum(1 for i in self.items if i.programmable)
    return ok / len(self.items)

def compare(a: Theory, b: Theory) -> None:
print(f"{a.name:<20} {a.score():.0%}")
print(f"{b.name:<20} {b.score():.0%}")

Demeter theory

demeter = Theory("Demeter", [
Item("Latitude", "type", True),
Item("Temperature", "type", True),
Item("Goddess", "type", False),
Item("Emotion", "type", False),
Item("Demeter", "node", False),
Item("emotionstate", "node", False),
Item("emotionat", "function", False),
Item("emotion_weather", "function", False),
])

Axial tilt theory

axialtilt = Theory("Axial tilt", [
Item("Latitude", "type", True),
Item("Temperature", "type", True),
Item("Angle", "type", True),
Item("Insolation", "type", True),
Item("axialtilt", "node", True),
Item("solarconstant", "node", True),
Item("solarangle", "function", True),
Item("insolation_at", "function", True),
Item("temperature", "function", True),
])

compare(demeter, axial_tilt)

Output metrics:
Demeter 25%
Axial tilt 100%

I'm not a programmer, so the code below is 100% AI-generated. But here is an attempt. If we normalize a theory into the parts that can be put on a computer, the types it uses, the nodes (specific values) it commits to, and the functions between them, we can score the theory by how many of those parts run.

from dataclasses import dataclass

@dataclass
class Item:
name: str
kind: str # "type", "node", or "function"
programmable: bool # does it compile and run?

@dataclass
class Theory:
name: str
items: list[Item]

1
2
3
4
5

def score(self) -> float:
    if not self.items:
        return 0.0
    ok = sum(1 for i in self.items if i.programmable)
    return ok / len(self.items)

def compare(a: Theory, b: Theory) -> None:
print(f"{a.name:<20} {a.score():.0%}")
print(f"{b.name:<20} {b.score():.0%}")

Demeter theory

demeter = Theory("Demeter", [
Item("Latitude", "type", True),
Item("Temperature", "type", True),
Item("Goddess", "type", False),
Item("Emotion", "type", False),
Item("Demeter", "node", False),
Item("emotionstate", "node", False),
Item("emotionat", "function", False),
Item("emotion_weather", "function", False),
])

Axial tilt theory

axialtilt = Theory("Axial tilt", [
Item("Latitude", "type", True),
Item("Temperature", "type", True),
Item("Angle", "type", True),
Item("Insolation", "type", True),
Item("axialtilt", "node", True),
Item("solarconstant", "node", True),
Item("solarangle", "function", True),
Item("insolation_at", "function", True),
Item("temperature", "function", True),
])

compare(demeter, axial_tilt)

Output metrics:
Demeter 25%
Axial tilt 100%

When we search for truth, I think most of us are trying to understand the causal structure of the universe, not just predict it with our own fitted models. This is just a criticism of this notion of truth, which waters the concept down from what I at least think of as truth. Many incompatible theories can fit the same facts without capturing any causality. If you agree that truth is correspondence with reality, and not with the facts within our conceptual framework, the problem reemerges.

A statement carves the world into concepts standing in relations. For it to correspond with reality, those concepts must pick out genuine entities and relations in reality. But we have no way of verifying that our conceptual carvings track or pick out entities and relations in reality.

You might disagree. But when we search for truth, I think most of us are trying to understand the causal structure of the universe, not just predict it with our own fitted models. This is just a criticism of this notion of truth, which waters the concept down from what I at least think of as truth. Many incompatible theories can fit the same facts without capturing any causality. If you agree that truth is correspondence with reality, and not with the facts within our conceptual framework, the problem reemerges.

A statement carves the world into concepts standing in relations. For it to correspond with reality, those concepts must pick out genuine entities and relations in reality. But we have no way of verifying that our conceptual carvings track or pick out entities and relations in reality. This might not imply that some theories can't be more true than others. But it definitely rules out absolute truth.

When we search for truth, I think most of us are trying to understand the causal structure of the universe, not just predict it with our own fitted models. This is just a criticism of this notion of truth, which waters the concept down from what I at least think of as truth. Many incompatible theories can fit the same facts without capturing any causality. If you agree that truth is correspondence with reality, and not with the facts within our conceptual framework, the problem reemerges.

A statement carves the world into concepts standing in relations. For it to correspond with reality, those concepts must pick out genuine entities and relations in reality. But we have no way of verifying that our conceptual carvings track the world's entities and relations. And therefore we can't know if a statement is true, or if it merely corresponds with the facts (our ideas/perceptions of the world)

When we search for truth, I think most of us are trying to understand the causal structure of the universe, not just predict it with our own fitted models. This is just a criticism of this notion of truth, which waters the concept down from what I at least think of as truth. Many incompatible theories can fit the same facts without capturing any causality. If you agree that truth is correspondence with reality, and not with the facts within our conceptual framework, the problem reemerges.

A statement carves the world into concepts standing in relations. For it to correspond with reality, those concepts must pick out genuine entities and relations in reality. But we have no way of verifying that our conceptual carvings track or pick out entities and relations in reality.

I think tractibility lacks the open-ended capacity to reformulate what counts as a problem, a solution, and relevant data. Creativity is (at least partially) the ability to reformulate the problem space itself, not by ironing out implications of existing theories. An AI and computational systems is already good at ironing out the implications in our language and existing knowledge systems. But that's search within a given space, not the creation of a new one. Creativity seems to work on a higher level. It's operating at the level of problem framing, which requires things like relevance. An AI can't create new relevance, because its weights are a statistical compression of what humans have already found relevant. It inherits a frame; it doesn't generate one.

I think this shows that tractability can't do the work the bounty asks. Tractability is defined relative to a fixed problem space. But universal creativity is (at least partially) the capacity to restructure the space, to change what counts as a problem, a solution, and relevant data.

I think tractibility lacks the open-ended capacity to reformulate what counts as a problem, a solution, and relevant data. Creativity is (at least partially) the ability to reformulate the problem space itself, not by ironing out implications of existing theories. An AI and computational systems is already good at ironing out the implications in our language and existing knowledge systems. But that's search within a given space, not the creation of a new one. Creativity seems to work on a higher level. It's operating at the level of problem framing, which requires things like relevance. An AI can't create new relevance, because its weights are a statistical compression of what humans have already found relevant. It inherits a pre-given frame.

I might be confused about what you mean by tractible. But it seems to me that tractability can't do the work the bounty asks. Tractability is formally defined relative to a fixed problem space. But universal creativity is (at least partially) the capacity to restructure the space, to change what counts as a problem, a solution, and relevant data.

I think the core of universal creativity isn't about efficiency, it's the open-ended capacity to restructure what counts as a problem, a solution, and relevant data. Creativity is (at least partially) the ability to reformulate the problem space itself, not by ironing out implications of existing theories. An AI and computational systems is already good at ironing out the implications in our language and existing knowledge systems. But that's search within a given space, not the creation of a new one. Creativity seems to work on a higher level. It's operating at the level of problem framing, which requires things like relevance. An AI can't create new relevance, because its weights are a statistical compression of what humans have already found relevant. It inherits a frame; it doesn't generate one.

I think this shows that tractability can't do the work the bounty asks. Tractability is defined relative to a fixed problem space. But universal creativity is (at least partially) the capacity to restructure the space, to change what counts as a problem, a solution, and relevant data.

I think tractibility lacks the open-ended capacity to reformulate what counts as a problem, a solution, and relevant data. Creativity is (at least partially) the ability to reformulate the problem space itself, not by ironing out implications of existing theories. An AI and computational systems is already good at ironing out the implications in our language and existing knowledge systems. But that's search within a given space, not the creation of a new one. Creativity seems to work on a higher level. It's operating at the level of problem framing, which requires things like relevance. An AI can't create new relevance, because its weights are a statistical compression of what humans have already found relevant. It inherits a frame; it doesn't generate one.

I think this shows that tractability can't do the work the bounty asks. Tractability is defined relative to a fixed problem space. But universal creativity is (at least partially) the capacity to restructure the space, to change what counts as a problem, a solution, and relevant data.

This also admits of the distinction between AI and AGI (and "universal creativity") as being whether the system is capable of creating knowledge ex nihilo, as argued by Deutsch. Only universal creativity could create knowledge from nothing. Bounded creativity must start with something.

I think DD's view is that creativity is problem-solving at a meta level. True knowledge creation occurs when the problem space itself is reformulated, not by ironing out implications of existing theories. An AI is already good at ironing out the implications in our language and existing knowledge systems. But that's search within a given space, not the creation of a new one. Creativity seems to work on a higher level. It's operating at the level of problem framing, which requires things like relevance. An AI can't create new relevance, because its weights are a statistical compression of what humans have already found relevant. It inherits a frame; it doesn't generate one.

This is why tractability can't do the work the bounty asks. Tractability is defined relative to a fixed problem space. But universal creativity is (at least partially) the capacity to restructure the space, to change what counts as a problem, a solution, and relevant data.

This also admits of the distinction between AI and AGI (and "universal creativity") as being whether the system is capable of creating knowledge ex nihilo, as argued by Deutsch. Only universal creativity could create knowledge from nothing. Bounded creativity must start with something.

Moved the criticism of 4694

By Tractible, do you mean "efficient relative to fixed task"?

By Tractible, do you mean "efficient relative to fixed task"?