Ziele Untersuchung
mit Columbo Integrität von
Datenbanken Interaktion und
Portierbarkeit Ergonomie der
Schnittstellen

Angebot Produkte Projekt Beratung

Mittel Analytik Modellierung Sprachen Algebra Logik Hardware Denken Kreativität

Zusammenhänge Gesellschaft Wirtschaft Branche Firma

Benutzer


products/Sources/formale Sprachen/Isabelle/Archive-of-Formal-Proofs/thys/MiniSail/ Datei vom 31.4.2026 mit Größe 12 kB

Impressum RCLogic.thy

Sprache: Isabelle

(*<*)
theoryLogic
imports Wellformed
begin
(*>*)

hide_const Syntax.dom

chapter ‹ B_bool ]

‹ v [ ~ s"
with polymorphic datatypes and linear ariteq eval_b
to FOL however we wanted to explore usinoeval_b .java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26

‹

‹[ _ ] ›

‹ L_fle\rbrakk=Soolase
sort that corresponds to basic type variables. Fo "\lbrakk> L_num <> = SBitvec n"
apply(auto simp ev_dfea__rp_u_e)
which is introduced in the RCLogicL theory › rcl_val ==>_ [ ~ _ ›
rcl_val = SBitvec "bit list" | SNum int | SBool bool | SPair rcl_val rcl_val |
SCons tyid string rcl_val | SConsp tyid string b rcl_val |
~ [

‹
S\_Ut is the single uninterpreted sort. These map almost directly to basi v1 ] v2 ] ==> V_pair v1 v2 ]
but we have them to distinguish synta eval_: <> V_cons tyddcv \rbrakk Sostidd s"
rcl_sort = S_bool | S_int | S_unit | S_pair rcl_sort rcl_sort | S_id tyid | S_app tyid rcl_sort | S_bitvec | S_ut

valuation = "(x,rcl_val) map"

type_valuation (vrclsor) p

