"If you take the hint, you'll never know whether or not you needed one... but we're trying to industrialize a planet and that's probably more important than you ever knowing whether you could have discovered the deeper orders of Validity from scratch, so, yeah.  You cannot build 'add one' out of only and, not, implies, for all.  I previously showed you a system that had predicates like 'blue' and 'red', which took in the kind of object that 'forall' quantifies over, and spat out truth or falsehood depending on whether the object was red or not.  There's no way to build 'add one' out of only those materials, because 'add one' takes in an object, a number, and spits out another object."

"This doesn't mean your system has to start out knowing what add-one means.  It does mean that you're going to have to conjure up an add-one symbol that maps objects to objects, and then start describing what it means.  But that description needs to talk about add-one as a hypothetical function whose properties will be described, not build it purely out of the predicate symbols and logical connectors.  You are also going to need a symbol '=' for equality between two objects; that one is usually assumed primitive - that even if the system starts out knowing else about the objects it describes, it knows how to tell when two objects are equal."

"There's a more sophisticated trick you can pull to not need to introduce a special symbol for add-one - roughly, you say, for all functions from objects to objects, if that function has these properties, this stuff follows - but that would involve quantifying over functions, which we can skip for now.  So, to reiterate:  You get to conjure the symbol for add-one from nowhere; you get to declare by fiat and premise that it takes in an object and spits out an object; you don't, however, get to assume that it has any behaviors beyond that, or means anything in particular, except for whatever statements you make using the add-one symbol.  Same for symbols like plus, or times.  You can declare that there's a plus symbol, and that it takes in two objects and spits out a third object, but anything about which objects has to be described by you, and that's what makes the symbols meaningful."

"If you take the hint, you'll never know whether or not you needed one... but we're trying to industrialize a planet and that's probably more important than you ever knowing whether you could have discovered the deeper orders of Validity from scratch, so, yeah.  You cannot build 'add one' out of only and, not, implies, for all.  I previously showed you a system that had predicates like 'blue' and 'red', which took in the kind of object that 'forall' quantifies over, and spat out truth or falsehood depending on whether the object was red or not.  There's no way to build 'add one' out of only those materials, because 'add one' takes in an object, a number, and spits out another object."

"This doesn't mean your system has to start out knowing what add-one means.  It does mean that you're going to have to conjure up an add-one symbol that maps objects to objects, and then start describing what it means.  But that description needs to talk about add-one as a hypothetical function whose properties will be described, not build it purely out of the predicate symbols and logical connectors.  You are also going to need a symbol '=' for equality between two objects; that one is usually assumed primitive - that even if the system starts out knowing else about the objects it describes, it knows how to tell when two objects are equal.  '=' takes in two objects, and spits out truth or falsehood."

"There's a more sophisticated trick you can pull to not need to introduce a special symbol for add-one - roughly, you say, for all functions from objects to objects, if that function has these properties, this stuff follows - but that would involve quantifying over functions, which we can skip for now.  So, to reiterate:  You get to conjure the symbol for add-one from nowhere; you get to declare by fiat and premise that it takes in an object and spits out an object; you don't, however, get to assume that it has any behaviors beyond that, or means anything in particular, except for whatever statements you make using the add-one symbol.  Same for symbols like plus, or times.  You can declare that there's a plus symbol, and that it takes in two objects and spits out a third object, but anything about which objects has to be described by you, and that's what makes the symbols meaningful."

"If you take the hint, you'll never know whether or not you needed one... but we're trying to industrialize a planet and that's probably more important than you ever knowing whether you could have discovered the deeper orders of Validity from scratch, so, yeah.  You cannot build 'add one' out of only and, not, implies, for all.  I previously showed you a system that had predicates like 'blue' and 'red', which took in the kind of object that 'forall' quantifies over, and spat out truth or falsehood depending on whether the object was red or not.  There's no way to build 'add one' out of only those materials, because 'add one' takes in an object, a number, and spits out another object."

"This doesn't mean your system has to start out knowing what add-one means.  It does mean that you're going to have to conjure up an add-one symbol that maps objects to objects, and then start describing what it means.  But that description needs to talk about add-one as a hypothetical function whose properties will be described, not build it purely out of the predicate symbols and logical connectors.  You are also going to need a symbol '=' for equality between two objects; that one is usually assumed primitive - that even if the system starts out knowing else about the objects it describes, it knows how to tell when two objects are equal.  '=' takes in two objects, and spits out truth or falsehood."

"There's a more sophisticated trick you can pull to not need to introduce a special symbol for add-one - roughly, you say, for all functions from objects to objects, if that function has these properties, this stuff follows - but that would involve quantifying over functions, which we can skip for now.  So, to reiterate:  You get to conjure the symbol for add-one from nowhere; you get to declare by fiat and premise that it takes in an object and spits out an object; you don't, however, get to assume that it has any behaviors beyond that, or means anything in particular, except for whatever statements you make using the add-one symbol.  Same for two-object functions like add, or multiply.  You can declare that there's a plus symbol, and that it takes in two objects and spits out a third object, but anything about which objects has to be described by you, and that's what makes the symbols meaningful."

"If you take the hint, you'll never know whether or not you needed one... but we're trying to industrialize a planet and that's probably more important than you ever knowing whether you could have punched above your measured intelligence level and discovered the deeper orders of Validity from scratch, so, yeah.  You cannot build 'add one' out of only and, not, implies, for all.  I previously showed you a system that had predicates like 'blue' and 'red', which took in the kind of object that 'forall' quantifies over, and spat out truth or falsehood depending on whether the object was red or not.  There's no way to build 'add one' out of only those materials, because 'add one' takes in an object, a number, and spits out another object."

"This doesn't mean your system has to start out knowing what add-one means.  It does mean that you're going to have to conjure up an add-one symbol that maps objects to objects, and then start describing what it means.  But that description needs to talk about add-one as a hypothetical function whose properties will be described, not build it purely out of the predicate symbols and logical connectors.  You are also going to need a symbol '=' for equality between two objects; that one is usually assumed primitive - that even if the system starts out knowing else about the objects it describes, it knows how to tell when two objects are equal.  '=' takes in two objects, and spits out truth or falsehood."

"There's a more sophisticated trick you can pull to not need to introduce a special symbol for add-one - roughly, you say, for all functions from objects to objects, if that function has these properties, this stuff follows - but that would involve quantifying over functions, which we can skip for now.  So, to reiterate:  You get to conjure the symbol for add-one from nowhere; you get to declare by fiat and premise that it takes in an object and spits out an object; you don't, however, get to assume that it has any behaviors beyond that, or means anything in particular, except for whatever statements you make using the add-one symbol.  Same for two-object functions like add, or multiply.  You can declare that there's a plus symbol, and that it takes in two objects and spits out a third object, but anything about which objects has to be described by you, and that's what makes the symbols meaningful."

"If you take the hint, you'll never know whether or not you needed one... but we're trying to industrialize a planet and that's probably more important than you ever knowing whether you could have punched above your measured intelligence level and discovered the deeper orders of Validity from scratch, so, yeah, hint.  You cannot build 'add one' out of only and, not, implies, for all.  I previously showed you a system that had predicates like 'blue' and 'red', which took in the kind of object that 'forall' quantifies over, and spat out truth or falsehood depending on whether the object was red or not.  There's no way to build 'add one' out of only those materials, because 'add one' takes in an object, a number, and spits out another object."

"This doesn't mean your system has to start out knowing what add-one means.  It does mean that you're going to have to conjure up an add-one symbol that maps objects to objects, and then start describing what it means.  But that description needs to talk about add-one as a hypothetical function whose properties will be described, not build it purely out of the predicate symbols and logical connectors.  You are also going to need a symbol '=' for equality between two objects; that one is usually assumed primitive - that even if the system starts out knowing else about the objects it describes, it knows how to tell when two objects are equal.  '=' takes in two objects, and spits out truth or falsehood."

"There's a more sophisticated trick you can pull to not need to introduce a special symbol for add-one - roughly, you say, for all functions from objects to objects, if that function has these properties, this stuff follows - but that would involve quantifying over functions, which we can skip for now.  So, to reiterate:  You get to conjure the symbol for add-one from nowhere; you get to declare by fiat and premise that it takes in an object and spits out an object; you don't, however, get to assume that it has any behaviors beyond that, or means anything in particular, except for whatever statements you make using the add-one symbol.  Same for two-object functions like add, or multiply.  You can declare that there's a plus symbol, and that it takes in two objects and spits out a third object, but anything about which objects has to be described by you, and that's what makes the symbols meaningful."

"If you take the hint, you'll never know whether or not you needed one... but we're trying to industrialize a planet and that's probably more important than you ever knowing whether you could have punched above your measured intelligence level and discovered the deeper orders of Validity from scratch, so, yeah, hint.  You cannot build 'add one' out of only and, not, implies, for all.  I previously showed you a system that had predicates like 'blue' and 'red', which took in the kind of object that 'forall' quantifies over, and spat out truth or falsehood depending on whether the object was red or not.  There's no way to build 'add one' out of only those materials, because 'add one' takes in an object, a number, and spits out another object."

"This doesn't mean your system has to start out knowing what add-one means.  It does mean that you're going to have to conjure up an add-one symbol that maps objects to objects, and then start describing what it means.  But that description needs to talk about add-one as a hypothetical function whose properties will be described, not build it purely out of the predicate symbols and logical connectors.  You are also going to need a symbol '=' for equality between two objects; that one is usually assumed primitive - that even if the system starts out knowing else about the objects it describes, it knows how to tell when two objects are equal.  '=' takes in two objects, and spits out truth or falsehood."

"There's a more sophisticated trick you can pull to not need to introduce a special symbol for add-one - roughly, you say, for all functions from objects to objects, if that function has these properties, this stuff follows - but that would involve quantifying over functions, which we can skip for now.  So, to reiterate:  You get to conjure the symbol for add-one from nowhere; you get to declare by fiat and premise that it takes in an object and spits out an object; you don't, however, get to assume that it has any behaviors beyond that, or means anything in particular, except for whatever statements you make using the add-one symbol.  Same for two-object functions like add, or multiply.  You can declare that there's a plus symbol, and that it takes in two objects and spits out a third object, but anything about which objects has to be described by you, and that's what makes the symbols meaningful."

"If you take the hint, you'll never know whether or not you needed one... but we're trying to industrialize a planet and that's probably more important than you ever knowing whether you could have punched above your measured intelligence level and discovered the deeper orders of Validity from scratch, so, yeah, hint.  You cannot build 'add one' out of only and, not, implies, for all.  I previously showed you a system that had predicates like 'blue' and 'red', which took in the kind of object that 'forall' quantifies over, and spat out truth or falsehood depending on whether the object was red or not.  There's no way to build 'add one' out of only those materials, because 'add one' takes in an object, a number, and spits out another object."

"This doesn't mean your system has to start out knowing what add-one means.  It does mean that you're going to have to conjure up an add-one symbol that maps objects to objects, and then start describing what it means.  But that description needs to talk about add-one as a hypothetical function whose properties will be described, not build it purely out of the predicate symbols and logical connectors.  You are also going to need a symbol '=' for equality between two objects; that one is usually assumed primitive - that even if the system starts out knowing nothing else about the objects it describes, it knows how to tell when two objects are equal.  '=' takes in two objects, and spits out truth or falsehood."

