Polymorphic classes first draft
This commit is contained in:
Nicolas Méric
parent
5a7cbf2da5
commit
b364880bfc
|
|
@ -184,7 +184,7 @@ scenarios from the point of view of the ontology modeling. In @{text_section (un
|
|||
we discuss the user-interaction generated from the ontological definitions. Finally, we draw
|
||||
conclusions and discuss related work in @{text_section (unchecked) \<open>conclusion\<close>}. \<close>
|
||||
|
||||
section*[bgrnd::text_section,main_author="Some(@{docitem ''bu''}::author)"]
|
||||
section*[bgrnd::text_section,main_author="Some(@{author ''bu''}::author)"]
|
||||
\<open> Background: The Isabelle System \<close>
|
||||
text*[background::introduction, level="Some 1"]\<open>
|
||||
While Isabelle is widely perceived as an interactive theorem prover for HOL
|
||||
|
|
@ -246,7 +246,7 @@ can be type-checked before being displayed and can be used for calculations befo
|
|||
typeset. When editing, Isabelle's PIDE offers auto-completion and error-messages while typing the
|
||||
above \<^emph>\<open>semi-formal\<close> content.\<close>
|
||||
|
||||
section*[isadof::technical,main_author="Some(@{docitem ''adb''}::author)"]\<open> \<^isadof> \<close>
|
||||
section*[isadof::technical,main_author="Some(@{author ''adb''}::author)"]\<open> \<^isadof> \<close>
|
||||
|
||||
text\<open> An \<^isadof> document consists of three components:
|
||||
\<^item> the \<^emph>\<open>ontology definition\<close> which is an Isabelle theory file with definitions
|
||||
|
|
|
|||
|
|
@ -54,7 +54,7 @@ abstract*[abs, keywordlist="[\<open>Shallow Embedding\<close>,\<open>Process-Alg
|
|||
If you consider citing this paper, please refer to @{cite "HOL-CSP-iFM2020"}.
|
||||
\<close>
|
||||
text\<open>\<close>
|
||||
section*[introheader::introduction,main_author="Some(@{docitem ''bu''}::author)"]\<open> Introduction \<close>
|
||||
section*[introheader::introduction,main_author="Some(@{author ''bu''}::author)"]\<open> Introduction \<close>
|
||||
text*[introtext::introduction, level="Some 1"]\<open>
|
||||
Communicating Sequential Processes (\<^csp>) is a language to specify and verify patterns of
|
||||
interaction of concurrent systems. Together with CCS and LOTOS, it belongs to the family of
|
||||
|
|
@ -126,10 +126,10 @@ attempt to formalize denotational \<^csp> semantics covering a part of Bill Rosc
|
|||
omitted.\<close>}.
|
||||
\<close>
|
||||
|
||||
section*["pre"::tc,main_author="Some(@{author \<open>bu\<close>}::author)"]
|
||||
section*["pre"::technical,main_author="Some(@{author \<open>bu\<close>}::author)"]
|
||||
\<open>Preliminaries\<close>
|
||||
|
||||
subsection*[cspsemantics::tc, main_author="Some(@{author ''bu''})"]\<open>Denotational \<^csp> Semantics\<close>
|
||||
subsection*[cspsemantics::technical, main_author="Some(@{author ''bu''})"]\<open>Denotational \<^csp> Semantics\<close>
|
||||
|
||||
text\<open> The denotational semantics (following @{cite "roscoe:csp:1998"}) comes in three layers:
|
||||
the \<^emph>\<open>trace model\<close>, the \<^emph>\<open>(stable) failures model\<close> and the \<^emph>\<open>failure/divergence model\<close>.
|
||||
|
|
@ -189,7 +189,7 @@ of @{cite "IsobeRoggenbach2010"} is restricted to a variant of the failures mode
|
|||
|
||||
\<close>
|
||||
|
||||
subsection*["isabelleHol"::tc, main_author="Some(@{author ''bu''})"]\<open>Isabelle/HOL\<close>
|
||||
subsection*["isabelleHol"::technical, main_author="Some(@{author ''bu''})"]\<open>Isabelle/HOL\<close>
|
||||
text\<open> Nowadays, Isabelle/HOL is one of the major interactive theory development environments
|
||||
@{cite "nipkow.ea:isabelle:2002"}. HOL stands for Higher-Order Logic, a logic based on simply-typed
|
||||
\<open>\<lambda>\<close>-calculus extended by parametric polymorphism and Haskell-like type-classes.
|
||||
|
|
@ -218,10 +218,10 @@ domain theory for a particular type-class \<open>\<alpha>::pcpo\<close>, \<^ie>
|
|||
fixed-point induction and other (automated) proof infrastructure. Isabelle's type-inference can
|
||||
automatically infer, for example, that if \<open>\<alpha>::pcpo\<close>, then \<open>(\<beta> \<Rightarrow> \<alpha>)::pcpo\<close>. \<close>
|
||||
|
||||
section*["csphol"::tc,main_author="Some(@{author ''bu''}::author)", level="Some 2"]
|
||||
section*["csphol"::technical,main_author="Some(@{author ''bu''}::author)", level="Some 2"]
|
||||
\<open>Formalising Denotational \<^csp> Semantics in HOL \<close>
|
||||
|
||||
subsection*["processinv"::tc, main_author="Some(@{author ''bu''})"]
|
||||
subsection*["processinv"::technical, main_author="Some(@{author ''bu''})"]
|
||||
\<open>Process Invariant and Process Type\<close>
|
||||
text\<open> First, we need a slight revision of the concept
|
||||
of \<^emph>\<open>trace\<close>: if \<open>\<Sigma>\<close> is the type of the atomic events (represented by a type variable), then
|
||||
|
|
@ -272,7 +272,7 @@ but this can be constructed in a straight-forward manner. Suitable definitions f
|
|||
\<open>\<T>\<close>, \<open>\<F>\<close> and \<open>\<D>\<close> lifting \<open>fst\<close> and \<open>snd\<close> on the new \<open>'\<alpha> process\<close>-type allows to derive
|
||||
the above properties for any \<open>P::'\<alpha> process\<close>. \<close>
|
||||
|
||||
subsection*["operator"::tc, main_author="Some(@{author ''lina''})"]
|
||||
subsection*["operator"::technical, main_author="Some(@{author ''lina''})"]
|
||||
\<open>\<^csp> Operators over the Process Type\<close>
|
||||
text\<open> Now, the operators of \<^csp> \<open>Skip\<close>, \<open>Stop\<close>, \<open>_\<sqinter>_\<close>, \<open>_\<box>_\<close>, \<open>_\<rightarrow>_\<close>,\<open>_\<lbrakk>_\<rbrakk>_\<close> etc.
|
||||
for internal choice, external choice, prefix and parallel composition, can
|
||||
|
|
@ -297,7 +297,7 @@ The definitional presentation of the \<^csp> process operators according to @{ci
|
|||
follows always this scheme. This part of the theory comprises around 2000 loc.
|
||||
\<close>
|
||||
|
||||
subsection*["orderings"::tc, main_author="Some(@{author ''bu''})"]
|
||||
subsection*["orderings"::technical, main_author="Some(@{author ''bu''})"]
|
||||
\<open>Refinement Orderings\<close>
|
||||
|
||||
text\<open> \<^csp> is centered around the idea of process refinement; many critical properties,
|
||||
|
|
@ -327,7 +327,7 @@ states, from which no internal progress is possible.
|
|||
\<close>
|
||||
|
||||
|
||||
subsection*["fixpoint"::tc, main_author="Some(@{author ''lina''})"]
|
||||
subsection*["fixpoint"::technical, main_author="Some(@{author ''lina''})"]
|
||||
\<open>Process Ordering and HOLCF\<close>
|
||||
text\<open> For any denotational semantics, the fixed point theory giving semantics to systems
|
||||
of recursive equations is considered as keystone. Its prerequisite is a complete partial ordering
|
||||
|
|
@ -394,7 +394,7 @@ Fixed-point inductions are the main proof weapon in verifications, together with
|
|||
and the \<^csp> laws. Denotational arguments can be hidden as they are not needed in practical
|
||||
verifications. \<close>
|
||||
|
||||
subsection*["law"::tc, main_author="Some(@{author ''lina''})"]
|
||||
subsection*["law"::technical, main_author="Some(@{author ''lina''})"]
|
||||
\<open>\<^csp> Rules: Improved Proofs and New Results\<close>
|
||||
|
||||
|
||||
|
|
@ -436,11 +436,11 @@ cases to be considered as well as their complexity makes pen and paper proofs
|
|||
practically infeasible.
|
||||
\<close>
|
||||
|
||||
section*["newResults"::tc,main_author="Some(@{author ''safouan''}::author)",
|
||||
section*["newResults"::technical,main_author="Some(@{author ''safouan''}::author)",
|
||||
main_author="Some(@{author ''lina''}::author)", level= "Some 3"]
|
||||
\<open>Theoretical Results on Refinement\<close>
|
||||
text\<open>\<close>
|
||||
subsection*["adm"::tc,main_author="Some(@{author ''safouan''}::author)",
|
||||
subsection*["adm"::technical,main_author="Some(@{author ''safouan''}::author)",
|
||||
main_author="Some(@{author ''lina''}::author)"]
|
||||
\<open>Decomposition Rules\<close>
|
||||
text\<open>
|
||||
|
|
@ -476,7 +476,7 @@ The failure and divergence projections of this operator are also interdependent,
|
|||
sequence operator. Hence, this operator is not monotonic with \<open>\<sqsubseteq>\<^sub>\<F>\<close>, \<open>\<sqsubseteq>\<^sub>\<D>\<close> and \<open>\<sqsubseteq>\<^sub>\<T>\<close>, but monotonic
|
||||
when their combinations are considered. \<close>
|
||||
|
||||
subsection*["processes"::tc,main_author="Some(@{author ''safouan''}::author)",
|
||||
subsection*["processes"::technical,main_author="Some(@{author ''safouan''}::author)",
|
||||
main_author="Some(@{author ''lina''}::author)"]
|
||||
\<open>Reference Processes and their Properties\<close>
|
||||
text\<open>
|
||||
|
|
@ -597,7 +597,7 @@ then it may still be livelock-free. % This makes sense since livelocks are worse
|
|||
|
||||
\<close>
|
||||
|
||||
section*["advanced"::tc,main_author="Some(@{author ''safouan''}::author)",level="Some 3"]
|
||||
section*["advanced"::technical,main_author="Some(@{author ''safouan''}::author)",level="Some 3"]
|
||||
\<open>Advanced Verification Techniques\<close>
|
||||
|
||||
text\<open>
|
||||
|
|
@ -612,7 +612,7 @@ verification. In the latter case, we present an approach to a verification of a
|
|||
architecture, in this case a ring-structure of arbitrary size.
|
||||
\<close>
|
||||
|
||||
subsection*["illustration"::tc,main_author="Some(@{author ''safouan''}::author)", level="Some 3"]
|
||||
subsection*["illustration"::technical,main_author="Some(@{author ''safouan''}::author)", level="Some 3"]
|
||||
\<open>The General CopyBuffer Example\<close>
|
||||
text\<open>
|
||||
We consider the paradigmatic copy buffer example @{cite "Hoare:1985:CSP:3921" and "Roscoe:UCS:2010"}
|
||||
|
|
@ -677,7 +677,7 @@ corollary deadlock_free COPY
|
|||
\<close>
|
||||
|
||||
|
||||
subsection*["inductions"::tc,main_author="Some(@{author ''safouan''}::author)"]
|
||||
subsection*["inductions"::technical,main_author="Some(@{author ''safouan''}::author)"]
|
||||
\<open>New Fixed-Point Inductions\<close>
|
||||
|
||||
text\<open>
|
||||
|
|
@ -727,7 +727,7 @@ The astute reader may notice here that if the induction step is weakened (having
|
|||
the base steps require enforcement.
|
||||
\<close>
|
||||
|
||||
subsection*["norm"::tc,main_author="Some(@{author ''safouan''}::author)"]
|
||||
subsection*["norm"::technical,main_author="Some(@{author ''safouan''}::author)"]
|
||||
\<open>Normalization\<close>
|
||||
text\<open>
|
||||
Our framework can reason not only over infinite alphabets, but also over processes parameterized
|
||||
|
|
@ -787,7 +787,7 @@ Summing up, our method consists of four stages:
|
|||
|
||||
\<close>
|
||||
|
||||
subsection*["dining_philosophers"::tc,main_author="Some(@{author ''safouan''}::author)",level="Some 3"]
|
||||
subsection*["dining_philosophers"::technical,main_author="Some(@{author ''safouan''}::author)",level="Some 3"]
|
||||
\<open>Generalized Dining Philosophers\<close>
|
||||
|
||||
text\<open> The dining philosophers problem is another paradigmatic example in the \<^csp> literature
|
||||
|
|
@ -879,7 +879,7 @@ for a dozen of philosophers (on a usual machine) due to the exponential combinat
|
|||
Furthermore, our proof is fairly stable against modifications like adding non synchronized events like
|
||||
thinking or sitting down in contrast to model-checking techniques. \<close>
|
||||
|
||||
section*["relatedwork"::tc,main_author="Some(@{author ''lina''}::author)",level="Some 3"]
|
||||
section*["relatedwork"::technical,main_author="Some(@{author ''lina''}::author)",level="Some 3"]
|
||||
\<open>Related work\<close>
|
||||
|
||||
text\<open>
|
||||
|
|
|
|||
|
|
@ -131,7 +131,7 @@ type_synonym XX = B
|
|||
|
||||
section\<open>Examples of inheritance \<close>
|
||||
|
||||
doc_class C = XX +
|
||||
doc_class C = B +
|
||||
z :: "A option" <= None (* A LINK, i.e. an attribute that has a type
|
||||
referring to a document class. Mathematical
|
||||
relations over document items can be modeled. *)
|
||||
|
|
|
|||
|
|
@ -160,7 +160,7 @@ ML\<open> @{docitem_attribute a2::omega};
|
|||
|
||||
type_synonym ALFACENTAURI = E
|
||||
|
||||
update_instance*[omega::ALFACENTAURI, x+="''inition''"]
|
||||
update_instance*[omega::E, x+="''inition''"]
|
||||
|
||||
ML\<open> val s = HOLogic.dest_string ( @{docitem_attribute x::omega}) \<close>
|
||||
|
||||
|
|
|
|||
|
|
@ -144,8 +144,8 @@ update_instance*[f::F,r:="[@{thm ''Concept_OntoReferencing.some_proof''}]"]
|
|||
text\<open> ..., mauris amet, id elit aliquam aptent id, ... @{docitem \<open>a\<close>} \<close>
|
||||
(*>*)
|
||||
text\<open>Here we add and maintain a link that is actually modeled as m-to-n relation ...\<close>
|
||||
update_instance*[f::F,b:="{(@{docitem \<open>a\<close>}::A,@{docitem \<open>c1\<close>}::C),
|
||||
(@{docitem \<open>a\<close>}, @{docitem \<open>c2\<close>})}"]
|
||||
update_instance*[f::F,b:="{(@{A \<open>a\<close>}::A,@{C \<open>c1\<close>}::C),
|
||||
(@{A \<open>a\<close>}, @{C \<open>c2\<close>})}"]
|
||||
|
||||
section\<open>Closing the Monitor and testing the Results.\<close>
|
||||
|
||||
|
|
|
|||
|
|
@ -116,20 +116,22 @@ section\<open>Putting everything together\<close>
|
|||
|
||||
text\<open>Major sample: test-item of doc-class \<open>F\<close> with a relational link between class instances,
|
||||
and links to formal Isabelle items like \<open>typ\<close>, \<open>term\<close> and \<open>thm\<close>. \<close>
|
||||
declare[[ML_print_depth = 10000]]
|
||||
text*[xcv4::F, r="[@{thm ''HOL.refl''},
|
||||
@{thm \<open>Concept_TermAntiquotations.local_sample_lemma\<close>}]", (* long names required *)
|
||||
b="{(@{docitem ''xcv1''},@{docitem \<open>xcv2\<close>})}", (* notations \<open>...\<close> vs. ''...'' *)
|
||||
b="{(@{A ''xcv1''},@{C \<open>xcv2\<close>})}", (* notations \<open>...\<close> vs. ''...'' *)
|
||||
s="[@{typ \<open>int list\<close>}]",
|
||||
properties = "[@{term \<open>H \<longrightarrow> H\<close>}]" (* notation \<open>...\<close> required for UTF8*)
|
||||
]\<open>Lorem ipsum ...\<close>
|
||||
|
||||
declare[[ML_print_depth = 20]]
|
||||
text*[xcv5::G, g="@{thm \<open>HOL.sym\<close>}"]\<open>Lorem ipsum ...\<close>
|
||||
|
||||
text\<open>... and here we add a relation between @{docitem \<open>xcv3\<close>} and @{docitem \<open>xcv2\<close>}
|
||||
into the relation \verb+b+ of @{docitem \<open>xcv5\<close>}. Note that in the link-relation,
|
||||
a @{typ "C"}-type is required, but a @{typ "G"}-type is offered which is legal in
|
||||
\verb+Isa_DOF+ because of the sub-class relation between those classes: \<close>
|
||||
update_instance*[xcv4::F, b+="{(@{docitem ''xcv3''},@{docitem ''xcv5''})}"]
|
||||
a @{typ "C"}-type is required, so if a @{typ "G"}-type is offered, it is considered illegal
|
||||
in \verb+Isa_DOF+ despite the sub-class relation between those classes: \<close>
|
||||
update_instance-assert-error[xcv4::F, b+="{(@{docitem ''xcv3''},@{docitem ''xcv5''})}"]
|
||||
\<open>Type unification failed\<close>
|
||||
|
||||
text\<open>And here is the results of some ML-term antiquotations:\<close>
|
||||
ML\<open> @{docitem_attribute b::xcv4} \<close>
|
||||
|
|
|
|||
|
|
@ -187,7 +187,7 @@ to update the instance @{docitem \<open>xcv4\<close>}:
|
|||
\<close>
|
||||
|
||||
update_instance-assert-error[xcv4::F, b+="{(@{A ''xcv3''},@{G ''xcv5''})}"]
|
||||
\<open>type of attribute: Conceptual.F.b does not fit to term\<close>
|
||||
\<open>Type unification failed: Clash of types\<close>
|
||||
|
||||
|
||||
section\<open>\<^theory_text>\<open>assert*\<close>-Annotated assertion-commands\<close>
|
||||
|
|
@ -225,11 +225,11 @@ text\<open>... and here we reference @{A \<open>assertionA\<close>}.\<close>
|
|||
(*>*)
|
||||
assert*\<open>evidence @{result \<open>resultProof\<close>} = evidence @{result \<open>resultProof2\<close>}\<close>
|
||||
|
||||
text\<open>The optional evaluator of \<open>value*\<close> and \<open>assert*\<close> must be specified after the meta arguments:\<close>
|
||||
value* [optional_test_A::A, x=6] [nbe] \<open>filter (\<lambda>\<sigma>. A.x \<sigma> > 5) @{A_instances}\<close>
|
||||
text\<open>The optional evaluator of \<open>value*\<close> and \<open>assert*\<close> must be specified before the meta arguments:\<close>
|
||||
value* [nbe] [optional_test_A::A, x=6] \<open>filter (\<lambda>\<sigma>. A.x \<sigma> > 5) @{A_instances}\<close>
|
||||
|
||||
assert* [resultProof3::result, evidence = "proof", property="[@{thm \<open>HOL.sym\<close>}]"] [nbe]
|
||||
\<open>evidence @{result \<open>resultProof3\<close>} = evidence @{result \<open>resultProof2\<close>}\<close>
|
||||
assert* [nbe] [resultProof3::result, evidence = "proof", property="[@{thm \<open>HOL.sym\<close>}]"]
|
||||
\<open>evidence @{result \<open>resultProof3\<close>} = evidence @{result \<open>resultProof2\<close>}\<close>
|
||||
|
||||
text\<open>
|
||||
The evaluation of @{command "assert*"} can be disabled
|
||||
|
|
|
|||
|
|
@ -16,6 +16,7 @@ session "Isabelle_DOF-Unit-Tests" = "Isabelle_DOF-Ontologies" +
|
|||
"Cenelec_Test"
|
||||
"OutOfOrderPresntn"
|
||||
"COL_Test"
|
||||
"Test_Polymorphic_Classes"
|
||||
document_files
|
||||
"root.bib"
|
||||
"figures/A.png"
|
||||
|
|
|
|||
|
|
@ -23,6 +23,8 @@ keywords "text-" "text-latex" :: document_body
|
|||
and "update_instance-assert-error" :: document_body
|
||||
and "declare_reference-assert-error" :: document_body
|
||||
and "value-assert-error" :: document_body
|
||||
and "definition-assert-error" :: document_body
|
||||
and "doc_class-assert-error" :: document_body
|
||||
|
||||
begin
|
||||
|
||||
|
|
@ -152,20 +154,55 @@ val _ =
|
|||
|
||||
|
||||
val _ =
|
||||
let fun pass_trans_to_value_cmd (args, (((name, modes), t),src)) trans =
|
||||
(Value_Command.value_cmd {assert=false} args name modes t @{here} trans
|
||||
handle ERROR msg => (if error_match src msg
|
||||
then (writeln ("Correct error: "^msg^": reported.");trans)
|
||||
else error"Wrong error reported"))
|
||||
let fun pass_trans_to_value_cmd (args, (((name, modes), t),src)) trans =
|
||||
let val pos = Toplevel.pos_of trans
|
||||
in trans |> Toplevel.theory
|
||||
(fn thy => Value_Command.value_cmd {assert=false} args name modes t pos thy
|
||||
handle ERROR msg => (if error_match src msg
|
||||
then (writeln ("Correct error: "^msg^": reported."); thy)
|
||||
else error"Wrong error reported"))
|
||||
end
|
||||
in Outer_Syntax.command \<^command_keyword>\<open>value-assert-error\<close> "evaluate and print term"
|
||||
(ODL_Meta_Args_Parser.opt_attributes --
|
||||
(Value_Command.opt_evaluator
|
||||
-- Value_Command.opt_modes
|
||||
-- Parse.term
|
||||
-- Parse.document_source)
|
||||
>> (Toplevel.theory o pass_trans_to_value_cmd))
|
||||
>> (pass_trans_to_value_cmd))
|
||||
end;
|
||||
|
||||
val _ =
|
||||
let fun definition_cmd' meta_args_opt decl params prems spec src bool ctxt =
|
||||
Local_Theory.background_theory (Value_Command.meta_args_exec meta_args_opt) ctxt
|
||||
|> (fn ctxt => Definition_Star_Command.definition_cmd decl params prems spec bool ctxt
|
||||
handle ERROR msg => if error_match src msg
|
||||
then (writeln ("Correct error: "^msg^": reported.")
|
||||
; pair "Bound 0" @{thm refl}
|
||||
|> pair (Bound 0)
|
||||
|> rpair ctxt)
|
||||
else error"Wrong error reported")
|
||||
in
|
||||
Outer_Syntax.local_theory' \<^command_keyword>\<open>definition-assert-error\<close> "constant definition"
|
||||
(ODL_Meta_Args_Parser.opt_attributes --
|
||||
(Scan.option Parse_Spec.constdecl -- (Parse_Spec.opt_thm_name ":" -- Parse.prop) --
|
||||
Parse_Spec.if_assumes -- Parse.for_fixes -- Parse.document_source)
|
||||
>> (fn (meta_args_opt, ((((decl, spec), prems), params), src)) =>
|
||||
#2 oo definition_cmd' meta_args_opt decl params prems spec src))
|
||||
end;
|
||||
|
||||
|
||||
val _ =
|
||||
let fun add_doc_class_cmd' ((((overloaded, hdr), (parent, attrs)),((rejects,accept_rex),invars)), src) =
|
||||
(fn thy => OntoParser.add_doc_class_cmd {overloaded = overloaded} hdr parent attrs rejects accept_rex invars thy
|
||||
handle ERROR msg => (if error_match src msg
|
||||
then (writeln ("Correct error: "^msg^": reported."); thy)
|
||||
else error"Wrong error reported"))
|
||||
in
|
||||
Outer_Syntax.command \<^command_keyword>\<open>doc_class-assert-error\<close>
|
||||
"define document class"
|
||||
((OntoParser.parse_doc_class -- Parse.document_source)
|
||||
>> (Toplevel.theory o add_doc_class_cmd'))
|
||||
end
|
||||
|
||||
val _ =
|
||||
Outer_Syntax.command ("text-latex", \<^here>) "formal comment (primary style)"
|
||||
|
|
|
|||
|
|
@ -0,0 +1,682 @@
|
|||
theory Test_Polymorphic_Classes
|
||||
imports Isabelle_DOF.Isa_DOF
|
||||
TestKit
|
||||
begin
|
||||
|
||||
doc_class title =
|
||||
short_title :: "string option" <= "None"
|
||||
|
||||
doc_class Author =
|
||||
email :: "string" <= "''''"
|
||||
|
||||
datatype classification = SIL0 | SIL1 | SIL2 | SIL3 | SIL4
|
||||
|
||||
doc_class abstract =
|
||||
keywordlist :: "string list" <= "[]"
|
||||
safety_level :: "classification" <= "SIL3"
|
||||
|
||||
doc_class text_section =
|
||||
authored_by :: "Author set" <= "{}"
|
||||
level :: "int option" <= "None"
|
||||
|
||||
doc_class ('a::one, 'b, 'c) test0 = text_section +
|
||||
testa :: "'a list"
|
||||
testb :: "'b list"
|
||||
testc :: "'c list"
|
||||
|
||||
typ\<open>('a, 'b, 'c) test0\<close>
|
||||
typ\<open>('a, 'b, 'c, 'd) test0_scheme\<close>
|
||||
|
||||
find_consts name:"test0"
|
||||
find_theorems name:"test0"
|
||||
|
||||
|
||||
doc_class 'a test1 = text_section +
|
||||
test1 :: "'a list"
|
||||
invariant author_finite_test :: "finite (authored_by \<sigma>)"
|
||||
invariant force_level_test :: "(level \<sigma>) \<noteq> None \<and> the (level \<sigma>) > 1"
|
||||
|
||||
find_consts name:"test1*inv"
|
||||
find_theorems name:"test1*inv"
|
||||
|
||||
text*[church::Author, email="\<open>b\<close>"]\<open>\<close>
|
||||
text\<open>@{Author "church"}\<close>
|
||||
value*\<open>@{Author \<open>church\<close>}\<close>
|
||||
|
||||
text\<open>\<^value_>\<open>@{Author \<open>church\<close>}\<close>\<close>
|
||||
|
||||
doc_class ('a, 'b) test2 = "'a test1" +
|
||||
test2 :: "'b list"
|
||||
type_synonym ('a, 'b) test2_syn = "('a, 'b) test2"
|
||||
|
||||
find_theorems name:"test2"
|
||||
|
||||
declare [[invariants_checking_with_tactics]]
|
||||
text*[testtest::"('a, int) test2", level = "Some 2", authored_by = "{@{Author \<open>church\<close>}}", test2 = "[1]"]\<open>\<close>
|
||||
value*\<open>test2 @{test2 \<open>testtest\<close>}\<close>
|
||||
|
||||
text*[testtest2''::"(nat, int) test2", test1 = "[2::nat, 3]", test2 = "[4::int, 5]", level = "Some (2::int)"]\<open>\<close>
|
||||
value*\<open>test1 @{test2 \<open>testtest2''\<close>}\<close>
|
||||
declare [[invariants_checking_with_tactics = false]]
|
||||
|
||||
ML\<open>
|
||||
val t = Syntax.parse_term \<^context> "@{test2 \<open>testtest\<close>}"
|
||||
|
||||
\<close>
|
||||
ML\<open>
|
||||
val t = \<^term>\<open>test2.make 8142730 Test_Parametric_Classes_2_test2_authored_by_Attribute_Not_Initialized Test_Parametric_Classes_2_test2_level_Attribute_Not_Initialized Test_Parametric_Classes_2_test2_test1_Attribute_Not_Initialized
|
||||
Test_Parametric_Classes_2_test2_test2_Attribute_Not_Initialized
|
||||
\<lparr>authored_by := bot, level := None\<rparr> \<close>
|
||||
\<close>
|
||||
|
||||
text\<open>test2 = "[1::'a::one]" should be test2 = "[1::int]" because the type of testtest4 is ('a::one, int) test2:\<close>
|
||||
text-assert-error[testtest4::"('a::one, int) test2", level = "Some 2", authored_by = "{@{Author \<open>church\<close>}}", test2 = "[1::'a::one]"]\<open>\<close>
|
||||
\<open>Type unification failed\<close>
|
||||
text\<open>Indeed this definition fails:\<close>
|
||||
definition-assert-error testtest2::"('a::one, int) test2" where "testtest2 \<equiv>
|
||||
test2.make 11953346
|
||||
{@{Author \<open>church\<close>}}
|
||||
(Some 2)
|
||||
[]
|
||||
[]
|
||||
\<lparr>authored_by := bot
|
||||
, level := None, level := Some 2
|
||||
, authored_by := insert \<lparr>Author.tag_attribute = 11953164, email = []\<rparr> bot
|
||||
, test2.test2 := [1::('a::one)]\<rparr> "
|
||||
\<open>Type unification failed\<close>
|
||||
|
||||
text\<open>For now, no more support of type synonyms as parent:\<close>
|
||||
doc_class ('a, 'b, 'c) A =
|
||||
a :: "'a list"
|
||||
b :: "'b list"
|
||||
c :: "'c list"
|
||||
type_synonym ('a, 'b, 'c) A_syn = "('a, 'b, 'c) A"
|
||||
|
||||
doc_class-assert-error ('a, 'b, 'c, 'd) B = "('b, 'c, 'd) A_syn" +
|
||||
d ::"'a::one list" <= "[1]"
|
||||
\<open>Undefined onto class: "A_syn"\<close>
|
||||
|
||||
|
||||
declare[[invariants_checking_with_tactics]]
|
||||
|
||||
definition* testauthor0 where "testauthor0 \<equiv> \<lparr>Author.tag_attribute = 5, email = \<open>test_author_email\<close>\<rparr>"
|
||||
definition* testauthor :: "Author" where "testauthor \<equiv> \<lparr>Author.tag_attribute = 5, email = \<open>test_author_email\<close>\<rparr>"
|
||||
definition* testauthor2 :: "Author" where "testauthor2 \<equiv> \<lparr>Author.tag_attribute = 5, email = \<open>test_author_email\<close>\<rparr> \<lparr>email := \<open>test_author_email_2\<close> \<rparr>"
|
||||
definition* testauthor3 :: "Author" where "testauthor3 \<equiv> testauthor \<lparr>email := \<open>test_author_email_2\<close> \<rparr>"
|
||||
|
||||
ML\<open>
|
||||
val ctxt = \<^context>
|
||||
val input0 = Syntax.read_input "@{Author \<open>church\<close>}"
|
||||
val source = Syntax.read_input "\<^term_>\<open>@{Author \<open>church\<close>}\<close>"
|
||||
val input = source
|
||||
val tt = Document_Output.output_document ctxt {markdown = false} input
|
||||
\<close>
|
||||
|
||||
doc_class ('a, 'b) elaborate1 =
|
||||
a :: "'a list"
|
||||
b :: "'b list"
|
||||
|
||||
doc_class ('a, 'b) elaborate2 =
|
||||
c :: "('a, 'b) elaborate1 list"
|
||||
|
||||
doc_class ('a, 'b) elaborate3 =
|
||||
d :: "('a, 'b) elaborate2 list"
|
||||
|
||||
text*[test_elaborate1::"('a::one, 'b) elaborate1", a = "[1]"]\<open>\<close>
|
||||
|
||||
term*\<open>@{elaborate1 \<open>test_elaborate1\<close>}\<close>
|
||||
value* [nbe]\<open>@{elaborate1 \<open>test_elaborate1\<close>}\<close>
|
||||
|
||||
|
||||
text*[test_elaborate2::"('a::one, 'b) elaborate2", c = "[@{elaborate1 \<open>test_elaborate1\<close>}]"]\<open>\<close>
|
||||
|
||||
text*[test_elaborate3::"('a::one, 'b) elaborate3", d = "[@{elaborate2 \<open>test_elaborate2\<close>}]"]\<open>\<close>
|
||||
|
||||
term*\<open>(concat o concat) ((map o map) a (map c (elaborate3.d @{elaborate3 \<open>test_elaborate3\<close>})))\<close>
|
||||
value*\<open>(concat o concat) ((map o map) a (map c (elaborate3.d @{elaborate3 \<open>test_elaborate3\<close>})))\<close>
|
||||
|
||||
|
||||
text\<open>
|
||||
The term antiquotation is considered a ground term.
|
||||
Then its type here is \<^typ>\<open>'a::one list\<close> whith \<open>'a\<close> a fixed-type variable.
|
||||
So the following definition only works because the parameter of the class is also \<open>'a\<close>.\<close>
|
||||
declare[[ML_print_depth = 10000]]
|
||||
doc_class 'a elaborate4 =
|
||||
d :: "'a::one list" <= "(concat o concat) ((map o map) a (map c (elaborate3.d @{elaborate3 \<open>test_elaborate3\<close>})))"
|
||||
declare[[ML_print_depth = 20]]
|
||||
|
||||
declare[[ML_print_depth = 10000]]
|
||||
text*[test_elaborate4::"'a::one elaborate4"]\<open>\<close>
|
||||
declare[[ML_print_depth = 20]]
|
||||
|
||||
|
||||
text\<open>Bug:
|
||||
As the term antiquotation is considered as a ground term,
|
||||
its type \<^typ>\<open>'a::one list\<close> conflicts with the type of the attribute \<^typ>\<open>int list\<close>.
|
||||
To support the instantiataion of the term antiquatation as an \<^typ>\<open>int list\<close>,
|
||||
the term antiquatation should have the same behavior as a constant definition,
|
||||
which is not the case for now.\<close>
|
||||
declare[[ML_print_depth = 10000]]
|
||||
doc_class-assert-error elaborate4' =
|
||||
d :: "int list" <= "(concat o concat) ((map o map) a (map c (elaborate3.d @{elaborate3 \<open>test_elaborate3\<close>})))"
|
||||
\<open>Type unification failed\<close>
|
||||
declare[[ML_print_depth = 20]]
|
||||
|
||||
text\<open>The behavior we want to support: \<close>
|
||||
|
||||
definition one_list :: "'a::one list" where "one_list \<equiv> [1]"
|
||||
|
||||
text\<open>the constant \<^const>\<open>one_list\<close> can be instantiate as an \<^typ>\<open>int list\<close>:\<close>
|
||||
doc_class elaborate4'' =
|
||||
d :: "int list" <= "one_list"
|
||||
|
||||
declare[[ML_print_depth = 10000]]
|
||||
text*[test_elaborate4''::"elaborate4''"]\<open>\<close>
|
||||
declare[[ML_print_depth = 20]]
|
||||
|
||||
|
||||
term*\<open>concat (map a (elaborate2.c @{elaborate2 \<open>test_elaborate2\<close>}))\<close>
|
||||
value*\<open>concat (map a (elaborate2.c @{elaborate2 \<open>test_elaborate2\<close>}))\<close>
|
||||
|
||||
text\<open>
|
||||
The term antiquotation is considered a ground term.
|
||||
Then its type here is \<^typ>\<open>'a::one list\<close> whith \<open>'a\<close> a fixed-type variable.
|
||||
So the following definition only works because the parameter of the class is also \<open>'a\<close>.\<close>
|
||||
declare[[ML_print_depth = 10000]]
|
||||
doc_class 'a elaborate5 =
|
||||
d :: "'a::one list" <= "concat (map a (elaborate2.c @{elaborate2 \<open>test_elaborate2\<close>}))"
|
||||
declare[[ML_print_depth = 20]]
|
||||
|
||||
text\<open>Bug: But when defining an instance, as we use a \<open>'b\<close> variable to specify the type
|
||||
of the instance (\<^typ>\<open>'b::one elaborate5\<close>, then the unification fails\<close>
|
||||
declare[[ML_print_depth = 10000]]
|
||||
text-assert-error[test_elaborate5::"'b::one elaborate5"]\<open>\<close>
|
||||
\<open>Inconsistent sort constraints for type variable "'b"\<close>
|
||||
declare[[ML_print_depth = 20]]
|
||||
|
||||
text\<open>Bug:
|
||||
The term antiquotation is considered a ground term.
|
||||
Then its type here is \<^typ>\<open>'a::one list\<close> whith \<open>'a\<close> a fixed-type variable.
|
||||
So it is not compatible with the type of the attribute \<^typ>\<open>'a::numeral list\<close>\<close>
|
||||
doc_class-assert-error 'a elaborate5' =
|
||||
d :: "'a::numeral list" <= "concat (map a (elaborate2.c @{elaborate2 \<open>test_elaborate2\<close>}))"
|
||||
\<open>Sort constraint\<close>
|
||||
|
||||
text\<open>The behavior we want to support: \<close>
|
||||
|
||||
text\<open>the constant \<^const>\<open>one_list\<close> can be instantiate as an \<^typ>\<open>'a::numeral list\<close>:\<close>
|
||||
doc_class 'a elaborate5'' =
|
||||
d :: "'a::numeral list" <= "one_list"
|
||||
|
||||
|
||||
text*[test_elaborate1a::"('a::one, int) elaborate1", a = "[1]", b = "[2]"]\<open>\<close>
|
||||
|
||||
term*\<open>@{elaborate1 \<open>test_elaborate1a\<close>}\<close>
|
||||
value* [nbe]\<open>@{elaborate1 \<open>test_elaborate1a\<close>}\<close>
|
||||
|
||||
text*[test_elaborate2a::"('a::one, int) elaborate2", c = "[@{elaborate1 \<open>test_elaborate1a\<close>}]"]\<open>\<close>
|
||||
|
||||
text*[test_elaborate3a::"('a::one, int) elaborate3", d = "[@{elaborate2 \<open>test_elaborate2a\<close>}]"]\<open>\<close>
|
||||
|
||||
text\<open>
|
||||
The term antiquotation is considered a ground term.
|
||||
Then its type here is \<^typ>\<open>'a::one list\<close> whith \<open>'a\<close> a fixed-type variable.
|
||||
So the following definition only works because the parameter of the class is also \<open>'a\<close>.\<close>
|
||||
definition* test_elaborate3_embedding ::"'a::one list"
|
||||
where "test_elaborate3_embedding \<equiv> (concat o concat) ((map o map) elaborate1.a (map elaborate2.c (elaborate3.d @{elaborate3 \<open>test_elaborate3a\<close>})))"
|
||||
|
||||
text\<open>Bug:
|
||||
The term antiquotation is considered a ground term.
|
||||
Then its type here is \<^typ>\<open>'a::one list\<close> whith \<open>'a\<close> a fixed-type variable.
|
||||
So it is not compatible with the specified type of the definition \<^typ>\<open>int list\<close>:\<close>
|
||||
definition-assert-error test_elaborate3_embedding'::"int list"
|
||||
where "test_elaborate3_embedding' \<equiv> (concat o concat) ((map o map) elaborate1.a (map elaborate2.c (elaborate3.d @{elaborate3 \<open>test_elaborate3a\<close>})))"
|
||||
\<open>Type unification failed\<close>
|
||||
|
||||
term*\<open>@{elaborate1 \<open>test_elaborate1a\<close>}\<close>
|
||||
value* [nbe]\<open>@{elaborate1 \<open>test_elaborate1a\<close>}\<close>
|
||||
|
||||
|
||||
record ('a, 'b) elaborate1' =
|
||||
a :: "'a list"
|
||||
b :: "'b list"
|
||||
|
||||
record ('a, 'b) elaborate2' =
|
||||
c :: "('a, 'b) elaborate1' list"
|
||||
|
||||
record ('a, 'b) elaborate3' =
|
||||
d :: "('a, 'b) elaborate2' list"
|
||||
|
||||
doc_class 'a one =
|
||||
a::"'a list"
|
||||
|
||||
text*[test_one::"'a::one one", a = "[1]"]\<open>\<close>
|
||||
|
||||
value* [nbe] \<open>@{one \<open>test_one\<close>}\<close>
|
||||
|
||||
term*\<open>a @{one \<open>test_one\<close>}\<close>
|
||||
|
||||
text\<open>Bug:
|
||||
The term antiquotation is considered a ground term.
|
||||
Then its type here is \<^typ>\<open>'a::one list\<close> whith \<open>'a\<close> a fixed-type variable.
|
||||
So it is not compatible with the specified type of the definition \<^typ>\<open>('b::one, 'a::numeral) elaborate1'\<close>
|
||||
because the term antiquotation can not be instantiate as a \<^typ>\<open>'b::one list\<close>
|
||||
and the \<open>'a\<close> is checked against the \<open>'a::numeral\<close> instance type parameter:\<close>
|
||||
definition-assert-error test_elaborate1'::"('b::one, 'a::numeral) elaborate1'"
|
||||
where "test_elaborate1' \<equiv> \<lparr> elaborate1'.a = a @{one \<open>test_one\<close>}, b = [2] \<rparr>"
|
||||
\<open>Sort constraint\<close>
|
||||
|
||||
text\<open>This is the same behavior as the following:\<close>
|
||||
definition-assert-error test_elaborate10::"('b::one, 'a::numeral) elaborate1'"
|
||||
where "test_elaborate10 \<equiv> \<lparr> elaborate1'.a = [1::'a::one], b = [2] \<rparr>"
|
||||
\<open>Sort constraint\<close>
|
||||
|
||||
definition-assert-error test_elaborate11::"('b::one, 'c::numeral) elaborate1'"
|
||||
where "test_elaborate11 \<equiv> \<lparr> elaborate1'.a = [1::'a::one], b = [2] \<rparr>"
|
||||
\<open>Type unification failed\<close>
|
||||
|
||||
text\<open>So this works:\<close>
|
||||
definition* test_elaborate1''::"('a::one, 'b::numeral) elaborate1'"
|
||||
where "test_elaborate1'' \<equiv> \<lparr> elaborate1'.a = a @{one \<open>test_one\<close>}, b = [2] \<rparr>"
|
||||
|
||||
term \<open>elaborate1'.a test_elaborate1''\<close>
|
||||
value [nbe] \<open>elaborate1'.a test_elaborate1''\<close>
|
||||
|
||||
text\<open>But if we embed the term antiquotation in a definition,
|
||||
the type unification works:\<close>
|
||||
definition* onedef where "onedef \<equiv> @{one \<open>test_one\<close>}"
|
||||
|
||||
definition test_elaborate1'''::"('b::one, 'a::numeral) elaborate1'"
|
||||
where "test_elaborate1''' \<equiv> \<lparr> elaborate1'.a = a onedef, b = [2] \<rparr>"
|
||||
|
||||
value [nbe] \<open>elaborate1'.a test_elaborate1'''\<close>
|
||||
|
||||
|
||||
definition test_elaborate2'::"(int, 'b::numeral) elaborate2'"
|
||||
where "test_elaborate2' \<equiv> \<lparr> c = [test_elaborate1''] \<rparr>"
|
||||
|
||||
definition test_elaborate3'::"(int, 'b::numeral) elaborate3'"
|
||||
where "test_elaborate3' \<equiv> \<lparr> d = [test_elaborate2'] \<rparr>"
|
||||
|
||||
|
||||
doc_class 'a test3' =
|
||||
test3 :: "int"
|
||||
test3' :: "'a list"
|
||||
|
||||
text*[testtest30::"'a::one test3'", test3'="[1]"]\<open>\<close>
|
||||
text-assert-error[testtest30::"'a test3'", test3'="[1]"]\<open>\<close>
|
||||
\<open>Type unification failed: Variable\<close>
|
||||
|
||||
find_consts name:"test3'.test3"
|
||||
definition testone :: "'a::one test3'" where "testone \<equiv> \<lparr>tag_attribute = 5, test3 = 3, test3' = [1] \<rparr>"
|
||||
definition* testtwo :: "'a::one test3'" where "testtwo \<equiv> \<lparr>tag_attribute = 5, test3 = 1, test3' = [1] \<rparr>\<lparr> test3 := 1\<rparr>"
|
||||
|
||||
text*[testtest3'::"'a test3'", test3 = "1"]\<open>\<close>
|
||||
|
||||
declare [[show_sorts = false]]
|
||||
definition* testtest30 :: "'a test3'" where "testtest30 \<equiv> \<lparr>tag_attribute = 12, test3 = 2, test3' = [] \<rparr>"
|
||||
update_instance*[testtest3'::"'a test3'", test3 := "2"]
|
||||
|
||||
ML\<open>
|
||||
val t = @{value_ [nbe] \<open>test3 @{test3' \<open>testtest3'\<close>}\<close>}
|
||||
val tt = HOLogic.dest_number t
|
||||
\<close>
|
||||
|
||||
text\<open>@{value_ [] [nbe] \<open>test3 @{test3' \<open>testtest3'\<close>}\<close>}\<close>
|
||||
|
||||
update_instance*[testtest3'::"'a test3'", test3 += "2"]
|
||||
|
||||
ML\<open>
|
||||
val t = @{value_ [nbe] \<open>test3 @{test3' \<open>testtest3'\<close>}\<close>}
|
||||
val tt = HOLogic.dest_number t
|
||||
\<close>
|
||||
|
||||
value\<open>test3 \<lparr> tag_attribute = 1, test3 = 2, test3' = [2::int, 3] \<rparr>\<close>
|
||||
value\<open>test3 \<lparr> tag_attribute = 1, test3 = 2, test3' = [2::int, 3] \<rparr>\<close>
|
||||
find_consts name:"test3'.test3"
|
||||
|
||||
ML\<open>
|
||||
val test_value = @{value_ \<open>@{test3' \<open>testtest3'\<close>}\<close>}
|
||||
|
||||
\<close>
|
||||
declare [[show_sorts = false]]
|
||||
update_instance*[testtest3'::"'a test3'", test3 += "3"]
|
||||
declare [[show_sorts = false]]
|
||||
value*\<open>test3 @{test3' \<open>testtest3'\<close>}\<close>
|
||||
value\<open>test3 \<lparr> tag_attribute = 12, test3 = 5, test3' = AAAAAA\<rparr>\<close>
|
||||
|
||||
find_consts name:"test3'.test3"
|
||||
|
||||
text*[testtest3''::"int test3'", test3 = "1"]\<open>\<close>
|
||||
|
||||
update_instance*[testtest3''::"int test3'", test3' += "[3]"]
|
||||
|
||||
value*\<open>test3' @{test3' \<open>testtest3''\<close>}\<close>
|
||||
|
||||
update_instance*[testtest3''::"int test3'", test3' := "[3]"]
|
||||
|
||||
value*\<open>test3' @{test3' \<open>testtest3''\<close>}\<close>
|
||||
|
||||
update_instance*[testtest3''::"int test3'", test3' += "[2,5]"]
|
||||
|
||||
value*\<open>test3' @{test3' \<open>testtest3''\<close>}\<close>
|
||||
|
||||
definition testeq where "testeq \<equiv> \<lambda>x. x"
|
||||
find_consts name:"test3'.ma"
|
||||
|
||||
text-assert-error[testtest3''::"int test3'", test3 = "1", test3' = "[3::'a::numeral]"]\<open>\<close>
|
||||
\<open>Type unification failed\<close>
|
||||
|
||||
text-assert-error[testtest3''::"int test3'", test3 = "1", test3' = "[3]"]\<open>\<close>
|
||||
\<open>Duplicate instance declaration\<close>
|
||||
|
||||
|
||||
declare[[ML_print_depth = 10000]]
|
||||
definition-assert-error testest3''' :: "int test3'"
|
||||
where "testest3''' \<equiv> \<lparr> tag_attribute = 12, test3 = 1, test3' = [2]\<rparr>\<lparr> test3' := [3::'a::numeral]\<rparr>"
|
||||
\<open>Type unification failed\<close>
|
||||
declare[[ML_print_depth = 20]]
|
||||
|
||||
value* \<open>test3 @{test3' \<open>testtest3''\<close>}\<close>
|
||||
value* \<open>\<lparr> tag_attribute = 12, test3 = 1, test3' = [2]\<rparr>\<lparr> test3' := [3::int]\<rparr>\<close>
|
||||
value* \<open>test3 (\<lparr> tag_attribute = 12, test3 = 1, test3' = [2]\<rparr>\<lparr> test3' := [3::int]\<rparr>)\<close>
|
||||
term*\<open>@{test3' \<open>testtest3''\<close>}\<close>
|
||||
|
||||
ML\<open>val t = \<^term_>\<open>test3 @{test3' \<open>testtest3''\<close>}\<close>\<close>
|
||||
|
||||
value\<open>test3 \<lparr> tag_attribute = 12, test3 = 2, test3' = [2::int ,3]\<rparr>\<close>
|
||||
|
||||
find_consts name:"test3'.test3"
|
||||
find_consts name:"Isabelle_DOF_doc_class_test3'"
|
||||
update_instance*[testtest3''::"int test3'", test3 := "2"]
|
||||
ML\<open>
|
||||
val t = @{value_ [nbe] \<open>test3 @{test3' \<open>testtest3''\<close>}\<close>}
|
||||
val tt = HOLogic.dest_number t |> snd
|
||||
\<close>
|
||||
|
||||
doc_class 'a testa =
|
||||
a:: "'a set"
|
||||
b:: "int set"
|
||||
|
||||
text*[testtesta::"'a testa", b = "{2}"]\<open>\<close>
|
||||
update_instance*[testtesta::"'a testa", b += "{3}"]
|
||||
|
||||
ML\<open>
|
||||
val t = @{value_ [nbe] \<open>b @{testa \<open>testtesta\<close>}\<close>}
|
||||
val tt = HOLogic.dest_set t |> map (HOLogic.dest_number #> snd)
|
||||
\<close>
|
||||
|
||||
update_instance-assert-error[testtesta::"'a::numeral testa", a := "{2::'a::numeral}"]
|
||||
\<open>incompatible classes:'a Test_Polymorphic_Classes.testa:'a::numeral Test_Polymorphic_Classes.testa\<close>
|
||||
|
||||
text*[testtesta'::"'a::numeral testa", a = "{2}"]\<open>\<close>
|
||||
|
||||
update_instance*[testtesta'::"'a::numeral testa", a += "{3}"]
|
||||
|
||||
ML\<open>
|
||||
val t = @{value_ [nbe] \<open>a @{testa \<open>testtesta'\<close>}\<close>}
|
||||
\<close>
|
||||
|
||||
update_instance-assert-error[testtesta'::"'a::numeral testa", a += "{3::int}"]
|
||||
\<open>Type unification failed\<close>
|
||||
|
||||
definition-assert-error testtesta'' :: "'a::numeral testa"
|
||||
where "testtesta'' \<equiv> \<lparr>tag_attribute = 5, a = {1}, b = {1} \<rparr>\<lparr> a := {1::int}\<rparr>"
|
||||
\<open>Type unification failed\<close>
|
||||
|
||||
update_instance*[testtesta'::"'a::numeral testa", b := "{3::int}"]
|
||||
ML\<open>
|
||||
val t = @{value_ [nbe] \<open>b @{testa \<open>testtesta'\<close>}\<close>}
|
||||
\<close>
|
||||
|
||||
value* [nbe] \<open>b @{testa \<open>testtesta'\<close>}\<close>
|
||||
|
||||
definition testtesta'' :: "'a::numeral testa"
|
||||
where "testtesta'' \<equiv> \<lparr>tag_attribute = 5, a = {1}, b = {1} \<rparr>\<lparr> b := {2::int}\<rparr>"
|
||||
|
||||
value [nbe]\<open>b testtesta''\<close>
|
||||
|
||||
doc_class 'a test3 =
|
||||
test3 :: "'a list"
|
||||
type_synonym 'a test3_syn = "'a test3"
|
||||
|
||||
text*[testtest3::"int test3", test3 = "[1]"]\<open>\<close>
|
||||
update_instance*[testtest3::"int test3", test3 := "[2]"]
|
||||
ML\<open>
|
||||
val t = \<^term_>\<open>test3 @{test3 \<open>testtest3\<close>}\<close>
|
||||
val tt = \<^value_>\<open>test3 @{test3 \<open>testtest3\<close>}\<close> |> HOLogic.dest_list |> map HOLogic.dest_number
|
||||
\<close>
|
||||
|
||||
update_instance*[testtest3::"int test3", test3 += "[3]"]
|
||||
value*\<open>test3 @{test3 \<open>testtest3\<close>}\<close>
|
||||
|
||||
|
||||
doc_class ('a, 'b) test4 = "'a test3" +
|
||||
test4 :: "'b list"
|
||||
|
||||
definition-assert-error testtest0'::"('a::one, int) test4" where "testtest0' \<equiv>
|
||||
test4.make 11953346
|
||||
[] [1::('a::one)]"
|
||||
\<open>Type unification failed\<close>
|
||||
|
||||
definition-assert-error testtest0''::"('a, int) test4" where "testtest0'' \<equiv>
|
||||
test4.make 11953346
|
||||
[1] Test_Parametric_Classes_2_test4_test4_Attribute_Not_Initialized"
|
||||
\<open>Type unification failed\<close>
|
||||
|
||||
text\<open>Must fail because the equivalent definition
|
||||
\<open>testtest0'\<close> below fails
|
||||
due to the constraint in the where [1::('a::one)] is not an \<^typ>\<open>int list\<close>
|
||||
but an \<^typ>\<open>'a::one list\<close> list \<close>
|
||||
text-assert-error[testtest0::"('a::one, int) test4", test4 = "[1::'a::one]"]\<open>\<close>
|
||||
\<open>Type unification failed\<close>
|
||||
update_instance-assert-error[testtest0::"('a::one, int) test4"]
|
||||
\<open>Undefined instance: "testtest0"\<close>
|
||||
|
||||
value-assert-error\<open>@{test4 \<open>testtest0\<close>}\<close>\<open>Undefined instance: "testtest0"\<close>
|
||||
|
||||
definition testtest0''::"('a, int) test4" where "testtest0'' \<equiv>
|
||||
\<lparr> tag_attribute = 11953346, test3 = [], test4 = [1]\<rparr>\<lparr>test4 := [2]\<rparr>"
|
||||
|
||||
definition testtest0'''::"('a, int) test4" where "testtest0''' \<equiv>
|
||||
\<lparr> tag_attribute = 11953346, test3 = [], test4 = [1]\<rparr>\<lparr>test4 := [2]\<rparr>"
|
||||
|
||||
|
||||
value [nbe] \<open>test3 testtest0''\<close>
|
||||
|
||||
type_synonym notion = string
|
||||
|
||||
doc_class Introduction = text_section +
|
||||
authored_by :: "Author set" <= "UNIV"
|
||||
uses :: "notion set"
|
||||
invariant author_finite :: "finite (authored_by \<sigma>)"
|
||||
and force_level :: "(level \<sigma>) \<noteq> None \<and> the (level \<sigma>) > 1"
|
||||
|
||||
doc_class claim = Introduction +
|
||||
based_on :: "notion list"
|
||||
|
||||
doc_class technical = text_section +
|
||||
formal_results :: "thm list"
|
||||
|
||||
doc_class "definition" = technical +
|
||||
is_formal :: "bool"
|
||||
property :: "term list" <= "[]"
|
||||
|
||||
datatype kind = expert_opinion | argument | "proof"
|
||||
|
||||
doc_class result = technical +
|
||||
evidence :: kind
|
||||
property :: "thm list" <= "[]"
|
||||
invariant has_property :: "evidence \<sigma> = proof \<longleftrightarrow> property \<sigma> \<noteq> []"
|
||||
|
||||
doc_class example = technical +
|
||||
referring_to :: "(notion + definition) set" <= "{}"
|
||||
|
||||
doc_class conclusion = text_section +
|
||||
establish :: "(claim \<times> result) set"
|
||||
invariant establish_defined :: "\<forall> x. x \<in> Domain (establish \<sigma>)
|
||||
\<longrightarrow> (\<exists> y \<in> Range (establish \<sigma>). (x, y) \<in> establish \<sigma>)"
|
||||
|
||||
text\<open>Next we define some instances (docitems): \<close>
|
||||
|
||||
declare[[invariants_checking_with_tactics = true]]
|
||||
|
||||
text*[church1::Author, email="\<open>church@lambda.org\<close>"]\<open>\<close>
|
||||
|
||||
text*[resultProof::result, evidence = "proof", property="[@{thm \<open>HOL.refl\<close>}]"]\<open>\<close>
|
||||
text*[resultArgument::result, evidence = "argument"]\<open>\<close>
|
||||
|
||||
text\<open>The invariants \<^theory_text>\<open>author_finite\<close> and \<^theory_text>\<open>establish_defined\<close> can not be checked directly
|
||||
and need a little help.
|
||||
We can set the \<open>invariants_checking_with_tactics\<close> theory attribute to help the checking.
|
||||
It will enable a basic tactic, using unfold and auto:\<close>
|
||||
|
||||
declare[[invariants_checking_with_tactics = true]]
|
||||
|
||||
text*[curry::Author, email="\<open>curry@lambda.org\<close>"]\<open>\<close>
|
||||
text*[introduction2::Introduction, authored_by = "{@{Author \<open>church\<close>}}", level = "Some 2"]\<open>\<close>
|
||||
(* When not commented, should violated the invariant:
|
||||
update_instance*[introduction2::Introduction
|
||||
, authored_by := "{@{Author \<open>church\<close>}}"
|
||||
, level := "Some 1"]
|
||||
*)
|
||||
|
||||
text*[introduction_test_parsed_elaborate::Introduction, authored_by = "authored_by @{Introduction \<open>introduction2\<close>}", level = "Some 2"]\<open>\<close>
|
||||
term*\<open>authored_by @{Introduction \<open>introduction_test_parsed_elaborate\<close>}\<close>
|
||||
value*\<open>authored_by @{Introduction \<open>introduction_test_parsed_elaborate\<close>}\<close>
|
||||
text*[introduction3::Introduction, authored_by = "{@{Author \<open>church\<close>}}", level = "Some 2"]\<open>\<close>
|
||||
text*[introduction4::Introduction, authored_by = "{@{Author \<open>curry\<close>}}", level = "Some 4"]\<open>\<close>
|
||||
|
||||
text*[resultProof2::result, evidence = "proof", property="[@{thm \<open>HOL.sym\<close>}]"]\<open>\<close>
|
||||
|
||||
text\<open>Then we can evaluate expressions with instances:\<close>
|
||||
|
||||
term*\<open>authored_by @{Introduction \<open>introduction2\<close>} = authored_by @{Introduction \<open>introduction3\<close>}\<close>
|
||||
value*\<open>authored_by @{Introduction \<open>introduction2\<close>} = authored_by @{Introduction \<open>introduction3\<close>}\<close>
|
||||
value*\<open>authored_by @{Introduction \<open>introduction2\<close>} = authored_by @{Introduction \<open>introduction4\<close>}\<close>
|
||||
|
||||
value*\<open>@{Introduction \<open>introduction2\<close>}\<close>
|
||||
|
||||
value*\<open>{@{Author \<open>curry\<close>}} = {@{Author \<open>church\<close>}}\<close>
|
||||
|
||||
term*\<open>property @{result \<open>resultProof\<close>} = property @{result \<open>resultProof2\<close>}\<close>
|
||||
value*\<open>property @{result \<open>resultProof\<close>} = property @{result \<open>resultProof2\<close>}\<close>
|
||||
|
||||
value*\<open>evidence @{result \<open>resultProof\<close>} = evidence @{result \<open>resultProof2\<close>}\<close>
|
||||
|
||||
declare[[invariants_checking_with_tactics = false]]
|
||||
|
||||
declare[[invariants_strict_checking = false]]
|
||||
|
||||
doc_class test_A =
|
||||
level :: "int option"
|
||||
x :: int
|
||||
|
||||
doc_class test_B =
|
||||
level :: "int option"
|
||||
x :: "string" (* attributes live in their own name-space *)
|
||||
y :: "string list" <= "[]" (* and can have arbitrary type constructors *)
|
||||
(* LaTeX may have problems with this, though *)
|
||||
|
||||
text\<open>We may even use type-synonyms for class synonyms ...\<close>
|
||||
type_synonym test_XX = test_B
|
||||
|
||||
doc_class test_C0 = test_B +
|
||||
z :: "test_A option" <= None (* A LINK, i.e. an attribute that has a type
|
||||
referring to a document class. Mathematical
|
||||
relations over document items can be modeled. *)
|
||||
g :: "thm" (* a reference to the proxy-type 'thm' allowing
|
||||
|
||||
to denote references to theorems inside attributes *)
|
||||
|
||||
|
||||
doc_class test_C = test_B +
|
||||
z :: "test_A option" <= None (* A LINK, i.e. an attribute that has a type
|
||||
referring to a document class. Mathematical
|
||||
relations over document items can be modeled. *)
|
||||
g :: "thm" (* a reference to the proxy-type 'thm' allowing
|
||||
|
||||
to denote references to theorems inside attributes *)
|
||||
|
||||
datatype enum = X1 | X2 | X3 (* we add an enumeration type ... *)
|
||||
|
||||
|
||||
doc_class test_D = test_B +
|
||||
x :: "string" <= "\<open>def \<longrightarrow>\<close>" (* overriding default *)
|
||||
a1 :: enum <= "X2" (* class - definitions may be mixed
|
||||
with arbitrary HOL-commands, thus
|
||||
also local definitions of enumerations *)
|
||||
a2 :: int <= 0
|
||||
|
||||
doc_class test_E = test_D +
|
||||
x :: "string" <= "''qed''" (* overriding default *)
|
||||
|
||||
doc_class test_G = test_C +
|
||||
g :: "thm" <= "@{thm \<open>HOL.refl\<close>}" (* warning overriding attribute expected*)
|
||||
|
||||
doc_class 'a test_F =
|
||||
properties :: "term list"
|
||||
r :: "thm list"
|
||||
u :: "file"
|
||||
s :: "typ list"
|
||||
b :: "(test_A \<times> 'a test_C_scheme) set" <= "{}" (* This is a relation link, roughly corresponding
|
||||
to an association class. It can be used to track
|
||||
claims to result - relations, for example.*)
|
||||
b' :: "(test_A \<times> 'a test_C_scheme) list" <= "[]"
|
||||
invariant br :: "r \<sigma> \<noteq> [] \<and> card(b \<sigma>) \<ge> 3"
|
||||
and br':: "r \<sigma> \<noteq> [] \<and> length(b' \<sigma>) \<ge> 3"
|
||||
and cr :: "properties \<sigma> \<noteq> []"
|
||||
|
||||
lemma*[l::test_E] local_sample_lemma :
|
||||
"@{thm \<open>refl\<close>} = @{thm ''refl''}" by simp
|
||||
\<comment> \<open>un-evaluated references are similar to
|
||||
uninterpreted constants. Not much is known
|
||||
about them, but that doesn't mean that we
|
||||
can't prove some basics over them...\<close>
|
||||
|
||||
text*[xcv1::test_A, x=5]\<open>Lorem ipsum ...\<close>
|
||||
text*[xcv2::test_C, g="@{thm ''HOL.refl''}"]\<open>Lorem ipsum ...\<close>
|
||||
text*[xcv3::test_A, x=7]\<open>Lorem ipsum ...\<close>
|
||||
|
||||
text\<open>Bug: For now, the implementation is no more compatible with the docitem term-antiquotation:\<close>
|
||||
text-assert-error[xcv10::"unit test_F", r="[@{thm ''HOL.refl''},
|
||||
@{thm \<open>local_sample_lemma\<close>}]", (* long names required *)
|
||||
b="{(@{docitem ''xcv1''},@{docitem \<open>xcv2\<close>})}", (* notations \<open>...\<close> vs. ''...'' *)
|
||||
s="[@{typ \<open>int list\<close>}]",
|
||||
properties = "[@{term \<open>H \<longrightarrow> H\<close>}]" (* notation \<open>...\<close> required for UTF8*)
|
||||
]\<open>Lorem ipsum ...\<close>\<open>Type unification failed\<close>
|
||||
|
||||
text*[xcv11::"unit test_F", r="[@{thm ''HOL.refl''},
|
||||
@{thm \<open>local_sample_lemma\<close>}]", (* long names required *)
|
||||
b="{(@{test_A ''xcv1''},@{test_C \<open>xcv2\<close>})}", (* notations \<open>...\<close> vs. ''...'' *)
|
||||
s="[@{typ \<open>int list\<close>}]",
|
||||
properties = "[@{term \<open>H \<longrightarrow> H\<close>}]" (* notation \<open>...\<close> required for UTF8*)
|
||||
]\<open>Lorem ipsum ...\<close>
|
||||
|
||||
value*\<open>b @{test_F \<open>xcv11\<close>}\<close>
|
||||
|
||||
typ\<open>unit test_F\<close>
|
||||
|
||||
text*[xcv4::"unit test_F", r="[@{thm ''HOL.refl''},
|
||||
@{thm \<open>local_sample_lemma\<close>}]", (* long names required *)
|
||||
b="{(@{test_A ''xcv1''},@{test_C \<open>xcv2\<close>})}", (* notations \<open>...\<close> vs. ''...'' *)
|
||||
s="[@{typ \<open>int list\<close>}]",
|
||||
properties = "[@{term \<open>H \<longrightarrow> H\<close>}]" (* notation \<open>...\<close> required for UTF8*)
|
||||
]\<open>Lorem ipsum ...\<close>
|
||||
|
||||
value*\<open>b @{test_F \<open>xcv4\<close>}\<close>
|
||||
|
||||
text*[xcv5::test_G, g="@{thm \<open>HOL.sym\<close>}"]\<open>Lorem ipsum ...\<close>
|
||||
|
||||
update_instance*[xcv4::"unit test_F", b+="{(@{test_A ''xcv3''},@{test_C ''xcv2''})}"]
|
||||
|
||||
update_instance-assert-error[xcv4::"unit test_F", b+="{(@{test_A ''xcv3''},@{test_G ''xcv5''})}"]
|
||||
\<open>Type unification failed: Clash of types\<close>
|
||||
|
||||
|
||||
|
||||
typ\<open>unit test_G_ext\<close>
|
||||
typ\<open>\<lparr>test_G.tag_attribute :: int\<rparr>\<close>
|
||||
text*[xcv6::"\<lparr>test_G.tag_attribute :: int\<rparr> test_F", b="{(@{test_A ''xcv3''},@{test_G ''xcv5''})}"]\<open>\<close>
|
||||
|
||||
end
|
||||
|
|
@ -165,11 +165,11 @@ text\<open>The intended use for the \<open>doc_class\<close>es \<^verbatim>\<ope
|
|||
\<^verbatim>\<open>math_example\<close> (or \<^verbatim>\<open>math_ex\<close> for short)
|
||||
are \<^emph>\<open>informal\<close> descriptions of semi-formal definitions (by inheritance).
|
||||
Math-Examples can be made referentiable triggering explicit, numbered presentations.\<close>
|
||||
doc_class math_motivation = tc +
|
||||
doc_class math_motivation = technical +
|
||||
referentiable :: bool <= False
|
||||
type_synonym math_mtv = math_motivation
|
||||
|
||||
doc_class math_explanation = tc +
|
||||
doc_class math_explanation = technical +
|
||||
referentiable :: bool <= False
|
||||
type_synonym math_exp = math_explanation
|
||||
|
||||
|
|
@ -207,7 +207,7 @@ datatype math_content_class =
|
|||
text\<open>Instances of the \<open>doc_class\<close> \<^verbatim>\<open>math_content\<close> are by definition @{term "semiformal"}; they may
|
||||
be non-referential, but in this case they will not have a @{term "short_name"}.\<close>
|
||||
|
||||
doc_class math_content = tc +
|
||||
doc_class math_content = technical +
|
||||
referentiable :: bool <= False
|
||||
short_name :: string <= "''''"
|
||||
status :: status <= "semiformal"
|
||||
|
|
@ -516,34 +516,34 @@ subsection\<open>Content in Engineering/Tech Papers \<close>
|
|||
text\<open>This section is currently experimental and not supported by the documentation
|
||||
generation backend.\<close>
|
||||
|
||||
doc_class engineering_content = tc +
|
||||
doc_class engineering_content = technical +
|
||||
short_name :: string <= "''''"
|
||||
status :: status
|
||||
type_synonym eng_content = engineering_content
|
||||
|
||||
|
||||
doc_class "experiment" = eng_content +
|
||||
doc_class "experiment" = engineering_content +
|
||||
tag :: "string" <= "''''"
|
||||
|
||||
doc_class "evaluation" = eng_content +
|
||||
doc_class "evaluation" = engineering_content +
|
||||
tag :: "string" <= "''''"
|
||||
|
||||
doc_class "data" = eng_content +
|
||||
doc_class "data" = engineering_content +
|
||||
tag :: "string" <= "''''"
|
||||
|
||||
doc_class tech_definition = eng_content +
|
||||
doc_class tech_definition = engineering_content +
|
||||
referentiable :: bool <= True
|
||||
tag :: "string" <= "''''"
|
||||
|
||||
doc_class tech_code = eng_content +
|
||||
doc_class tech_code = engineering_content +
|
||||
referentiable :: bool <= True
|
||||
tag :: "string" <= "''''"
|
||||
|
||||
doc_class tech_example = eng_content +
|
||||
doc_class tech_example = engineering_content +
|
||||
referentiable :: bool <= True
|
||||
tag :: "string" <= "''''"
|
||||
|
||||
doc_class eng_example = eng_content +
|
||||
doc_class eng_example = engineering_content +
|
||||
referentiable :: bool <= True
|
||||
tag :: "string" <= "''''"
|
||||
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load Diff
|
|
@ -474,7 +474,7 @@ text\<open>
|
|||
\<^rail>\<open>
|
||||
(@@{command "term*"} ('[' meta_args ']')? '\<open>' HOL_term '\<close>'
|
||||
| (@@{command "value*"}
|
||||
| @@{command "assert*"}) \<newline> ('[' meta_args ']')? ('[' evaluator ']')? '\<open>' HOL_term '\<close>'
|
||||
| @@{command "assert*"}) \<newline> ('[' evaluator ']')? ('[' meta_args ']')? '\<open>' HOL_term '\<close>'
|
||||
| (@@{command "definition*"}) ('[' meta_args ']')?
|
||||
('... see ref manual')
|
||||
| (@@{command "lemma*"} | @@{command "theorem*"} | @@{command "corollary*"}
|
||||
|
|
|
|||
Loading…
Reference in New Issue