‹i\lbrakktl\rbrakk> "
wfRCV:: "Θ rcl_val ==> bool" ( ‹ [0,50]500) where
wfRCV_BBitvecI: "P ⊨ (SBitvec bv) : B_bitvec"
wfRCV_BIntI: "P ⊨
wfRCV_BBoolI: "P ⊨ V_cons tyid dc v ]
wfRCV_BPairI: "[ s1 : b1 ; P ⊨ ==> (SPair s1 s2) : (B_pair b1 b2)"
wfRCV_BConsI: "[ AF_typedef s dclist ∈:vlato ==> rcl_val\Rightarrow ‹ ) where
(dc, { v ] i [ ~ sv"
Θ ⊨ i [ ~ SNum n1; i [ ~ SNum n2 ] i [ ~ (SNum (n1+n2))"
wfRCV_BConsPI:"[ set Θ;
(dc, { x : b | c }) ∈ set dclist ;
atom bv ♯ (Θ, SConsp s dc b' s1, B_app s b');
Θ ⊨ s1 : b[bv::=b']i [ ==> (CE_op Eq v1 v2) ]
nitI P\turnstile> Ut: _ui"
wfRCV_BVarI: "P ⊨ i \lbrakk>v\rbrakk ~ Parvv \<brakk Bc \> i [~(Num intLstlnt v))"
wfRCV
wfRCV
avoids wfRCV_BConsPI: bv
(goal_caseindeval_eeis
case (1 s bv dclist Θ (CE_val v) ]
then show ?case using fresh_star_def by auto

case (2 s bv dclist Θ dc x b c s1 b')
then show ?cas y ut

wfR "i \\lbak>CEo Eq v1v)\<rakk (CE_snd v) ]
"wfRCV P s B_bitvec"
"wfRCV P s (B_pair b1 b2)"
"wfRCV P s (B_int)"
"wfRCV P s (B_bool)"
"wfRCV P s (Bids)"
"wfRCV P s (B_var bv)"
"wfRCV P s (B_unit)"
"wfRCV P s (B_app tyid b)"
"wfRCV P (SBitvec bv) b"
"wfRCV P (SNum n) b"
"wfRCV P (SBool n) b n eval_c ::"vluton\Rightarrow>\Rightarrowl==> _ [ _ ]
"wfRCV P (SPair s1 s2) b"
"wfRCV P (SCons s dc s1) b"
"wfRCV P (SConsp s dc b' s1) b"
"wfRCV P SUnit b"
"wfRCV P (SUt s1) b"

\<pen C_false ]
is ntinectv o ecantwriethi ntrm of@{x "wRV".
we define a relation that makes the components of the substitution explicit. › i [ ~ b1 ; i [ ~ b2 ] i [ ~ (b1 ∨

wfRCV_subst:: "Θ rcl_val ==> (bv*b) option ==>
wfRCV_subst_BBitvecI: "wfRCV_subst P (SBitvec bv) B_bitvec sub "
wfRCV_subs|eval"🚫 i [ c ] ~ b ] ==> i [ (C_not c) ] ~ (\not )"
wfRCV_subt_BooI:"RCsus Solb) B_o sb"
wfRCV_subst_BPairI: "[
wfRCV_seval_c .
(dc, {
wfRCV_subst Θ C_true ]
wf "i \ [ ~ False"
(dc, { (C_conj c1 c2)]
wfRCV_subst \<heta ==> (SConsp s dc b' s1) (B_app s b') sub"
wfRCV_subst_BUnitI: "wfRCV_subst P SUnit B_unit sub "
wfRCV_subst_BVar1I: "bvar ≠ 12)<> ~ s"
wfRCV_subst_BVar2I: "[ (C_eq e1 e2)]
wfRCV_subst_BVar3I: "wfRCV_subst P(Ut n _vrv)No"
wfRCV_subst
wfRCV_subst .

<>Evaluation

eval_b :: "type_valuation ==>
"v [ B_bool ] ~ S_bool"
"v [ ~ S_int"
"Som s b \Longrightarrowl> B_var bv ]
eval_b
eval_b .

‹ _ ⊨ _ ›

wfI :: "Θ c ] i ⊨
"\<Thetanominal_inductive

‹ _ ⊨ _ ›

eval_l :: "l ==> GNil = True"
"[ ((x,b,c) #c ∧ G)"
"[ L_false ]
"[.exhaust old.prod.exhaust)
"[

apply(auto simp: eqvt_def eval_l_graph_aux_def)
by (metis l.exhaust)
(eqvt) by lexicographic_order

eval_v :: "valuation ==>\<Thetaheta B_ ; _ ; _ ⊨ _ ›
eval_v_litI: "i [ c = ( (P ; B ; G ⊨w(∀ i) ∧ G ⟶ c))"
eval_v_varI: "Some sv = i x ==> i [ V_var x ] ~ sv"
eval_v_pairI: "[ i [) by lexicographc_orer
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
_op: \lbrakk v ] i [ ~ SConsp tyid dc b s"
eval_v
eval_v .

eval_v_elims:
"i [ V_lit l ] ~ s"
"i [
lemma va valid_trueI [inro:
"i [
"i [_f G"

eval_e :: "valuation ==> ce ==>> CC_true"
eval_e_valI: "i [ v p -
eval_e_plusI: "[i. i ⊨
eval_e_leqI: "\<;
eval_e_eqI: "[ i [ v1 ] ~ s1; i [ v2 ] ~ s2 ] ==> i [ (CE_op Eq v1 v2) ] ~ (SBool (s1 = s2))"
eval_e_fstI: "[ i [ v ] ~ SPair v1 v2 ] ==> i [ (CE_fst v) ] ~ v1"
eval_e_sndI: "[ i [ v ] ~ SPair v1 v2 ] ==> i [ (CE_snd v) ] ~ v2"
eval_e_concatI:"[ i [ v1 ] ~ (SBitvec bv1); i [ v2 ] ~ (SBitvec bv2) ] ==> i [ (CE_concat v1 v2) ] ~ (SBitvec (bv1@bv2))"
eval_e_lenI:"[ i [ v ] ~ (SBitvec bv) ] ==> i [ (CE_len v) ] ~ (SNum (int (List.length bv)))"
eval_e
eval_e .

eval_e_elims:
"i [ (CE_val v) ] ~ s"
"i [ (CE_op Plus v1 v2) ] ~ s"
"i [ (CE_op LEq v1 v2) ] ~ s"
"i [ (CE_op Eq v1 v2) ] ~ s"
"i [ (CE_fst v) ] ~ s"
"i [ (CE_snd v) ] ~ s"
"i [ (CE_concat v1 v2) ] ~ s"
"i [ (CE_len v) ] ~ s"

eval_c :: "valuation ==> c ==> bool ==> bool" ( ‹ _ [ _ ] ~ _ ›) where
eval_c_trueI: "i [ C_true ] ~ True"
eval_c_falseI:"i [ C_false ] ~ False"
eval_c_conjI: "[ i [ c1 ] ~ b1 ; i [ c2 ] ~ b2 ] ==> i [ (C_conj c1 c2) ] ~ (b1 ∧ b2)"
eval_c_disjI: "[ i [ c1 ] ~ b1 ; i [ c2 ] ~ b2 ] ==> i [ (C_disj c1 c2) ] ~ (b1 ∨ b2)"
eval_c_impI:"[ i [ c1 ] ~ b1 ; i [ c2 ] ~ b2 ] ==> i [ (C_imp c1 c2) ] ~ (b1 ⟶ b2)"
eval_c_notI:"[ i [ c ] ~ b ] ==> i [ (C_not c) ] ~ (¬ b)"
eval_c_eqI:"[ i [ e1 ] ~ sv1; i [ e2 ] ~ sv2 ] ==> i [ (C_eq e1 e2) ] ~ (sv1=sv2)"
eval_c
eval_c .

eval_c_elims:
"i [ C_true ] ~ True"
"i [ C_false ] ~ False"
"i [ (C_conj c1 c2)] ~ s"
"i [ (C_disj c1 c2)] ~ s"
"i [ (C_imp c1 c2)] ~ s"
"i [ (C_not c) ] ~ s"
"i [ (C_eq e1 e2)] ~ s"
"i [ C_true ] ~ s"
"i [ C_false ] ~ s"

‹Satisfiability›

is_satis :: "valuation ==> c ==> bool" ( ‹ _ ⊨ _ › ) where
"i [ c ] ~ True ==> i ⊨ c"
is_satis
is_satis .

is_satis_g :: "valuation ==> Γ ==> bool" ( ‹ _ ⊨ _ › ) where
"i ⊨ GNil = True"
"i ⊨ ((x,b,c) #_\Γ G) = ( i ⊨ c ∧ i ⊨ G)"
apply(auto simp: eqvt_def is_satis_g_graph_aux_def)
by (metis Γ.exhaust old.prod.exhaust)
(eqvt) by lexicographic_order

‹Validity›

valid :: "Θ ==> B ==> Γ ==> c ==> bool" (‹_ ; _ ; _ ⊨ _ › [50, 50] 50) where
"P ; B ; G ⊨ c = ( (P ; B ; G ⊨_w_f c) ∧ (∀i. (P ; G ⊨ i) ∧ i ⊨ G ⟶ i ⊨ c))"
by (auto simp: eqvt_def wfI_def valid_graph_aux_def)
(eqvt) by lexicographic_order

‹Lemmas›
‹Lemmas needed for Examples›

valid_trueI [intro]:
fixes G::Γ
assumes "P ; B ⊨_w_f G"
shows "P ; B ; G ⊨ C_true"
-
have "∀i. i ⊨ C_true" using is_satis.simps eval_c_trueI by simp
moreover have "P ; B ; G ⊨_w_f C_true" using wfC_trueI assms by simp
ultimately show ?thesis using valid.simps by simp

Messung V0.5 in Prozent

¤ Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.0.8Bemerkung: ¤

*Bot Zugriff

Wurzel

Suchen

NIST Cobol Testsuite

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.