"There's a more sophisticated trick you can pull to not need to introduce a special symbol for add-one - roughly, you say, for all functions from objects to objects, if that function has these properties, this stuff follows - but that would involve quantifying over functions, which we can skip for now.  So, to reiterate:  You get to conjure the symbol for add-one from nowhere; you get to declare by fiat and premise that it takes in an object and spits out an object; you don't, however, get to assume that it has any behaviors beyond that, or means anything in particular, except for whatever statements you make using the add-one symbol.  Same for two-object functions like add, or multiply.  You can declare that there's a plus symbol, and that it takes in two objects and spits out a third object, but anything about which objects has to be described by you, and that's what makes the symbols meaningful."

"If you take the hint now, you'll never know whether or not you needed a hint or just more time... but we're trying to industrialize a planet and that's probably more important than you ever knowing whether you could have punched above your measured intelligence level and discovered the deeper orders of Validity from scratch, so, yeah, hint.  You cannot build 'add one' out of only and, not, implies, for all.  I previously showed you a system that had predicates like 'blue' and 'red', which took in the kind of object that 'forall' quantifies over, and spat out truth or falsehood depending on whether the object was red or not.  There's no way to build 'add one' out of only those materials, because 'add one' takes in an object, a number, and spits out another object."

"This doesn't mean your system has to start out knowing what add-one means.  It does mean that you're going to have to conjure up an add-one symbol that maps objects to objects, and then start describing what it means.  But that description needs to talk about add-one as a hypothetical function whose properties will be described, not build it purely out of the predicate symbols and logical connectors.  You are also going to need a symbol '=' for equality between two objects; that one is usually assumed primitive - that even if the system starts out knowing nothing else about the objects it describes, it knows how to tell when two objects are equal.  '=' takes in two objects, and spits out truth or falsehood."

"There's a more sophisticated trick you can pull to not need to introduce a special symbol for add-one - roughly, you say, for all functions from objects to objects, if that function has these properties, this stuff follows - but that would involve quantifying over functions, which we can skip for now.  So, to reiterate:  You get to conjure the symbol for add-one from nowhere; you get to declare by fiat and premise that it takes in an object and spits out an object; you don't, however, get to assume that it has any behaviors beyond that, or means anything in particular, except for whatever statements you make using the add-one symbol.  Same for two-object functions like add, or multiply.  You can declare that there's a plus symbol, and that it takes in two objects and spits out a third object, but anything about which objects has to be described by you, and that's what makes the symbols meaningful."

"If you take the hint now, you'll never know whether or not you needed a hint or just more time... but we're trying to industrialize a planet and that's probably more important than you ever knowing whether you could have punched above your measured intelligence level and discovered the deeper orders of Validity from scratch, so, yeah, hint.  You cannot build 'add one' out of only and, not, implies, for all.  I previously showed you a system that had predicates like 'blue' and 'red', which took in the kind of object that 'forall' quantifies over, and spat out truth or falsehood depending on whether the object was red or not.  There's no way to build 'add one' out of only those materials, because 'add one' takes in an object, a number, and spits out another object."

"This doesn't mean your system has to start out knowing what add-one means.  It does mean that you're going to have to conjure up an add-one symbol that maps objects to objects, and then start describing what it means.  But that description needs to talk about add-one as a hypothetical function whose properties will be described, not build it purely out of the predicate symbols and logical connectors.  You are also going to need a symbol '=' for equality between two objects; that one is usually assumed primitive - that even if the system starts out knowing nothing else about the objects it describes, it knows how to tell when two objects are equal.  '=' takes in two objects, and spits out truth or falsehood."

"There's a more sophisticated trick you can pull to not need to introduce a special symbol for add-one - roughly, you say, for all functions from objects to objects, if that function has these properties, this stuff follows - but that would involve quantifying over functions, which we can skip for now.  So, to reiterate:  You get to conjure the symbol for add-one from nowhere; you get to declare by fiat and premise that it takes in an object and spits out an object; you don't, however, get to assume that it has any behaviors beyond that, or means anything in particular, except for whatever statements you make using the add-one symbol.  Same for two-object functions like add, or multiply.  You can declare that there's a plus symbol, and that it takes in two objects and spits out a third object, but anything about which objects has to be described by you, and that's what makes the symbols meaningful."