From joe at gilith.com Thu Dec 1 22:08:41 2011 From: joe at gilith.com (Joe Hurd) Date: Thu, 1 Dec 2011 14:08:41 -0800 Subject: [opentheory-users] the Unwanted namespace In-Reply-To: References: Message-ID: Hi Ramana, I just released a version of the opentheory tool that should eliminate any occurrences of Unwanted.id I wanted to test it on the article that you uploaded some time ago, but unfortunately the new scheme requires that the Unwanted.id constants to be eliminated are input constants (i.e., not defined by the theory). Could you either (i) upload a new version of your article without the definition of Unwanted.id or (ii) try the new version of the opentheory tool yourself to see whether it does the right thing? Cheers, Joe On Mon, Oct 10, 2011 at 12:55 AM, Ramana Kumar wrote: >> Unfortunately I can see other ways that terms like these could enter >> the state, such as >> >> appThm (|- (\f. f x) = t) (|- Unwanted.id = u) >> >> followed by betaConv of the LHS at a later point. > > So we would need to consider betaConv too... > Anything else? > >> I'd really like a scheme that eliminates all occurrences of the >> Unwanted.id constant from a proof, if that was possible. And by this I >> mean that grepping the resulting article for occurrences of the >> "Unwanted" namespace will not turn up any results. > > OK. > > I think your current treatment of appTerm is fine - it won't fail, and > it removes those occurrences of Unwanted.id from the article file. > > So let's consider appThm and betaConv. > These are the general forms I see introducing unwanted terms: > > appThm (|- Unwanted.id = f) (|- x = y) > appThm (|- f = Unwanted.id) (|- x = y) > betaConv (|- (\f. t[f x]) Unwanted.id) > > What happens if you just change the semantics of all of these commands > to replace any resulting (Unwanted.id t) terms by (t), and also > prevent Unwanted.id from being defined (to stop an obvious soundness > problem)? > > _______________________________________________ > opentheory-users mailing list > opentheory-users at gilith.com > http://www.gilith.com/mailman/listinfo/opentheory-users > From ramana.kumar at gmail.com Fri Dec 2 19:46:12 2011 From: ramana.kumar at gmail.com (Ramana Kumar) Date: Fri, 2 Dec 2011 19:46:12 +0000 Subject: [opentheory-users] the Unwanted namespace In-Reply-To: References: Message-ID: My lazy list article made use of Unwanted.id but didn't define it. I've been trying to process it with the new opentheory for about 10 minutes and it seems like it's either really slow or caught in a loop. I put the article here cam.xrchz.net/ll.art.gz. There's also the original version from two months ago cam.xrchz.net/llist.art.gz, which I don't know why is different. Here's what I'm looking at: % opentheory info --article -o llist.art llist.art WARNING: 38 objects left on the stack by llist.art WARNING: 473,658 objects left in the dictionary by llist.art Some (maybe optional) output indicating status and progress might be nice. On Thu, Dec 1, 2011 at 10:08 PM, Joe Hurd wrote: > Hi Ramana, > > I just released a version of the opentheory tool that should eliminate > any occurrences of > > Unwanted.id > > I wanted to test it on the article that you uploaded some time ago, > but unfortunately the new scheme requires that the Unwanted.id > constants to be eliminated are input constants (i.e., not defined by > the theory). > > Could you either (i) upload a new version of your article without the > definition of Unwanted.id or (ii) try the new version of the > opentheory tool yourself to see whether it does the right thing? > > Cheers, > > Joe > > On Mon, Oct 10, 2011 at 12:55 AM, Ramana Kumar wrote: >>> Unfortunately I can see other ways that terms like these could enter >>> the state, such as >>> >>> appThm (|- (\f. f x) = t) (|- Unwanted.id = u) >>> >>> followed by betaConv of the LHS at a later point. >> >> So we would need to consider betaConv too... >> Anything else? >> >>> I'd really like a scheme that eliminates all occurrences of the >>> Unwanted.id constant from a proof, if that was possible. And by this I >>> mean that grepping the resulting article for occurrences of the >>> "Unwanted" namespace will not turn up any results. >> >> OK. >> >> I think your current treatment of appTerm is fine - it won't fail, and >> it removes those occurrences of Unwanted.id from the article file. >> >> So let's consider appThm and betaConv. >> These are the general forms I see introducing unwanted terms: >> >> appThm (|- Unwanted.id = f) (|- x = y) >> appThm (|- f = Unwanted.id) (|- x = y) >> betaConv (|- (\f. t[f x]) Unwanted.id) >> >> What happens if you just change the semantics of all of these commands >> to replace any resulting (Unwanted.id t) terms by (t), and also >> prevent Unwanted.id from being defined (to stop an obvious soundness >> problem)? >> >> _______________________________________________ >> 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 ramana.kumar at gmail.com Fri Dec 2 19:53:21 2011 From: ramana.kumar at gmail.com (Ramana Kumar) Date: Fri, 2 Dec 2011 19:53:21 +0000 Subject: [opentheory-users] the Unwanted namespace In-Reply-To: References: Message-ID: OK it wasn't looping - just taking a long time. On Fri, Dec 2, 2011 at 7:46 PM, Ramana Kumar wrote: > My lazy list article made use of Unwanted.id but didn't define it. > I've been trying to process it with the new opentheory for about 10 > minutes and it seems like it's either really slow or caught in a loop. > I put the article here cam.xrchz.net/ll.art.gz. There's also the > original version from two months ago cam.xrchz.net/llist.art.gz, which > I don't know why is different. > > Here's what I'm looking at: > % opentheory info --article -o llist.art llist.art > WARNING: 38 objects left on the stack by llist.art > WARNING: 473,658 objects left in the dictionary by llist.art > > Some (maybe optional) output indicating status and progress might be nice. > > On Thu, Dec 1, 2011 at 10:08 PM, Joe Hurd wrote: >> Hi Ramana, >> >> I just released a version of the opentheory tool that should eliminate >> any occurrences of >> >> Unwanted.id >> >> I wanted to test it on the article that you uploaded some time ago, >> but unfortunately the new scheme requires that the Unwanted.id >> constants to be eliminated are input constants (i.e., not defined by >> the theory). >> >> Could you either (i) upload a new version of your article without the >> definition of Unwanted.id or (ii) try the new version of the >> opentheory tool yourself to see whether it does the right thing? >> >> Cheers, >> >> Joe >> >> On Mon, Oct 10, 2011 at 12:55 AM, Ramana Kumar wrote: >>>> Unfortunately I can see other ways that terms like these could enter >>>> the state, such as >>>> >>>> appThm (|- (\f. f x) = t) (|- Unwanted.id = u) >>>> >>>> followed by betaConv of the LHS at a later point. >>> >>> So we would need to consider betaConv too... >>> Anything else? >>> >>>> I'd really like a scheme that eliminates all occurrences of the >>>> Unwanted.id constant from a proof, if that was possible. And by this I >>>> mean that grepping the resulting article for occurrences of the >>>> "Unwanted" namespace will not turn up any results. >>> >>> OK. >>> >>> I think your current treatment of appTerm is fine - it won't fail, and >>> it removes those occurrences of Unwanted.id from the article file. >>> >>> So let's consider appThm and betaConv. >>> These are the general forms I see introducing unwanted terms: >>> >>> appThm (|- Unwanted.id = f) (|- x = y) >>> appThm (|- f = Unwanted.id) (|- x = y) >>> betaConv (|- (\f. t[f x]) Unwanted.id) >>> >>> What happens if you just change the semantics of all of these commands >>> to replace any resulting (Unwanted.id t) terms by (t), and also >>> prevent Unwanted.id from being defined (to stop an obvious soundness >>> problem)? >>> >>> _______________________________________________ >>> 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 joe at gilith.com Fri Dec 2 22:25:38 2011 From: joe at gilith.com (Joe Hurd) Date: Fri, 2 Dec 2011 14:25:38 -0800 Subject: [opentheory-users] the Unwanted namespace In-Reply-To: References: Message-ID: Hi Ramana, I will say that the recent change I made to eliminate "Unwanted.id tm" terms in general, rather than simple cases, resulted in a performance degradation that I'm currently investigating. But this aside, when the the opentheory tool eventually terminated, did it successfully eliminate all Unwanted.id terms? Cheers, Joe On Fri, Dec 2, 2011 at 11:53 AM, Ramana Kumar wrote: > OK it wasn't looping - just taking a long time. > > On Fri, Dec 2, 2011 at 7:46 PM, Ramana Kumar wrote: >> My lazy list article made use of Unwanted.id but didn't define it. >> I've been trying to process it with the new opentheory for about 10 >> minutes and it seems like it's either really slow or caught in a loop. >> I put the article here cam.xrchz.net/ll.art.gz. There's also the >> original version from two months ago cam.xrchz.net/llist.art.gz, which >> I don't know why is different. >> >> Here's what I'm looking at: >> % opentheory info --article -o llist.art llist.art >> WARNING: 38 objects left on the stack by llist.art >> WARNING: 473,658 objects left in the dictionary by llist.art >> >> Some (maybe optional) output indicating status and progress might be nice. >> >> On Thu, Dec 1, 2011 at 10:08 PM, Joe Hurd wrote: >>> Hi Ramana, >>> >>> I just released a version of the opentheory tool that should eliminate >>> any occurrences of >>> >>> Unwanted.id >>> >>> I wanted to test it on the article that you uploaded some time ago, >>> but unfortunately the new scheme requires that the Unwanted.id >>> constants to be eliminated are input constants (i.e., not defined by >>> the theory). >>> >>> Could you either (i) upload a new version of your article without the >>> definition of Unwanted.id or (ii) try the new version of the >>> opentheory tool yourself to see whether it does the right thing? >>> >>> Cheers, >>> >>> Joe >>> >>> On Mon, Oct 10, 2011 at 12:55 AM, Ramana Kumar wrote: >>>>> Unfortunately I can see other ways that terms like these could enter >>>>> the state, such as >>>>> >>>>> appThm (|- (\f. f x) = t) (|- Unwanted.id = u) >>>>> >>>>> followed by betaConv of the LHS at a later point. >>>> >>>> So we would need to consider betaConv too... >>>> Anything else? >>>> >>>>> I'd really like a scheme that eliminates all occurrences of the >>>>> Unwanted.id constant from a proof, if that was possible. And by this I >>>>> mean that grepping the resulting article for occurrences of the >>>>> "Unwanted" namespace will not turn up any results. >>>> >>>> OK. >>>> >>>> I think your current treatment of appTerm is fine - it won't fail, and >>>> it removes those occurrences of Unwanted.id from the article file. >>>> >>>> So let's consider appThm and betaConv. >>>> These are the general forms I see introducing unwanted terms: >>>> >>>> appThm (|- Unwanted.id = f) (|- x = y) >>>> appThm (|- f = Unwanted.id) (|- x = y) >>>> betaConv (|- (\f. t[f x]) Unwanted.id) >>>> >>>> What happens if you just change the semantics of all of these commands >>>> to replace any resulting (Unwanted.id t) terms by (t), and also >>>> prevent Unwanted.id from being defined (to stop an obvious soundness >>>> problem)? >>>> >>>> _______________________________________________ >>>> 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 > > _______________________________________________ > opentheory-users mailing list > opentheory-users at gilith.com > http://www.gilith.com/mailman/listinfo/opentheory-users From ramana.kumar at gmail.com Sat Dec 3 12:33:49 2011 From: ramana.kumar at gmail.com (Ramana Kumar) Date: Sat, 3 Dec 2011 12:33:49 +0000 Subject: [opentheory-users] the Unwanted namespace In-Reply-To: References: Message-ID: On Fri, Dec 2, 2011 at 10:25 PM, Joe Hurd wrote: > Hi Ramana, > > I will say that the recent change I made to eliminate "Unwanted.id tm" > terms in general, rather than simple cases, resulted in a performance > degradation that I'm currently investigating. > > But this aside, when the the opentheory tool eventually terminated, > did it successfully eliminate all Unwanted.id terms? I think so. A glance at the summary of the article looked OK. I am having trouble reading it back in to HOL4, but that may be an unrelated problem. > > Cheers, > > Joe > > On Fri, Dec 2, 2011 at 11:53 AM, Ramana Kumar wrote: >> OK it wasn't looping - just taking a long time. >> >> On Fri, Dec 2, 2011 at 7:46 PM, Ramana Kumar wrote: >>> My lazy list article made use of Unwanted.id but didn't define it. >>> I've been trying to process it with the new opentheory for about 10 >>> minutes and it seems like it's either really slow or caught in a loop. >>> I put the article here cam.xrchz.net/ll.art.gz. There's also the >>> original version from two months ago cam.xrchz.net/llist.art.gz, which >>> I don't know why is different. >>> >>> Here's what I'm looking at: >>> % opentheory info --article -o llist.art llist.art >>> WARNING: 38 objects left on the stack by llist.art >>> WARNING: 473,658 objects left in the dictionary by llist.art >>> >>> Some (maybe optional) output indicating status and progress might be nice. >>> >>> On Thu, Dec 1, 2011 at 10:08 PM, Joe Hurd wrote: >>>> Hi Ramana, >>>> >>>> I just released a version of the opentheory tool that should eliminate >>>> any occurrences of >>>> >>>> Unwanted.id >>>> >>>> I wanted to test it on the article that you uploaded some time ago, >>>> but unfortunately the new scheme requires that the Unwanted.id >>>> constants to be eliminated are input constants (i.e., not defined by >>>> the theory). >>>> >>>> Could you either (i) upload a new version of your article without the >>>> definition of Unwanted.id or (ii) try the new version of the >>>> opentheory tool yourself to see whether it does the right thing? >>>> >>>> Cheers, >>>> >>>> Joe >>>> >>>> On Mon, Oct 10, 2011 at 12:55 AM, Ramana Kumar wrote: >>>>>> Unfortunately I can see other ways that terms like these could enter >>>>>> the state, such as >>>>>> >>>>>> appThm (|- (\f. f x) = t) (|- Unwanted.id = u) >>>>>> >>>>>> followed by betaConv of the LHS at a later point. >>>>> >>>>> So we would need to consider betaConv too... >>>>> Anything else? >>>>> >>>>>> I'd really like a scheme that eliminates all occurrences of the >>>>>> Unwanted.id constant from a proof, if that was possible. And by this I >>>>>> mean that grepping the resulting article for occurrences of the >>>>>> "Unwanted" namespace will not turn up any results. >>>>> >>>>> OK. >>>>> >>>>> I think your current treatment of appTerm is fine - it won't fail, and >>>>> it removes those occurrences of Unwanted.id from the article file. >>>>> >>>>> So let's consider appThm and betaConv. >>>>> These are the general forms I see introducing unwanted terms: >>>>> >>>>> appThm (|- Unwanted.id = f) (|- x = y) >>>>> appThm (|- f = Unwanted.id) (|- x = y) >>>>> betaConv (|- (\f. t[f x]) Unwanted.id) >>>>> >>>>> What happens if you just change the semantics of all of these commands >>>>> to replace any resulting (Unwanted.id t) terms by (t), and also >>>>> prevent Unwanted.id from being defined (to stop an obvious soundness >>>>> problem)? >>>>> >>>>> _______________________________________________ >>>>> 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 >> >> _______________________________________________ >> 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 ramana.kumar at gmail.com Sat Dec 3 22:59:13 2011 From: ramana.kumar at gmail.com (Ramana Kumar) Date: Sat, 3 Dec 2011 22:59:13 +0000 Subject: [opentheory-users] the Unwanted namespace In-Reply-To: References: Message-ID: Actually it seems that one Unwanted.id remained. It shows up in an Axiom in the lazy-list package I just uploaded http://opentheory.gilith.com/opentheory/packages/lazy-list-0.1/lazy-list-0.1.html. On Sat, Dec 3, 2011 at 12:33 PM, Ramana Kumar wrote: > On Fri, Dec 2, 2011 at 10:25 PM, Joe Hurd wrote: >> Hi Ramana, >> >> I will say that the recent change I made to eliminate "Unwanted.id tm" >> terms in general, rather than simple cases, resulted in a performance >> degradation that I'm currently investigating. >> >> But this aside, when the the opentheory tool eventually terminated, >> did it successfully eliminate all Unwanted.id terms? > > I think so. A glance at the summary of the article looked OK. > I am having trouble reading it back in to HOL4, but that may be an > unrelated problem. > >> >> Cheers, >> >> Joe >> >> On Fri, Dec 2, 2011 at 11:53 AM, Ramana Kumar wrote: >>> OK it wasn't looping - just taking a long time. >>> >>> On Fri, Dec 2, 2011 at 7:46 PM, Ramana Kumar wrote: >>>> My lazy list article made use of Unwanted.id but didn't define it. >>>> I've been trying to process it with the new opentheory for about 10 >>>> minutes and it seems like it's either really slow or caught in a loop. >>>> I put the article here cam.xrchz.net/ll.art.gz. There's also the >>>> original version from two months ago cam.xrchz.net/llist.art.gz, which >>>> I don't know why is different. >>>> >>>> Here's what I'm looking at: >>>> % opentheory info --article -o llist.art llist.art >>>> WARNING: 38 objects left on the stack by llist.art >>>> WARNING: 473,658 objects left in the dictionary by llist.art >>>> >>>> Some (maybe optional) output indicating status and progress might be nice. >>>> >>>> On Thu, Dec 1, 2011 at 10:08 PM, Joe Hurd wrote: >>>>> Hi Ramana, >>>>> >>>>> I just released a version of the opentheory tool that should eliminate >>>>> any occurrences of >>>>> >>>>> Unwanted.id >>>>> >>>>> I wanted to test it on the article that you uploaded some time ago, >>>>> but unfortunately the new scheme requires that the Unwanted.id >>>>> constants to be eliminated are input constants (i.e., not defined by >>>>> the theory). >>>>> >>>>> Could you either (i) upload a new version of your article without the >>>>> definition of Unwanted.id or (ii) try the new version of the >>>>> opentheory tool yourself to see whether it does the right thing? >>>>> >>>>> Cheers, >>>>> >>>>> Joe >>>>> >>>>> On Mon, Oct 10, 2011 at 12:55 AM, Ramana Kumar wrote: >>>>>>> Unfortunately I can see other ways that terms like these could enter >>>>>>> the state, such as >>>>>>> >>>>>>> appThm (|- (\f. f x) = t) (|- Unwanted.id = u) >>>>>>> >>>>>>> followed by betaConv of the LHS at a later point. >>>>>> >>>>>> So we would need to consider betaConv too... >>>>>> Anything else? >>>>>> >>>>>>> I'd really like a scheme that eliminates all occurrences of the >>>>>>> Unwanted.id constant from a proof, if that was possible. And by this I >>>>>>> mean that grepping the resulting article for occurrences of the >>>>>>> "Unwanted" namespace will not turn up any results. >>>>>> >>>>>> OK. >>>>>> >>>>>> I think your current treatment of appTerm is fine - it won't fail, and >>>>>> it removes those occurrences of Unwanted.id from the article file. >>>>>> >>>>>> So let's consider appThm and betaConv. >>>>>> These are the general forms I see introducing unwanted terms: >>>>>> >>>>>> appThm (|- Unwanted.id = f) (|- x = y) >>>>>> appThm (|- f = Unwanted.id) (|- x = y) >>>>>> betaConv (|- (\f. t[f x]) Unwanted.id) >>>>>> >>>>>> What happens if you just change the semantics of all of these commands >>>>>> to replace any resulting (Unwanted.id t) terms by (t), and also >>>>>> prevent Unwanted.id from being defined (to stop an obvious soundness >>>>>> problem)? >>>>>> >>>>>> _______________________________________________ >>>>>> 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 >>> >>> _______________________________________________ >>> 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 ramana.kumar at gmail.com Sat Dec 3 23:00:49 2011 From: ramana.kumar at gmail.com (Ramana Kumar) Date: Sat, 3 Dec 2011 23:00:49 +0000 Subject: [opentheory-users] the Unwanted namespace In-Reply-To: References: Message-ID: ugh apparently it's also a "defined constant". I don't know why my theory would be defining Unwanted.id ... On Sat, Dec 3, 2011 at 10:59 PM, Ramana Kumar wrote: > Actually it seems that one Unwanted.id remained. It shows up in an > Axiom in the lazy-list package I just uploaded > http://opentheory.gilith.com/opentheory/packages/lazy-list-0.1/lazy-list-0.1.html. > > On Sat, Dec 3, 2011 at 12:33 PM, Ramana Kumar wrote: >> On Fri, Dec 2, 2011 at 10:25 PM, Joe Hurd wrote: >>> Hi Ramana, >>> >>> I will say that the recent change I made to eliminate "Unwanted.id tm" >>> terms in general, rather than simple cases, resulted in a performance >>> degradation that I'm currently investigating. >>> >>> But this aside, when the the opentheory tool eventually terminated, >>> did it successfully eliminate all Unwanted.id terms? >> >> I think so. A glance at the summary of the article looked OK. >> I am having trouble reading it back in to HOL4, but that may be an >> unrelated problem. >> >>> >>> Cheers, >>> >>> Joe >>> >>> On Fri, Dec 2, 2011 at 11:53 AM, Ramana Kumar wrote: >>>> OK it wasn't looping - just taking a long time. >>>> >>>> On Fri, Dec 2, 2011 at 7:46 PM, Ramana Kumar wrote: >>>>> My lazy list article made use of Unwanted.id but didn't define it. >>>>> I've been trying to process it with the new opentheory for about 10 >>>>> minutes and it seems like it's either really slow or caught in a loop. >>>>> I put the article here cam.xrchz.net/ll.art.gz. There's also the >>>>> original version from two months ago cam.xrchz.net/llist.art.gz, which >>>>> I don't know why is different. >>>>> >>>>> Here's what I'm looking at: >>>>> % opentheory info --article -o llist.art llist.art >>>>> WARNING: 38 objects left on the stack by llist.art >>>>> WARNING: 473,658 objects left in the dictionary by llist.art >>>>> >>>>> Some (maybe optional) output indicating status and progress might be nice. >>>>> >>>>> On Thu, Dec 1, 2011 at 10:08 PM, Joe Hurd wrote: >>>>>> Hi Ramana, >>>>>> >>>>>> I just released a version of the opentheory tool that should eliminate >>>>>> any occurrences of >>>>>> >>>>>> Unwanted.id >>>>>> >>>>>> I wanted to test it on the article that you uploaded some time ago, >>>>>> but unfortunately the new scheme requires that the Unwanted.id >>>>>> constants to be eliminated are input constants (i.e., not defined by >>>>>> the theory). >>>>>> >>>>>> Could you either (i) upload a new version of your article without the >>>>>> definition of Unwanted.id or (ii) try the new version of the >>>>>> opentheory tool yourself to see whether it does the right thing? >>>>>> >>>>>> Cheers, >>>>>> >>>>>> Joe >>>>>> >>>>>> On Mon, Oct 10, 2011 at 12:55 AM, Ramana Kumar wrote: >>>>>>>> Unfortunately I can see other ways that terms like these could enter >>>>>>>> the state, such as >>>>>>>> >>>>>>>> appThm (|- (\f. f x) = t) (|- Unwanted.id = u) >>>>>>>> >>>>>>>> followed by betaConv of the LHS at a later point. >>>>>>> >>>>>>> So we would need to consider betaConv too... >>>>>>> Anything else? >>>>>>> >>>>>>>> I'd really like a scheme that eliminates all occurrences of the >>>>>>>> Unwanted.id constant from a proof, if that was possible. And by this I >>>>>>>> mean that grepping the resulting article for occurrences of the >>>>>>>> "Unwanted" namespace will not turn up any results. >>>>>>> >>>>>>> OK. >>>>>>> >>>>>>> I think your current treatment of appTerm is fine - it won't fail, and >>>>>>> it removes those occurrences of Unwanted.id from the article file. >>>>>>> >>>>>>> So let's consider appThm and betaConv. >>>>>>> These are the general forms I see introducing unwanted terms: >>>>>>> >>>>>>> appThm (|- Unwanted.id = f) (|- x = y) >>>>>>> appThm (|- f = Unwanted.id) (|- x = y) >>>>>>> betaConv (|- (\f. t[f x]) Unwanted.id) >>>>>>> >>>>>>> What happens if you just change the semantics of all of these commands >>>>>>> to replace any resulting (Unwanted.id t) terms by (t), and also >>>>>>> prevent Unwanted.id from being defined (to stop an obvious soundness >>>>>>> problem)? >>>>>>> >>>>>>> _______________________________________________ >>>>>>> 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 >>>> >>>> _______________________________________________ >>>> 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 joe at gilith.com Tue Dec 6 04:58:54 2011 From: joe at gilith.com (Joe Hurd) Date: Mon, 5 Dec 2011 20:58:54 -0800 Subject: [opentheory-users] the Unwanted namespace In-Reply-To: References: Message-ID: Hi Ramana, I fixed a performance bug in the proof rewriting, and your example goes through pretty quickly now (see below). The fix is both pushed and released in the latest version of the opentheory tool. Cheers, Joe ________________________________________________________________ dimholt:~/dev/opentheory$ gzcat ~/Desktop/ll.art.gz | time bin/mlton/opentheory info --inference article:- WARNING: 38 objects left on the stack by - WARNING: 473,658 objects left in the dictionary by - Primitive inferences: eqMp ............ 150,377 deductAntisym ... 129,584 subst ............ 76,065 appThm ........... 20,748 assume ........... 18,086 refl .............. 9,363 betaConv .......... 7,461 absThm ............ 4,564 axiom ............... 193 defineConst .......... 25 defineTypeOp .......... 1 Total ........... 416,467 24.40 real 15.30 user 9.07 sys dimholt:~/dev/opentheory$ time bin/mlton/opentheory info --inference foo.art Primitive inferences: eqMp ............. 68,100 subst ............ 56,228 deductAntisym .... 51,689 appThm ........... 17,378 betaConv .......... 6,866 refl .............. 6,325 absThm ............ 4,267 assume ............ 1,608 axiom ............... 190 defineConst .......... 26 defineTypeOp .......... 1 Total ........... 212,678 real 0m5.289s user 0m5.027s sys 0m0.256s From ramana.kumar at gmail.com Tue Dec 6 17:46:46 2011 From: ramana.kumar at gmail.com (Ramana Kumar) Date: Tue, 6 Dec 2011 17:46:46 +0000 Subject: [opentheory-users] interpreting namespaces Message-ID: The interpret lines in a theory file enable "renaming" of specific constants and type operators. Would it be possible to rename an entire namespace in one go? An example usage is extracting the lazy list theory from HOL4, which is called llist, but in OpenTheory namespace might be better called LazyList or Data.LazyList or something. The automatic technology for extracting an article just uses the theory name as the namespace by default. I could extend the HOL4 extractor to allow a manual override. Alternatively, I could put something in the .thy file (at the moment it would be an "interpret" line for every constant/type operator defined). Which option is better? From ramana.kumar at gmail.com Tue Dec 6 17:52:40 2011 From: ramana.kumar at gmail.com (Ramana Kumar) Date: Tue, 6 Dec 2011 17:52:40 +0000 Subject: [opentheory-users] invalid theory file syntax should be detected earlier Message-ID: If you don't put the namespace after a "show:" in a theory file in quotation marks, opentheory eventually says: FATAL ERROR: opentheory failed: Show.fromStringMapping It might be nicer to get a more informative syntax error earlier on. As an aside, is there an issue tracker for the opentheory tool? From ramana.kumar at gmail.com Tue Dec 6 17:55:17 2011 From: ramana.kumar at gmail.com (Ramana Kumar) Date: Tue, 6 Dec 2011 17:55:17 +0000 Subject: [opentheory-users] interpreting namespaces In-Reply-To: References: Message-ID: Perhaps the "show" lines already do this? Specifically the show "NAMESPACE" as "NAMESPACE" form. Is that appropriate to use in this situation, when packaging an article that is systematically using the wrong namespace? On Tue, Dec 6, 2011 at 5:46 PM, Ramana Kumar wrote: > The interpret lines in a theory file enable "renaming" of specific > constants and type operators. > Would it be possible to rename an entire namespace in one go? > > An example usage is extracting the lazy list theory from HOL4, which > is called llist, but in OpenTheory namespace might be better called > LazyList or Data.LazyList or something. > The automatic technology for extracting an article just uses the > theory name as the namespace by default. > I could extend the HOL4 extractor to allow a manual override. > Alternatively, I could put something in the .thy file (at the moment > it would be an "interpret" line for every constant/type operator > defined). > Which option is better? From joe at gilith.com Tue Dec 6 18:16:41 2011 From: joe at gilith.com (Joe Hurd) Date: Tue, 6 Dec 2011 10:16:41 -0800 Subject: [opentheory-users] interpreting namespaces In-Reply-To: References: Message-ID: Hi Ramana, The "show" lines just control printing, to make fully qualified names more palatable for humans, so I wouldn't use these. In production theories the "interpret" lines are intended for instantiating parametric theories, not "fixing" articles that were extracted with non-standard names. So that leaves the extraction process as the right place to assign names. One option would be to modify the HOL4 extractor, as you said. What I did in HOL Light is to extract an article with HOL Light names (everything is inside the HOLLight namespace), and then created a temporary theory file with lots of "interpret" lines which I ran through the opentheory tool to generate the final article. This article can then be used with neat theory file with no additional "interpret" lines. However, this process is perhaps a bit of a hack, and a proper theorem prover interface would handle the local to OpenTheory name mapping more smoothly. A bit of a ramble, but I hope that helps you with your design decision. Cheers, Joe On Tue, Dec 6, 2011 at 9:55 AM, Ramana Kumar wrote: > Perhaps the "show" lines already do this? > Specifically the > > show "NAMESPACE" as "NAMESPACE" > > form. > > Is that appropriate to use in this situation, when packaging an > article that is systematically using the wrong namespace? > > On Tue, Dec 6, 2011 at 5:46 PM, Ramana Kumar wrote: >> The interpret lines in a theory file enable "renaming" of specific >> constants and type operators. >> Would it be possible to rename an entire namespace in one go? >> >> An example usage is extracting the lazy list theory from HOL4, which >> is called llist, but in OpenTheory namespace might be better called >> LazyList or Data.LazyList or something. >> The automatic technology for extracting an article just uses the >> theory name as the namespace by default. >> I could extend the HOL4 extractor to allow a manual override. >> Alternatively, I could put something in the .thy file (at the moment >> it would be an "interpret" line for every constant/type operator >> defined). >> Which option is better? > > _______________________________________________ > opentheory-users mailing list > opentheory-users at gilith.com > http://www.gilith.com/mailman/listinfo/opentheory-users From ramana.kumar at gmail.com Tue Dec 6 18:44:46 2011 From: ramana.kumar at gmail.com (Ramana Kumar) Date: Tue, 6 Dec 2011 18:44:46 +0000 Subject: [opentheory-users] the Unwanted namespace In-Reply-To: References: Message-ID: Thanks for making it quicker :) Now, the only place where Unwanted.id seems not to be erased is in an apparent axiom required by my article. Can you confirm that the article is actually trying to define Unwanted.id? I generated the article from a HOL4 theory that I don't think should be defining anything mapped to Unwanted.id, so I'm a bit confused about that at the moment... On Tue, Dec 6, 2011 at 4:58 AM, Joe Hurd wrote: > Hi Ramana, > > I fixed a performance bug in the proof rewriting, and your example > goes through pretty quickly now (see below). The fix is both pushed > and released in the latest version of the opentheory tool. > > Cheers, > > Joe > > ________________________________________________________________ > > dimholt:~/dev/opentheory$ gzcat ~/Desktop/ll.art.gz | time > bin/mlton/opentheory info --inference article:- > WARNING: 38 objects left on the stack by - > WARNING: 473,658 objects left in the dictionary by - > Primitive inferences: > eqMp ............ 150,377 > deductAntisym ... 129,584 > subst ............ 76,065 > appThm ........... 20,748 > assume ........... 18,086 > refl .............. 9,363 > betaConv .......... 7,461 > absThm ............ 4,564 > axiom ............... 193 > defineConst .......... 25 > defineTypeOp .......... 1 > Total ........... 416,467 > ? ? ? 24.40 real > ? ? ? 15.30 user > ? ? ? ? 9.07 sys > > dimholt:~/dev/opentheory$ time bin/mlton/opentheory info --inference > foo.art Primitive inferences: > eqMp ............. 68,100 > subst ............ 56,228 > deductAntisym .... 51,689 > appThm ........... 17,378 > betaConv .......... 6,866 > refl .............. 6,325 > absThm ............ 4,267 > assume ............ 1,608 > axiom ............... 190 > defineConst .......... 26 > defineTypeOp .......... 1 > Total ........... 212,678 > > real ? ?0m5.289s > user ? ?0m5.027s > sys ? ? 0m0.256s > > _______________________________________________ > opentheory-users mailing list > opentheory-users at gilith.com > http://www.gilith.com/mailman/listinfo/opentheory-users From ramana.kumar at gmail.com Tue Dec 6 19:18:27 2011 From: ramana.kumar at gmail.com (Ramana Kumar) Date: Tue, 6 Dec 2011 19:18:27 +0000 Subject: [opentheory-users] the Unwanted namespace In-Reply-To: References: Message-ID: Will your scheme for eliminating Unwanted.id work in terms where it does not appear fully applied, but can still be eliminated? Specifically, when Unwanted.id is composed with another function. On Tue, Dec 6, 2011 at 6:44 PM, Ramana Kumar wrote: > Thanks for making it quicker :) > > Now, the only place where Unwanted.id seems not to be erased is in an > apparent axiom required by my article. > Can you confirm that the article is actually trying to define Unwanted.id? > I generated the article from a HOL4 theory that I don't think should > be defining anything mapped to Unwanted.id, so I'm a bit confused > about that at the moment... > > On Tue, Dec 6, 2011 at 4:58 AM, Joe Hurd wrote: >> Hi Ramana, >> >> I fixed a performance bug in the proof rewriting, and your example >> goes through pretty quickly now (see below). The fix is both pushed >> and released in the latest version of the opentheory tool. >> >> Cheers, >> >> Joe >> >> ________________________________________________________________ >> >> dimholt:~/dev/opentheory$ gzcat ~/Desktop/ll.art.gz | time >> bin/mlton/opentheory info --inference article:- >> WARNING: 38 objects left on the stack by - >> WARNING: 473,658 objects left in the dictionary by - >> Primitive inferences: >> eqMp ............ 150,377 >> deductAntisym ... 129,584 >> subst ............ 76,065 >> appThm ........... 20,748 >> assume ........... 18,086 >> refl .............. 9,363 >> betaConv .......... 7,461 >> absThm ............ 4,564 >> axiom ............... 193 >> defineConst .......... 25 >> defineTypeOp .......... 1 >> Total ........... 416,467 >> ? ? ? 24.40 real >> ? ? ? 15.30 user >> ? ? ? ? 9.07 sys >> >> dimholt:~/dev/opentheory$ time bin/mlton/opentheory info --inference >> foo.art Primitive inferences: >> eqMp ............. 68,100 >> subst ............ 56,228 >> deductAntisym .... 51,689 >> appThm ........... 17,378 >> betaConv .......... 6,866 >> refl .............. 6,325 >> absThm ............ 4,267 >> assume ............ 1,608 >> axiom ............... 190 >> defineConst .......... 26 >> defineTypeOp .......... 1 >> Total ........... 212,678 >> >> real ? ?0m5.289s >> user ? ?0m5.027s >> sys ? ? 0m0.256s >> >> _______________________________________________ >> opentheory-users mailing list >> opentheory-users at gilith.com >> http://www.gilith.com/mailman/listinfo/opentheory-users From joe at gilith.com Tue Dec 6 19:36:38 2011 From: joe at gilith.com (Joe Hurd) Date: Tue, 6 Dec 2011 11:36:38 -0800 Subject: [opentheory-users] the Unwanted namespace In-Reply-To: References: Message-ID: Hi Ramana, The elimination procedure only knows the definition Unwanted.id = \x. x which it uses to reduce terms Unwanted.id x --> x This is the reason that an instance of Unwanted.id is not being eliminated in your article (the elimination procedure knows nothing about the Function.o constant), although it does instantiate the undefined Unwanted.id constant to the definition above (which is why it appears to be defined in the resulting article). The solution is to ensure that every instance of Unwanted.id in theory assumptions and theorems is fully applied. This should always be the case for constants used to tag terms, which are the main use-case of Unwanted.id. Cheers, Joe On Tue, Dec 6, 2011 at 11:18 AM, Ramana Kumar wrote: > Will your scheme for eliminating Unwanted.id work in terms where it > does not appear fully applied, but can still be eliminated? > Specifically, when Unwanted.id is composed with another function. > > On Tue, Dec 6, 2011 at 6:44 PM, Ramana Kumar wrote: >> Thanks for making it quicker :) >> >> Now, the only place where Unwanted.id seems not to be erased is in an >> apparent axiom required by my article. >> Can you confirm that the article is actually trying to define Unwanted.id? >> I generated the article from a HOL4 theory that I don't think should >> be defining anything mapped to Unwanted.id, so I'm a bit confused >> about that at the moment... >> >> On Tue, Dec 6, 2011 at 4:58 AM, Joe Hurd wrote: >>> Hi Ramana, >>> >>> I fixed a performance bug in the proof rewriting, and your example >>> goes through pretty quickly now (see below). The fix is both pushed >>> and released in the latest version of the opentheory tool. >>> >>> Cheers, >>> >>> Joe >>> >>> ________________________________________________________________ >>> >>> dimholt:~/dev/opentheory$ gzcat ~/Desktop/ll.art.gz | time >>> bin/mlton/opentheory info --inference article:- >>> WARNING: 38 objects left on the stack by - >>> WARNING: 473,658 objects left in the dictionary by - >>> Primitive inferences: >>> eqMp ............ 150,377 >>> deductAntisym ... 129,584 >>> subst ............ 76,065 >>> appThm ........... 20,748 >>> assume ........... 18,086 >>> refl .............. 9,363 >>> betaConv .......... 7,461 >>> absThm ............ 4,564 >>> axiom ............... 193 >>> defineConst .......... 25 >>> defineTypeOp .......... 1 >>> Total ........... 416,467 >>> ? ? ? 24.40 real >>> ? ? ? 15.30 user >>> ? ? ? ? 9.07 sys >>> >>> dimholt:~/dev/opentheory$ time bin/mlton/opentheory info --inference >>> foo.art Primitive inferences: >>> eqMp ............. 68,100 >>> subst ............ 56,228 >>> deductAntisym .... 51,689 >>> appThm ........... 17,378 >>> betaConv .......... 6,866 >>> refl .............. 6,325 >>> absThm ............ 4,267 >>> assume ............ 1,608 >>> axiom ............... 190 >>> defineConst .......... 26 >>> defineTypeOp .......... 1 >>> Total ........... 212,678 >>> >>> real ? ?0m5.289s >>> user ? ?0m5.027s >>> sys ? ? 0m0.256s >>> >>> _______________________________________________ >>> 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 ramana.kumar at gmail.com Tue Dec 6 19:53:23 2011 From: ramana.kumar at gmail.com (Ramana Kumar) Date: Tue, 6 Dec 2011 19:53:23 +0000 Subject: [opentheory-users] the Unwanted namespace In-Reply-To: References: Message-ID: On Tue, Dec 6, 2011 at 7:36 PM, Joe Hurd wrote: > The solution is to ensure that every instance of Unwanted.id in theory > assumptions and theorems is fully applied. This should always be the > case for constants used to tag terms, which are the main use-case of > Unwanted.id. I'm not so sure about that. This theorem is from the HOL4 library (combinTheory.literal_case_FORALL_ELIM): |- literal_case f v ? (!) (S ((==>) o Abbrev o C (=) v) f) The "Abbrev" constant in the middle there is a tag for abbreviations (which I map to Unwanted.id). (This is where, I believe, my axiom in the lazy list theory was coming from.) I'm not sure why this theorem has the form it does, but it could be an example of a useful not-fully-applied tag. Perhaps someone who knows more about that theorem could clarify... > > Cheers, > > Joe > > On Tue, Dec 6, 2011 at 11:18 AM, Ramana Kumar wrote: >> Will your scheme for eliminating Unwanted.id work in terms where it >> does not appear fully applied, but can still be eliminated? >> Specifically, when Unwanted.id is composed with another function. >> >> On Tue, Dec 6, 2011 at 6:44 PM, Ramana Kumar wrote: >>> Thanks for making it quicker :) >>> >>> Now, the only place where Unwanted.id seems not to be erased is in an >>> apparent axiom required by my article. >>> Can you confirm that the article is actually trying to define Unwanted.id? >>> I generated the article from a HOL4 theory that I don't think should >>> be defining anything mapped to Unwanted.id, so I'm a bit confused >>> about that at the moment... >>> >>> On Tue, Dec 6, 2011 at 4:58 AM, Joe Hurd wrote: >>>> Hi Ramana, >>>> >>>> I fixed a performance bug in the proof rewriting, and your example >>>> goes through pretty quickly now (see below). The fix is both pushed >>>> and released in the latest version of the opentheory tool. >>>> >>>> Cheers, >>>> >>>> Joe >>>> >>>> ________________________________________________________________ >>>> >>>> dimholt:~/dev/opentheory$ gzcat ~/Desktop/ll.art.gz | time >>>> bin/mlton/opentheory info --inference article:- >>>> WARNING: 38 objects left on the stack by - >>>> WARNING: 473,658 objects left in the dictionary by - >>>> Primitive inferences: >>>> eqMp ............ 150,377 >>>> deductAntisym ... 129,584 >>>> subst ............ 76,065 >>>> appThm ........... 20,748 >>>> assume ........... 18,086 >>>> refl .............. 9,363 >>>> betaConv .......... 7,461 >>>> absThm ............ 4,564 >>>> axiom ............... 193 >>>> defineConst .......... 25 >>>> defineTypeOp .......... 1 >>>> Total ........... 416,467 >>>> ? ? ? 24.40 real >>>> ? ? ? 15.30 user >>>> ? ? ? ? 9.07 sys >>>> >>>> dimholt:~/dev/opentheory$ time bin/mlton/opentheory info --inference >>>> foo.art Primitive inferences: >>>> eqMp ............. 68,100 >>>> subst ............ 56,228 >>>> deductAntisym .... 51,689 >>>> appThm ........... 17,378 >>>> betaConv .......... 6,866 >>>> refl .............. 6,325 >>>> absThm ............ 4,267 >>>> assume ............ 1,608 >>>> axiom ............... 190 >>>> defineConst .......... 26 >>>> defineTypeOp .......... 1 >>>> Total ........... 212,678 >>>> >>>> real ? ?0m5.289s >>>> user ? ?0m5.027s >>>> sys ? ? 0m0.256s >>>> >>>> _______________________________________________ >>>> 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 > > _______________________________________________ > opentheory-users mailing list > opentheory-users at gilith.com > http://www.gilith.com/mailman/listinfo/opentheory-users From joe at gilith.com Tue Dec 6 22:30:34 2011 From: joe at gilith.com (Joe Hurd) Date: Tue, 6 Dec 2011 14:30:34 -0800 Subject: [opentheory-users] invalid theory file syntax should be detected earlier In-Reply-To: References: Message-ID: Hi Ramana, > It might be nicer to get a more informative syntax error earlier on. I've made the syntax error more friendly: FATAL ERROR: opentheory failed: bad show format: Data.Bool" please use one of the following forms: "NAMESPACE" "NAMESPACE" as "NAMESPACE" This is pushed and in the latest released version of the opentheory tool. I can't easily make it happen earlier, because the opentheory tool processes theories "lazily", so the show information only gets processed when it's needed. > As an aside, is there an issue tracker for the opentheory tool? Not right now: is there one that you would recommend? Cheers, Joe From joe at gilith.com Tue Dec 6 22:35:51 2011 From: joe at gilith.com (Joe Hurd) Date: Tue, 6 Dec 2011 14:35:51 -0800 Subject: [opentheory-users] the Unwanted namespace In-Reply-To: References: Message-ID: Hi Ramana, Good job digging up a counter-example to my claim about how tags are used, but I think it's probably not worth the effort to handle exotic cases. Perhaps the theorem you found could be deduced from a form with a fully applied tag? Cheers, Joe On Tue, Dec 6, 2011 at 11:53 AM, Ramana Kumar wrote: > On Tue, Dec 6, 2011 at 7:36 PM, Joe Hurd wrote: >> The solution is to ensure that every instance of Unwanted.id in theory >> assumptions and theorems is fully applied. This should always be the >> case for constants used to tag terms, which are the main use-case of >> Unwanted.id. > > I'm not so sure about that. This theorem is from the HOL4 library > (combinTheory.literal_case_FORALL_ELIM): > > |- literal_case f v ? (!) (S ((==>) o Abbrev o C (=) v) f) > > The "Abbrev" constant in the middle there is a tag for abbreviations > (which I map to Unwanted.id). > (This is where, I believe, my axiom in the lazy list theory was coming from.) > > I'm not sure why this theorem has the form it does, but it could be an > example of a useful not-fully-applied tag. > Perhaps someone who knows more about that theorem could clarify... > >> >> Cheers, >> >> Joe >> >> On Tue, Dec 6, 2011 at 11:18 AM, Ramana Kumar wrote: >>> Will your scheme for eliminating Unwanted.id work in terms where it >>> does not appear fully applied, but can still be eliminated? >>> Specifically, when Unwanted.id is composed with another function. >>> >>> On Tue, Dec 6, 2011 at 6:44 PM, Ramana Kumar wrote: >>>> Thanks for making it quicker :) >>>> >>>> Now, the only place where Unwanted.id seems not to be erased is in an >>>> apparent axiom required by my article. >>>> Can you confirm that the article is actually trying to define Unwanted.id? >>>> I generated the article from a HOL4 theory that I don't think should >>>> be defining anything mapped to Unwanted.id, so I'm a bit confused >>>> about that at the moment... >>>> >>>> On Tue, Dec 6, 2011 at 4:58 AM, Joe Hurd wrote: >>>>> Hi Ramana, >>>>> >>>>> I fixed a performance bug in the proof rewriting, and your example >>>>> goes through pretty quickly now (see below). The fix is both pushed >>>>> and released in the latest version of the opentheory tool. >>>>> >>>>> Cheers, >>>>> >>>>> Joe >>>>> >>>>> ________________________________________________________________ >>>>> >>>>> dimholt:~/dev/opentheory$ gzcat ~/Desktop/ll.art.gz | time >>>>> bin/mlton/opentheory info --inference article:- >>>>> WARNING: 38 objects left on the stack by - >>>>> WARNING: 473,658 objects left in the dictionary by - >>>>> Primitive inferences: >>>>> eqMp ............ 150,377 >>>>> deductAntisym ... 129,584 >>>>> subst ............ 76,065 >>>>> appThm ........... 20,748 >>>>> assume ........... 18,086 >>>>> refl .............. 9,363 >>>>> betaConv .......... 7,461 >>>>> absThm ............ 4,564 >>>>> axiom ............... 193 >>>>> defineConst .......... 25 >>>>> defineTypeOp .......... 1 >>>>> Total ........... 416,467 >>>>> ? ? ? 24.40 real >>>>> ? ? ? 15.30 user >>>>> ? ? ? ? 9.07 sys >>>>> >>>>> dimholt:~/dev/opentheory$ time bin/mlton/opentheory info --inference >>>>> foo.art Primitive inferences: >>>>> eqMp ............. 68,100 >>>>> subst ............ 56,228 >>>>> deductAntisym .... 51,689 >>>>> appThm ........... 17,378 >>>>> betaConv .......... 6,866 >>>>> refl .............. 6,325 >>>>> absThm ............ 4,267 >>>>> assume ............ 1,608 >>>>> axiom ............... 190 >>>>> defineConst .......... 26 >>>>> defineTypeOp .......... 1 >>>>> Total ........... 212,678 >>>>> >>>>> real ? ?0m5.289s >>>>> user ? ?0m5.027s >>>>> sys ? ? 0m0.256s >>>>> >>>>> _______________________________________________ >>>>> 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 >> >> _______________________________________________ >> 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 Michael.Norrish at nicta.com.au Tue Dec 6 23:02:02 2011 From: Michael.Norrish at nicta.com.au (Michael Norrish) Date: Wed, 07 Dec 2011 10:02:02 +1100 Subject: [opentheory-users] the Unwanted namespace In-Reply-To: References: Message-ID: <4EDE9EEA.4030902@nicta.com.au> I think the mistake here is mapping the Abbrev constant to Unwanted. I'd say it was probably worth preserving. Michael On 07/12/11 09:35, Joe Hurd wrote: > Hi Ramana, > > Good job digging up a counter-example to my claim about how tags are > used, but I think it's probably not worth the effort to handle exotic > cases. Perhaps the theorem you found could be deduced from a form with > a fully applied tag? > > Cheers, > > Joe > > On Tue, Dec 6, 2011 at 11:53 AM, Ramana Kumar wrote: >> On Tue, Dec 6, 2011 at 7:36 PM, Joe Hurd wrote: >>> The solution is to ensure that every instance of Unwanted.id in theory >>> assumptions and theorems is fully applied. This should always be the >>> case for constants used to tag terms, which are the main use-case of >>> Unwanted.id. >> >> I'm not so sure about that. This theorem is from the HOL4 library >> (combinTheory.literal_case_FORALL_ELIM): >> >> |- literal_case f v ? (!) (S ((==>) o Abbrev o C (=) v) f) >> >> The "Abbrev" constant in the middle there is a tag for abbreviations >> (which I map to Unwanted.id). >> (This is where, I believe, my axiom in the lazy list theory was coming from.) >> >> I'm not sure why this theorem has the form it does, but it could be an >> example of a useful not-fully-applied tag. >> Perhaps someone who knows more about that theorem could clarify... >> >>> >>> Cheers, >>> >>> Joe >>> >>> On Tue, Dec 6, 2011 at 11:18 AM, Ramana Kumar wrote: >>>> Will your scheme for eliminating Unwanted.id work in terms where it >>>> does not appear fully applied, but can still be eliminated? >>>> Specifically, when Unwanted.id is composed with another function. >>>> >>>> On Tue, Dec 6, 2011 at 6:44 PM, Ramana Kumar wrote: >>>>> Thanks for making it quicker :) >>>>> >>>>> Now, the only place where Unwanted.id seems not to be erased is in an >>>>> apparent axiom required by my article. >>>>> Can you confirm that the article is actually trying to define Unwanted.id? >>>>> I generated the article from a HOL4 theory that I don't think should >>>>> be defining anything mapped to Unwanted.id, so I'm a bit confused >>>>> about that at the moment... >>>>> >>>>> On Tue, Dec 6, 2011 at 4:58 AM, Joe Hurd wrote: >>>>>> Hi Ramana, >>>>>> >>>>>> I fixed a performance bug in the proof rewriting, and your example >>>>>> goes through pretty quickly now (see below). The fix is both pushed >>>>>> and released in the latest version of the opentheory tool. >>>>>> >>>>>> Cheers, >>>>>> >>>>>> Joe >>>>>> >>>>>> ________________________________________________________________ >>>>>> >>>>>> dimholt:~/dev/opentheory$ gzcat ~/Desktop/ll.art.gz | time >>>>>> bin/mlton/opentheory info --inference article:- >>>>>> WARNING: 38 objects left on the stack by - >>>>>> WARNING: 473,658 objects left in the dictionary by - >>>>>> Primitive inferences: >>>>>> eqMp ............ 150,377 >>>>>> deductAntisym ... 129,584 >>>>>> subst ............ 76,065 >>>>>> appThm ........... 20,748 >>>>>> assume ........... 18,086 >>>>>> refl .............. 9,363 >>>>>> betaConv .......... 7,461 >>>>>> absThm ............ 4,564 >>>>>> axiom ............... 193 >>>>>> defineConst .......... 25 >>>>>> defineTypeOp .......... 1 >>>>>> Total ........... 416,467 >>>>>> 24.40 real >>>>>> 15.30 user >>>>>> 9.07 sys >>>>>> >>>>>> dimholt:~/dev/opentheory$ time bin/mlton/opentheory info --inference >>>>>> foo.art Primitive inferences: >>>>>> eqMp ............. 68,100 >>>>>> subst ............ 56,228 >>>>>> deductAntisym .... 51,689 >>>>>> appThm ........... 17,378 >>>>>> betaConv .......... 6,866 >>>>>> refl .............. 6,325 >>>>>> absThm ............ 4,267 >>>>>> assume ............ 1,608 >>>>>> axiom ............... 190 >>>>>> defineConst .......... 26 >>>>>> defineTypeOp .......... 1 >>>>>> Total ........... 212,678 >>>>>> >>>>>> real 0m5.289s >>>>>> user 0m5.027s >>>>>> sys 0m0.256s >>>>>> >>>>>> _______________________________________________ >>>>>> 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 >>> >>> _______________________________________________ >>> 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 > > _______________________________________________ > opentheory-users mailing list > opentheory-users at gilith.com > http://www.gilith.com/mailman/listinfo/opentheory-users -------------- next part -------------- A non-text attachment was scrubbed... Name: signature.asc Type: application/pgp-signature Size: 554 bytes Desc: OpenPGP digital signature URL: From ramana.kumar at gmail.com Wed Dec 7 07:47:43 2011 From: ramana.kumar at gmail.com (Ramana Kumar) Date: Wed, 7 Dec 2011 07:47:43 +0000 Subject: [opentheory-users] the Unwanted namespace In-Reply-To: <4EDE9EEA.4030902@nicta.com.au> References: <4EDE9EEA.4030902@nicta.com.au> Message-ID: On Dec 6, 2011 11:02 PM, "Michael Norrish" wrote: > > I think the mistake here is mapping the Abbrev constant to Unwanted. I'd say it was probably worth preserving. Why? What does it mean outside of HOL4? > > Michael > > On 07/12/11 09:35, Joe Hurd wrote: > > Hi Ramana, > > > > Good job digging up a counter-example to my claim about how tags are > > used, but I think it's probably not worth the effort to handle exotic > > cases. Perhaps the theorem you found could be deduced from a form with > > a fully applied tag? > > > > Cheers, > > > > Joe > > > > On Tue, Dec 6, 2011 at 11:53 AM, Ramana Kumar wrote: > >> On Tue, Dec 6, 2011 at 7:36 PM, Joe Hurd wrote: > >>> The solution is to ensure that every instance of Unwanted.id in theory > >>> assumptions and theorems is fully applied. This should always be the > >>> case for constants used to tag terms, which are the main use-case of > >>> Unwanted.id. > >> > >> I'm not so sure about that. This theorem is from the HOL4 library > >> (combinTheory.literal_case_FORALL_ELIM): > >> > >> |- literal_case f v ? (!) (S ((==>) o Abbrev o C (=) v) f) > >> > >> The "Abbrev" constant in the middle there is a tag for abbreviations > >> (which I map to Unwanted.id). > >> (This is where, I believe, my axiom in the lazy list theory was coming from.) > >> > >> I'm not sure why this theorem has the form it does, but it could be an > >> example of a useful not-fully-applied tag. > >> Perhaps someone who knows more about that theorem could clarify... > >> > >>> > >>> Cheers, > >>> > >>> Joe > >>> > >>> On Tue, Dec 6, 2011 at 11:18 AM, Ramana Kumar wrote: > >>>> Will your scheme for eliminating Unwanted.id work in terms where it > >>>> does not appear fully applied, but can still be eliminated? > >>>> Specifically, when Unwanted.id is composed with another function. > >>>> > >>>> On Tue, Dec 6, 2011 at 6:44 PM, Ramana Kumar wrote: > >>>>> Thanks for making it quicker :) > >>>>> > >>>>> Now, the only place where Unwanted.id seems not to be erased is in an > >>>>> apparent axiom required by my article. > >>>>> Can you confirm that the article is actually trying to define Unwanted.id? > >>>>> I generated the article from a HOL4 theory that I don't think should > >>>>> be defining anything mapped to Unwanted.id, so I'm a bit confused > >>>>> about that at the moment... > >>>>> > >>>>> On Tue, Dec 6, 2011 at 4:58 AM, Joe Hurd wrote: > >>>>>> Hi Ramana, > >>>>>> > >>>>>> I fixed a performance bug in the proof rewriting, and your example > >>>>>> goes through pretty quickly now (see below). The fix is both pushed > >>>>>> and released in the latest version of the opentheory tool. > >>>>>> > >>>>>> Cheers, > >>>>>> > >>>>>> Joe > >>>>>> > >>>>>> ________________________________________________________________ > >>>>>> > >>>>>> dimholt:~/dev/opentheory$ gzcat ~/Desktop/ll.art.gz | time > >>>>>> bin/mlton/opentheory info --inference article:- > >>>>>> WARNING: 38 objects left on the stack by - > >>>>>> WARNING: 473,658 objects left in the dictionary by - > >>>>>> Primitive inferences: > >>>>>> eqMp ............ 150,377 > >>>>>> deductAntisym ... 129,584 > >>>>>> subst ............ 76,065 > >>>>>> appThm ........... 20,748 > >>>>>> assume ........... 18,086 > >>>>>> refl .............. 9,363 > >>>>>> betaConv .......... 7,461 > >>>>>> absThm ............ 4,564 > >>>>>> axiom ............... 193 > >>>>>> defineConst .......... 25 > >>>>>> defineTypeOp .......... 1 > >>>>>> Total ........... 416,467 > >>>>>> 24.40 real > >>>>>> 15.30 user > >>>>>> 9.07 sys > >>>>>> > >>>>>> dimholt:~/dev/opentheory$ time bin/mlton/opentheory info --inference > >>>>>> foo.art Primitive inferences: > >>>>>> eqMp ............. 68,100 > >>>>>> subst ............ 56,228 > >>>>>> deductAntisym .... 51,689 > >>>>>> appThm ........... 17,378 > >>>>>> betaConv .......... 6,866 > >>>>>> refl .............. 6,325 > >>>>>> absThm ............ 4,267 > >>>>>> assume ............ 1,608 > >>>>>> axiom ............... 190 > >>>>>> defineConst .......... 26 > >>>>>> defineTypeOp .......... 1 > >>>>>> Total ........... 212,678 > >>>>>> > >>>>>> real 0m5.289s > >>>>>> user 0m5.027s > >>>>>> sys 0m0.256s > >>>>>> > >>>>>> _______________________________________________ > >>>>>> 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 > >>> > >>> _______________________________________________ > >>> 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 > > > > _______________________________________________ > > 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 Michael.Norrish at nicta.com.au Wed Dec 7 08:46:06 2011 From: Michael.Norrish at nicta.com.au (Michael Norrish) Date: Wed, 07 Dec 2011 19:46:06 +1100 Subject: [opentheory-users] the Unwanted namespace In-Reply-To: References: <4EDE9EEA.4030902@nicta.com.au> Message-ID: <4EDF27CE.30601@nicta.com.au> On 7/12/11 6:47 PM, Ramana Kumar wrote: > On Dec 6, 2011 11:02 PM, "Michael Norrish" > wrote: >> >> I think the mistake here is mapping the Abbrev constant to Unwanted. > I'd say it was probably worth preserving. > > Why? What does it mean outside of HOL4? Nothing particularly. But I want to use opentheory as a storage mechanism for HOL4 theories, and so the technology needs to be faithful to what is in the HOL4 theories. But I admit I may have misunderstood the issue here. In particular, I'd be surprised if Abbrev actually appears in any theory's exports except for the definition and that forall-rewrite. Michael -------------- next part -------------- A non-text attachment was scrubbed... Name: signature.asc Type: application/pgp-signature Size: 551 bytes Desc: OpenPGP digital signature URL: From ramana.kumar at gmail.com Wed Dec 7 09:01:41 2011 From: ramana.kumar at gmail.com (Ramana Kumar) Date: Wed, 7 Dec 2011 09:01:41 +0000 Subject: [opentheory-users] the Unwanted namespace In-Reply-To: <4EDF27CE.30601@nicta.com.au> References: <4EDE9EEA.4030902@nicta.com.au> <4EDF27CE.30601@nicta.com.au> Message-ID: On Wed, Dec 7, 2011 at 8:46 AM, Michael Norrish wrote: > On 7/12/11 6:47 PM, Ramana Kumar wrote: >> On Dec 6, 2011 11:02 PM, "Michael Norrish" > > wrote: >>> >>> I think the mistake here is mapping the Abbrev constant to Unwanted. >> ?I'd say it was probably worth preserving. >> >> Why? What does it mean outside of HOL4? > > Nothing particularly. ?But I want to use opentheory as a storage > mechanism for HOL4 theories, and so the technology needs to be faithful > to what is in the HOL4 theories. I think opentheory would need to be augmented with something before it was really appropriate for storing faithful copies of prover-specific theories. There's no mechanism for storing syntax information (e.g. precedence, associativity) or overloads, automatic rewrites, any additional (non-logical) functionality (like a library associated with a theory), or even names for theorems. And I think it's correct to map things like Abbrev and NUMERAL to Unwanted.id, so when you read back the theory, the numbers are missing their tags, for example (that might be fixed by a smarter reader). It would be worth thinking about how to do all that with opentheory. I wouldn't want to compromise the goal of storing prover-independent theories without a good reason, though... >?But I admit I may have misunderstood > the issue here. ?In particular, I'd be surprised if Abbrev actually > appears in any theory's exports except for the definition and that > forall-rewrite. I don't think it appears in any of the exports... I guess it must have been used somewhere in a proof and then, since it couldn't be removed from the rewrite, ended up having to be defined (and appearing in an axiom). > > Michael > > > > _______________________________________________ > opentheory-users mailing list > opentheory-users at gilith.com > http://www.gilith.com/mailman/listinfo/opentheory-users > From michael.norrish at nicta.com.au Thu Dec 8 09:50:05 2011 From: michael.norrish at nicta.com.au (Michael Norrish) Date: Thu, 8 Dec 2011 20:50:05 +1100 Subject: [opentheory-users] the Unwanted namespace In-Reply-To: References: <4EDE9EEA.4030902@nicta.com.au> <4EDF27CE.30601@nicta.com.au> On 07/12/2011, at 20:01, Ramana Kumar wrote: > > It would be worth thinking about how to do all that with opentheory. > I wouldn't want to compromise the goal of storing prover-independent > theories without a good reason, though... My concern is that the resulting system might forget things that can't be recovered. Then it will never be usable as a theory storage mechanism. Is it possible to create a faithful representation of what's there that does support getting back exactly what was put in, and to *then* work on forgetting stuff that doesn't belong in theories meant for sharing with other systems? Michael -------------- next part -------------- An HTML attachment was scrubbed... URL: From ramana.kumar at gmail.com Thu Dec 8 10:32:57 2011 From: ramana.kumar at gmail.com (Ramana Kumar) Date: Thu, 8 Dec 2011 10:32:57 +0000 Subject: [opentheory-users] the Unwanted namespace In-Reply-To: References: <4EDE9EEA.4030902@nicta.com.au> <4EDF27CE.30601@nicta.com.au> Message-ID: Can we make a comprehensive list of the kind of stuff we might want to store in a theory package? I suspect there will be different recovery methods suitable for different kinds of data, and looking at the requirements will help see if and how opentheory might have to be modified or extended. - Tag-free theorems, definitions, low-level proofs. : already handled by article format - theory name and description and dependencies : already handled by theory package format - NUMERAL tags : reconstructible on reading? - Abbrev tags - Other tags? (Such as?) : An alternative approach might be to store terms in an article as-is (with tags) and then have different processing options for cleaning up an article like do-nothing, remove all tags, remove all of the following tags, or even possibly introduce tags for a specific prover (if they are inferable). - theorem names : could be stored in a separate file mapping names to statements? - automatic rewrites : could be stored in a separate file containing a list of theorems? - parsing and printing rules, and overloads : also could be in a separate file? - derived rules and other functionality associated with a theory - tactics, provers/decision procedures - syntax manipulation functions - what else? : again, could be in a separate file of code, possibly using opentheory article format to interface with the required constants/theorems in the theory? - what else? At the moment it looks like almost everything could be handled by extra files that would be mentioned in a theory package but wouldn't interfere with article files in their current form. Only tag constants are a problem because they change the terms the article is dealing with. Are there examples of tags that are definitely not reconstructible if they are thrown away during cleanup? On Thu, Dec 8, 2011 at 9:50 AM, Michael Norrish wrote: > On 07/12/2011, at 20:01, Ramana Kumar wrote: > > > It would be worth thinking about how to do all that with opentheory. > I wouldn't want to compromise the goal of storing prover-independent > theories without a good reason, though... > > > My concern is that the resulting system might forget things that can't be > recovered. ?Then it will never be usable as a theory storage mechanism. ? Is > it possible to create a faithful representation of what's there that does > support getting back exactly what was put in, and to *then* work on > forgetting stuff that doesn't belong in theories meant for sharing with > other systems? > > Michael > > _______________________________________________ > opentheory-users mailing list > opentheory-users at gilith.com > http://www.gilith.com/mailman/listinfo/opentheory-users > From Michael.Norrish at nicta.com.au Mon Dec 12 02:13:49 2011 From: Michael.Norrish at nicta.com.au (Michael Norrish) Date: Mon, 12 Dec 2011 13:13:49 +1100 Subject: [opentheory-users] the Unwanted namespace In-Reply-To: References: <4EDE9EEA.4030902@nicta.com.au> <4EDF27CE.30601@nicta.com.au> Message-ID: <4EE5635D.8090401@nicta.com.au> I think it?s clear that there?s no end of cruft that systems might like to put into theory files. Even the ?names? field you mention below may vary from system to system. Given that, we need some generic way of stuffing arbitrary, well-delimited strings into theory files. I?d probably prefer these strings to be inline, but it could also be done with associated files if necessary. I like the default being the storage of everything. Another example of a tag-like thing is the way we use K T x to store arbitrary terms x in a theory so that the term can be referred to by the LaTeX machinery we have. Michael On 08/12/11 21:32, Ramana Kumar wrote: > Can we make a comprehensive list of the kind of stuff we might want to > store in a theory package? > I suspect there will be different recovery methods suitable for > different kinds of data, and looking at the requirements will help see > if and how opentheory might have to be modified or extended. > > - Tag-free theorems, definitions, low-level proofs. > : already handled by article format > > - theory name and description and dependencies > : already handled by theory package format > > - NUMERAL tags > : reconstructible on reading? > > - Abbrev tags > > - Other tags? (Such as?) > : An alternative approach might be to store terms in an article as-is > (with tags) and then have different processing options for cleaning up > an article like do-nothing, remove all tags, remove all of the > following tags, or even possibly introduce tags for a specific prover > (if they are inferable). > > - theorem names > : could be stored in a separate file mapping names to statements? > > - automatic rewrites > : could be stored in a separate file containing a list of theorems? > > - parsing and printing rules, and overloads > : also could be in a separate file? > > - derived rules and other functionality associated with a theory > - tactics, provers/decision procedures > - syntax manipulation functions > - what else? > : again, could be in a separate file of code, possibly using > opentheory article format to interface with the required > constants/theorems in the theory? > > - what else? > > At the moment it looks like almost everything could be handled by > extra files that would be mentioned in a theory package but wouldn't > interfere with article files in their current form. Only tag constants > are a problem because they change the terms the article is dealing > with. > > Are there examples of tags that are definitely not reconstructible if > they are thrown away during cleanup? > > > On Thu, Dec 8, 2011 at 9:50 AM, Michael Norrish > wrote: >> On 07/12/2011, at 20:01, Ramana Kumar wrote: >> >> >> It would be worth thinking about how to do all that with opentheory. >> I wouldn't want to compromise the goal of storing prover-independent >> theories without a good reason, though... >> >> >> My concern is that the resulting system might forget things that can't be >> recovered. Then it will never be usable as a theory storage mechanism. Is >> it possible to create a faithful representation of what's there that does >> support getting back exactly what was put in, and to *then* work on >> forgetting stuff that doesn't belong in theories meant for sharing with >> other systems? >> >> Michael >> >> _______________________________________________ >> 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 -------------- A non-text attachment was scrubbed... Name: signature.asc Type: application/pgp-signature Size: 554 bytes Desc: OpenPGP digital signature URL: