From joe at gilith.com Mon Dec 2 06:01:17 2013
From: joe at gilith.com (Joe Leslie-Hurd)
Date: Mon, 2 Dec 2013 06:01:17 +0000
Subject: [opentheory-users] Type variables
In-Reply-To: <5B76842B-569A-4673-934A-731428BAF082@lemma-one.com>
References: <5B76842B-569A-4673-934A-731428BAF082@lemma-one.com>
Message-ID:
Hi Rob,
It might perhaps be a nice feature if the "axiom" command didn't just match
alpha-equivalent theorems, but was able to rename/instantiate type and free
term variables too. However, that seems like a lot to ask of an article
reader, and in any case it wouldn't solve the problem of processing type
variables when reading articles exported from another theorem prover with
different conventions.
There was some discussion on the list a while back about standardizing
names for type variables:
http://www.gilith.com/pipermail/opentheory-users/2011-September/000114.html
The best solution seems to be for the OpenTheory standard theory library to
adopt one convention (currently capital letters, like HOL Light), and for
other theorem provers to convert them to their local convention as part of
reading/writing articles (e.g., HOL4 would map A to 'a, B to 'b, etc.)
I have added a note about this to the documentation for the varType command
in the article format:
http://www.gilith.com/research/opentheory/article.html#varTypeCommand
Cheers,
Joe
On Fri, Nov 29, 2013 at 3:23 PM, Rob Arthan wrote:
> The OpenTheory "thm" command allows for an alpha-conversion to get the
> variable names in a theorem exactly right. The description doesn't say
> anything about type instantiation, so presumably type variable names have
> to be right already. Perhaps it should allow type variable renaming too,
> because the choice of type variable names in definitions of existing
> constants (like the quantifiers) is going to be implementation-dependent.
> Unfortunately, this is a little tricky to specify and implement because
> "thm" also allows the inferred theorem to have fewer assumptions than the
> target theorem.
>
> On this topic, the Gilith OpenTheory Repo seems to use HOL Light type
> variable names (A, B, C etc.) that can't be parsed in HOL4 or ProofPower.
> In any case, if "thm" doesn't allow for type variable renaming, then the
> documentation needs to say what type variables have been used.
>
> Regards,
>
> Rob.
>
>
> _______________________________________________
> opentheory-users mailing list
> opentheory-users at gilith.com
> http://www.gilith.com/mailman/listinfo/opentheory-users
>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL:
From joe at gilith.com Mon Dec 2 06:48:01 2013
From: joe at gilith.com (Joe Leslie-Hurd)
Date: Mon, 2 Dec 2013 06:48:01 +0000
Subject: [opentheory-users] Status of derived syntax
In-Reply-To:
References: <90D3187E-5208-471C-9240-EA2B316BA2C9@lemma-one.com>
Message-ID:
Hi Rob,
I take it that for you only equality and choice are primitive.
>
That is correct.
ETA_AX and SELECT_AX only use outermost universal quantifier, so you could
> just have stripped that off, giving equivalent readable axioms with free
> variables.
>
Another OpenTheory convention is that theorems don't have any free
variables, so I was trying to find a solution that satisfied this
constraint (though doing so meant throwing out readability).
But I don't really understand the problem you are trying to guard against.
> In addition to the axiom of infinity, the package axiom-infinity inputs the
> logical connectives and the quantifiers and has assumptions that say these
> things and injective and surjective have their standard meaning. You use
> the quantifiers and logical connectives in the assumptions about injective
> and surjective, so why does it cause a problem to use them in the axiom of
> infinity?
>
The assumptions collectively enforce that the standard definition of basic
logical constants are used. Consider the following two assumptions of the
axiom-infinity theory package:
|- (!) = \p. p = \x. T
|- !f. surjective f <=> !y. ?x. y = f x
The first assumption enforces that universal quantification has the
standard definition, so it can't cause problems to use universal
quantification in the definition of surjectivity.
The real problem I was trying to solve is recognizing the 3 standard axioms
so that I don't falsely report them as "unsatisfied assumptions" of a
theory. This is much easier if the standard axioms are expressed solely in
terms of primitive constants and type operators, so that the tool doesn't
have to check any definitions. The little axiom-* theories translate from
the primitive versions of the axioms to readable versions, assuming that
the standard definitions are being used. And note that the opentheory tool
reports all their assumptions as being satisfied, even though the primitive
versions of the axioms are not satisfied by any required theories but are
recognized as standard axioms.
I was thinking of changing the OpenTheory pretty printer so that the
primitive versions of the axioms would simply print as "AXIOM OF INFINITY"
instead of the monster term, which would perhaps avoid some future
confusion. I'm also open to better ways of booting up the OpenTheory
standard theory library, if you have any ideas.
Cheers,
Joe
-------------- next part --------------
An HTML attachment was scrubbed...
URL:
From rda at lemma-one.com Mon Dec 2 16:50:34 2013
From: rda at lemma-one.com (Rob Arthan)
Date: Mon, 2 Dec 2013 16:50:34 +0000
Subject: [opentheory-users] Type variables
In-Reply-To:
References: <5B76842B-569A-4673-934A-731428BAF082@lemma-one.com>
Message-ID:
Joe,
On reflection, I think it would be far too complicated to have axiom or thm do type instantiation. At the moment, what I am doing is reading the base package translating its definitions into the the ProofPower definitions (or theorems derived from them) and I can easily instantiate the definitions to give exactly what is asked for as I process them. Mapping HOL Light type variable names into ProofPower ones sounds like a good idea too.
Regards,
Rob.
On 2 Dec 2013, at 06:01, Joe Leslie-Hurd wrote:
> Hi Rob,
>
> It might perhaps be a nice feature if the "axiom" command didn't just match alpha-equivalent theorems, but was able to rename/instantiate type and free term variables too. However, that seems like a lot to ask of an article reader, and in any case it wouldn't solve the problem of processing type variables when reading articles exported from another theorem prover with different conventions.
>
> There was some discussion on the list a while back about standardizing names for type variables:
>
> http://www.gilith.com/pipermail/opentheory-users/2011-September/000114.html
>
> The best solution seems to be for the OpenTheory standard theory library to adopt one convention (currently capital letters, like HOL Light), and for other theorem provers to convert them to their local convention as part of reading/writing articles (e.g., HOL4 would map A to 'a, B to 'b, etc.)
>
> I have added a note about this to the documentation for the varType command in the article format:
>
> http://www.gilith.com/research/opentheory/article.html#varTypeCommand
>
> Cheers,
>
> Joe
>
>
>
> On Fri, Nov 29, 2013 at 3:23 PM, Rob Arthan wrote:
> The OpenTheory "thm" command allows for an alpha-conversion to get the variable names in a theorem exactly right. The description doesn't say anything about type instantiation, so presumably type variable names have to be right already. Perhaps it should allow type variable renaming too, because the choice of type variable names in definitions of existing constants (like the quantifiers) is going to be implementation-dependent. Unfortunately, this is a little tricky to specify and implement because "thm" also allows the inferred theorem to have fewer assumptions than the target theorem.
>
> On this topic, the Gilith OpenTheory Repo seems to use HOL Light type variable names (A, B, C etc.) that can't be parsed in HOL4 or ProofPower. In any case, if "thm" doesn't allow for type variable renaming, then the documentation needs to say what type variables have been used.
>
> Regards,
>
> Rob.
>
>
> _______________________________________________
> opentheory-users mailing list
> opentheory-users at gilith.com
> http://www.gilith.com/mailman/listinfo/opentheory-users
>
>
> _______________________________________________
> opentheory-users mailing list
> opentheory-users at gilith.com
> http://www.gilith.com/mailman/listinfo/opentheory-users
From rda at lemma-one.com Mon Dec 2 17:04:21 2013
From: rda at lemma-one.com (Rob Arthan)
Date: Mon, 2 Dec 2013 17:04:21 +0000
Subject: [opentheory-users] Importing from the Gilith OpenTheory Repo
In-Reply-To:
References: <97AF3AA1-8D33-4FE0-A48B-25E738011F98@lemma-one.com>
Message-ID: <922736A7-5A86-446B-AB93-B227CD3A71BD@lemma-one.com>
Ramana,
On 24 Nov 2013, at 09:45, Ramana Kumar wrote:
> I think the idea of the base package is that everything in it should already be supported by your theorem prover, so you don't need to import it - rather, you use it as a dependency for things you export from your theorem prover.
>
My plan was to import the base package but using the ProofPower definitions (or theorems derived from them) rather than making new definitions so that I would end up importing all the theorems about the ProofPower constants and types that I need to support the dependencies of other packages. Isn't that what you are expected to do?
On this topic, I note that there are a number of names in the base package in the HOLLight namespace. E.g., "HOLLight.mk_pair. Is that intentional?
Regards,
Rob.
From joe at gilith.com Tue Dec 3 12:01:24 2013
From: joe at gilith.com (Joe Leslie-Hurd)
Date: Tue, 3 Dec 2013 12:01:24 +0000
Subject: [opentheory-users] Importing from the Gilith OpenTheory Repo
In-Reply-To: <922736A7-5A86-446B-AB93-B227CD3A71BD@lemma-one.com>
References: <97AF3AA1-8D33-4FE0-A48B-25E738011F98@lemma-one.com>
<922736A7-5A86-446B-AB93-B227CD3A71BD@lemma-one.com>
Message-ID:
Hi Rob,
My plan was to import the base package but using the ProofPower definitions
> (or theorems derived from them) rather than making new definitions so that
> I would end up importing all the theorems about the ProofPower constants
> and types that I need to support the dependencies of other packages. Isn't
> that what you are expected to do?
>
That's exactly right. In fact the construction of the base theory package
is designed to help with this, in the naming of the packages that make it
up. Definition theorems are stored in packages named *-def (the theorems in
these packages must be derived from ProofPower theorems), and the theorems
in other packages are merely consequences of these definition theorems (and
can either be mapped to named ProofPower theorems or simply added to the
theorem database as unnamed theorems).
On this topic, I note that there are a number of names in the base package
> in the HOLLight namespace. E.g., "HOLLight.mk_pair. Is that intentional?
>
That is definitely not intentional, and I even have a script that ensures
that no symbols in the HOLLight namespace escape to the standard theory
library. I have a feeling that I have not updated the base package on
gilith for too long, and will upload the latest version when I return from
my vacation next week.
Cheers,
Joe
-------------- next part --------------
An HTML attachment was scrubbed...
URL:
From rda at lemma-one.com Tue Dec 3 13:03:53 2013
From: rda at lemma-one.com (Rob Arthan)
Date: Tue, 3 Dec 2013 13:03:53 +0000
Subject: [opentheory-users] Importing from the Gilith OpenTheory Repo
In-Reply-To:
References: <97AF3AA1-8D33-4FE0-A48B-25E738011F98@lemma-one.com>
<922736A7-5A86-446B-AB93-B227CD3A71BD@lemma-one.com>
Message-ID: <2ADA0CEF-81C1-4926-B9FC-B22BD66213D5@lemma-one.com>
On 3 Dec 2013, at 12:01, Joe Leslie-Hurd wrote:
> Hi Rob,
>
> My plan was to import the base package but using the ProofPower definitions (or theorems derived from them) rather than making new definitions so that I would end up importing all the theorems about the ProofPower constants and types that I need to support the dependencies of other packages. Isn't that what you are expected to do?
>
> That's exactly right. In fact the construction of the base theory package is designed to help with this, in the naming of the packages that make it up. Definition theorems are stored in packages named *-def (the theorems in these packages must be derived from ProofPower theorems), and the theorems in other packages are merely consequences of these definition theorems (and can either be mapped to named ProofPower theorems or simply added to the theorem database as unnamed theorems).
What I was rather hoping was that I could substitute for the definitions and axioms and then import the proofs of the theorems. If I import say pair-thm, I find it involves a lot more assumptions other than definitions. I would have hoped that the assumptions in pair-thm would just be:
!xy?x y. xy = (x, y)
!x y. fst(x, y) = x
!x y. snd(x, y) = y
> On this topic, I note that there are a number of names in the base package in the HOLLight namespace. E.g., "HOLLight.mk_pair. Is that intentional?
>
> That is definitely not intentional, and I even have a script that ensures that no symbols in the HOLLight namespace escape to the standard theory library. I have a feeling that I have not updated the base package on gilith for too long, and will upload the latest version when I return from my vacation next week.
think all the names in the HOLLight namespace are related to type definitions. I look forward to seeing the updated base package.
Regards,
Rob.
>
> Cheers,
>
> Joe
>
> _______________________________________________
> opentheory-users mailing list
> opentheory-users at gilith.com
> http://www.gilith.com/mailman/listinfo/opentheory-users
From joe at gilith.com Wed Dec 4 00:15:04 2013
From: joe at gilith.com (Joe Leslie-Hurd)
Date: Wed, 4 Dec 2013 00:15:04 +0000
Subject: [opentheory-users] Importing from the Gilith OpenTheory Repo
In-Reply-To: <2ADA0CEF-81C1-4926-B9FC-B22BD66213D5@lemma-one.com>
References: <97AF3AA1-8D33-4FE0-A48B-25E738011F98@lemma-one.com>
<922736A7-5A86-446B-AB93-B227CD3A71BD@lemma-one.com>
<2ADA0CEF-81C1-4926-B9FC-B22BD66213D5@lemma-one.com>
Message-ID:
Hi Rob,
What I was rather hoping was that I could substitute for the definitions
> and axioms and then import the proofs of the theorems. If I import say
> pair-thm, I find it involves a lot more assumptions other than definitions.
> I would have hoped that the assumptions in pair-thm would just be:
>
> !xy?x y. xy = (x, y)
>
> !x y. fst(x, y) = x
>
> !x y. snd(x, y) = y
>
When I look at the assumptions of my (perhaps more recent) pair-thm theory,
it has 46 assumptions, but the 3 you list above are the only ones that
refer to pair type operators and constants. The rest are theorems exported
by the bool package.
So if you replace the 3 pair-def theorems with ProofPower versions, and
also have all the theorems from the bool theory available, then you can
prove all the theorems in pair-thm. In this way you can build up all the
theorems from the standard library by just replacing the *-def theorems
with ProofPower versions, processing the proofs of theorems in other
packages and storing them to satisfy assumptions of later packages.
Cheers,
Joe
-------------- next part --------------
An HTML attachment was scrubbed...
URL:
From rda at lemma-one.com Wed Dec 4 13:06:40 2013
From: rda at lemma-one.com (Rob Arthan)
Date: Wed, 4 Dec 2013 13:06:40 +0000
Subject: [opentheory-users] Importing from the Gilith OpenTheory Repo
In-Reply-To:
References: <97AF3AA1-8D33-4FE0-A48B-25E738011F98@lemma-one.com>
<922736A7-5A86-446B-AB93-B227CD3A71BD@lemma-one.com>
<2ADA0CEF-81C1-4926-B9FC-B22BD66213D5@lemma-one.com>
Message-ID:
Joe,
On 4 Dec 2013, at 00:15, Joe Leslie-Hurd wrote:
> Hi Rob,
>
> > What I was rather hoping was that I could substitute for the definitions and axioms and then import the proofs of the theorems. If I import say pair-thm, I find it involves a lot more > assumptions other than definitions. I would have hoped that the assumptions in pair-thm would just be:
>
> > !xy?x y. xy = (x, y)
>
> > !x y. fst(x, y) = x
>
> > !x y. snd(x, y) = y
>
> When I look at the assumptions of my (perhaps more recent) pair-thm theory, it has 46 assumptions, but the 3 you list above are the only ones that refer to pair type operators and constants. The rest are theorems exported by the bool package.
>
> So if you replace the 3 pair-def theorems with ProofPower versions, and also have all the theorems from the bool theory available, then you can prove all the theorems in pair-thm. In this way you can build up all the theorems from the standard library by just replacing the *-def theorems with ProofPower versions, processing the proofs of theorems in other packages and storing them to satisfy assumptions of later packages.
>
You make this sound like a very piecemeal process, so I am probably misunderstanding what you have in mind. Is there are an option to opentheory that will get it to create an article file that takes all the defined constants and types in a package as inputs and has a minimal set of assumptions about them and proves all the theorems? --article doesn't do this: it generates the (HOL Light) definitions of the constants and types (including the abs and rep functions which aren't defined as part of the package). --theorems generates something that tries to define T as equal to a constant named "base-1.132".
Ultimately, I think I don't understand what the base package is trying to offer. Its assumptions are the three axioms of HOL. That implies that it must define all the types defined in the package and hence must include specific abs and rep functions for the defined types amongst the constants it exports, but it doesn't. I would have expected abstract assumptions about the defined types like the three assumptions about fst, snd and (,) above to propagate up as assumptions of the base package, but they have actually become theorems (which can 't actually be derived from the stated assumptions because the abs and rep functions have (quite rightly) not been included as part of the interface).
Regards,
Rob.
From joe at gilith.com Wed Dec 4 17:53:07 2013
From: joe at gilith.com (Joe Leslie-Hurd)
Date: Wed, 4 Dec 2013 17:53:07 +0000
Subject: [opentheory-users] Importing from the Gilith OpenTheory Repo
In-Reply-To:
References: <97AF3AA1-8D33-4FE0-A48B-25E738011F98@lemma-one.com>
<922736A7-5A86-446B-AB93-B227CD3A71BD@lemma-one.com>
<2ADA0CEF-81C1-4926-B9FC-B22BD66213D5@lemma-one.com>
Message-ID:
Hi Rob,
1. Let me first explain the info options, which could probably do with
being renamed for clarity.
opentheory info --article outputs a proof from assumptions to theorems, and
is the main way for users to generate articles from theory packages
opentheory info --theorems (--assumptions) outputs an article file
consisting of just the theorems (assumptions) of the theory package, with
axiom proofs. It's just used for caching the theorems (assumptions) to
speed up processing later, and users shouldn't need to use these options.
2. The constants and type operators listed as defined by a theory package
only include those that appear in an exported theorem. The exact form of
the definition of these symbols is internal to the package, and is
something that users of the theory package should never need to know. In
fact the OpenTheory logical kernel is purely functional, so auxiliary
symbols such as the abs and rep functions don't even end up polluting a
global symbol table (though this might theoretically cause problems in
other HOL theorem provers that don't implement a purely functional logical
kernel).
3. The base theory package is the standard theory library, which is
supposed to be a common base implemented by all theorem provers in the HOL
family, but of course not every theorem is proved in the same form in all
HOL theorem provers, so there is a use case for importing the base theory
package.
Unfortunately there isn't a good way of generating a single article from
base that can be imported by the HOL theorem provers, because the
definitions will be mixed in with the theorems.
However, you can use the opentheory tool to list all the 'leaf' theory
packages inside base, using the following magic incantation:
opentheory list --dependency-order '(Identity - IncludedBy) (Includes*
base)'
Suppose each theorem in the *-def theory packages can be replaced with a
ProofPower theorem. The remaining theory packages in the list can be
converted to an article using opentheory info --article and imported into
ProofPower. These articles shouldn't make any definitions and their
assumptions should only consist of theorems proved by theory packages
earlier in the list. At the end of this process you would have every
theorem in the base theory package imported into ProofPower.
I hope that helps clear things up a bit.
Cheers,
Joe
On Wed, Dec 4, 2013 at 1:06 PM, Rob Arthan wrote:
> Joe,
>
> On 4 Dec 2013, at 00:15, Joe Leslie-Hurd wrote:
>
> > Hi Rob,
> >
> > > What I was rather hoping was that I could substitute for the
> definitions and axioms and then import the proofs of the theorems. If I
> import say pair-thm, I find it involves a lot more > assumptions other than
> definitions. I would have hoped that the assumptions in pair-thm would just
> be:
> >
> > > !xy?x y. xy = (x, y)
> >
> > > !x y. fst(x, y) = x
> >
> > > !x y. snd(x, y) = y
> >
> > When I look at the assumptions of my (perhaps more recent) pair-thm
> theory, it has 46 assumptions, but the 3 you list above are the only ones
> that refer to pair type operators and constants. The rest are theorems
> exported by the bool package.
> >
> > So if you replace the 3 pair-def theorems with ProofPower versions, and
> also have all the theorems from the bool theory available, then you can
> prove all the theorems in pair-thm. In this way you can build up all the
> theorems from the standard library by just replacing the *-def theorems
> with ProofPower versions, processing the proofs of theorems in other
> packages and storing them to satisfy assumptions of later packages.
> >
>
> You make this sound like a very piecemeal process, so I am probably
> misunderstanding what you have in mind. Is there are an option to
> opentheory that will get it to create an article file that takes all the
> defined constants and types in a package as inputs and has a minimal set of
> assumptions about them and proves all the theorems? --article doesn't do
> this: it generates the (HOL Light) definitions of the constants and types
> (including the abs and rep functions which aren't defined as part of the
> package). --theorems generates something that tries to define T as equal to
> a constant named "base-1.132".
>
> Ultimately, I think I don't understand what the base package is trying to
> offer. Its assumptions are the three axioms of HOL. That implies that it
> must define all the types defined in the package and hence must include
> specific abs and rep functions for the defined types amongst the constants
> it exports, but it doesn't. I would have expected abstract assumptions
> about the defined types like the three assumptions about fst, snd and (,)
> above to propagate up as assumptions of the base package, but they have
> actually become theorems (which can 't actually be derived from the stated
> assumptions because the abs and rep functions have (quite rightly) not been
> included as part of the interface).
>
> Regards,
>
> Rob.
> _______________________________________________
> opentheory-users mailing list
> opentheory-users at gilith.com
> http://www.gilith.com/mailman/listinfo/opentheory-users
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL:
From rda at lemma-one.com Thu Dec 5 14:18:16 2013
From: rda at lemma-one.com (Rob Arthan)
Date: Thu, 5 Dec 2013 14:18:16 +0000
Subject: [opentheory-users] deductAntisym and eqMp
Message-ID: <60530621-9301-48DA-B944-1375653738BE@lemma-one.com>
The specifications of deductAntisym and eqMp use set operations on the assumptions. Are these intended to be interpreted modulo alpha-convertibility? (ProofPower and HOL Light both treat the assumptions as ordered sets using alpha-convertibility as the equality test when inserting and deleting elements, but I don't know about HOL4.) If the answer is no, then a reader for ProofPower or HOL Light is going to have to use some fairly horrid tricks.
Regards,
Rob.
From ramana at member.fsf.org Thu Dec 5 14:33:44 2013
From: ramana at member.fsf.org (Ramana Kumar)
Date: Thu, 5 Dec 2013 14:33:44 +0000
Subject: [opentheory-users] deductAntisym and eqMp
In-Reply-To: <60530621-9301-48DA-B944-1375653738BE@lemma-one.com>
References: <60530621-9301-48DA-B944-1375653738BE@lemma-one.com>
Message-ID:
I believe they are intended to be interpreted modulo alpha-convertibility,
indeed.
(There's also a note at the top of the article specification saying Thm
objects are interchangeable if terms in them are alpha-convertible.)
HOL4 also uses sets-up-to-alpha for the assumptions on a sequent.
On Thu, Dec 5, 2013 at 2:18 PM, Rob Arthan wrote:
> The specifications of deductAntisym and eqMp use set operations on the
> assumptions. Are these intended to be interpreted modulo
> alpha-convertibility? (ProofPower and HOL Light both treat the assumptions
> as ordered sets using alpha-convertibility as the equality test when
> inserting and deleting elements, but I don't know about HOL4.) If the
> answer is no, then a reader for ProofPower or HOL Light is going to have to
> use some fairly horrid tricks.
>
> Regards,
>
> Rob.
> _______________________________________________
> opentheory-users mailing list
> opentheory-users at gilith.com
> http://www.gilith.com/mailman/listinfo/opentheory-users
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL:
From joe at gilith.com Fri Dec 6 11:53:10 2013
From: joe at gilith.com (Joe Leslie-Hurd)
Date: Fri, 6 Dec 2013 11:53:10 +0000
Subject: [opentheory-users] deductAntisym and eqMp
In-Reply-To:
References: <60530621-9301-48DA-B944-1375653738BE@lemma-one.com>
Message-ID:
OpenTheory theorem hypotheses are indeed supposed to be represented by a
set of terms modulo alpha-equivalence: I've added a note to that effect in
the description of the thm type in
http://www.gilith.com/research/opentheory/article.html
Cheers,
Joe
On Thu, Dec 5, 2013 at 2:33 PM, Ramana Kumar wrote:
> I believe they are intended to be interpreted modulo alpha-convertibility,
> indeed.
> (There's also a note at the top of the article specification saying Thm
> objects are interchangeable if terms in them are alpha-convertible.)
> HOL4 also uses sets-up-to-alpha for the assumptions on a sequent.
>
>
> On Thu, Dec 5, 2013 at 2:18 PM, Rob Arthan wrote:
>
>> The specifications of deductAntisym and eqMp use set operations on the
>> assumptions. Are these intended to be interpreted modulo
>> alpha-convertibility? (ProofPower and HOL Light both treat the assumptions
>> as ordered sets using alpha-convertibility as the equality test when
>> inserting and deleting elements, but I don't know about HOL4.) If the
>> answer is no, then a reader for ProofPower or HOL Light is going to have to
>> use some fairly horrid tricks.
>>
>> Regards,
>>
>> Rob.
>> _______________________________________________
>> opentheory-users mailing list
>> opentheory-users at gilith.com
>> http://www.gilith.com/mailman/listinfo/opentheory-users
>>
>
>
> _______________________________________________
> opentheory-users mailing list
> opentheory-users at gilith.com
> http://www.gilith.com/mailman/listinfo/opentheory-users
>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL:
From joe at gilith.com Tue Dec 10 21:36:03 2013
From: joe at gilith.com (Joe Leslie-Hurd)
Date: Tue, 10 Dec 2013 21:36:03 +0000
Subject: [opentheory-users] Importing from the Gilith OpenTheory Repo
In-Reply-To: <2ADA0CEF-81C1-4926-B9FC-B22BD66213D5@lemma-one.com>
References: <97AF3AA1-8D33-4FE0-A48B-25E738011F98@lemma-one.com>
<922736A7-5A86-446B-AB93-B227CD3A71BD@lemma-one.com>
<2ADA0CEF-81C1-4926-B9FC-B22BD66213D5@lemma-one.com>
Message-ID:
Hi Rob,
I wanted to follow up on the HOLLight namespace issue:
> > On this topic, I note that there are a number of names in the base
> package in the HOLLight namespace. E.g., "HOLLight.mk_pair. Is that
> intentional?
>
>
> > That is definitely not intentional, and I even have a script that
> ensures that no symbols in the HOLLight namespace escape to the standard
> theory library. I have a feeling that I have not updated the base package
> on gilith for too long, and will upload the latest version when I return
> from my vacation next week.
>
> think all the names in the HOLLight namespace are related to type
> definitions. I look forward to seeing the updated base package.
>
I've just updated the base package
http://opentheory.gilith.com/?pkg=base
but I see that the new version also contains symbols in the HOLLight
namespace.
However, the HOLLight symbol names do not appear in any exported theorem,
and so are contained within a single theory package. (This is actually what
my script checks, not that there are no HOLLight names anywhere.)
I believe this means is that these names are transient, and you can replace
them with any fresh names (perhaps using a ProofPower version of gensym?),
without changing any exported theorem in the standard theory library.
Does that resolve the issue?
Cheers,
Joe
-------------- next part --------------
An HTML attachment was scrubbed...
URL: