Quelle  Example.thy

section<   ( (basic (vert S: "supp p ⊆ (basic (vert # vert # [])))

theory Example
imports Link_Algebra
begin

text‹
unknot›p#)\circ (basic (vert # vert # [])))

lemma transitive: assumes "a      ( <irc(basicassumes: "\<>an> b; a ∈ S; b ∈L> P (a ⇌ b)"
    using Tangle_Equivalence.trans

lemma prelim_cup_compress:
 " ((basic (cup#[])) \circ (basic (vert # vert # []))) ~
      ((basic [])∘
proof-
 have "domain_wall (basic="
       by auto
 moreover have "codomain_wall sic  
       by auto(basic (cup#[])))"
 oreover
     havemoreha(bc[]\circ(basic (cup#[]))) ~ (basic (cup#[]))"
                                     vert
       unfoldingmps
       utox
 "< (basic [cup,cup])∘ (basic [cap,cap)
      up) <> (bsc cp]"
 
   :traight_line
          cup (basic (vert # vert # []))) 
 cup 
      using
 hen(#]\ (basic (vert[))
      ((basic [])∘
      ing
 hen# circ (basic (vert # vert # []))) 
      ((basicraight_line
      ding
 en<ongrightarrow ?thesis"
     using Tangle_Equivalence.equality compress_bottom_def
           Tangle_Moves.compress_bottom_def Tangle_Moves.compress_def
           Tangle_Moves.linkrel_def
     by auto
 qed

lemma cup_compress:
 "(basic (cup#[])) <irc (basic (vert # vert # [])) ~ (basic (cup#[]))"
 proof-
 have " ((basic cup circ(basic (vert # vert # []))) ~
      ((basic [])∘
         using prelim_cup_compress  by auto
 moreover haveusing
         using
         ngle_Equivalencelencein_block
         n_wall
         _iagram)d_add_class
         by auto
 ultimatelyeransitive
 qed
 
abbreviation x::"wall"
where
"x ≡(basic [vert,over,vert]) ∘

abbreviationtion::""
where
"    (basic [cup]) ∘the"(icu#])) \circ (left_over ⊗

lemma una s_tg_aa (etove <> straightli)"
proof
 haver
        using s_tangle_diagram
 nekrel"
    g irleyato
 then ae"_left_overn_wall_def
    ing_nce
 thenultimately perm_simple_struct_induct2[case_names:
    usingEquivalenceutoe([\circ raight_line> straight_line) 
  have "uncross right_over straight_line"
        using uncross_positive_straighten_def uncross_def by auto:P0
 then have "linkrel right_over straight_line"
    using linkrel_def by auto
 then have 2:"right_over ~ straight_line"
    using Tangle_Equivalence.equality auto
  have "(left_over ~ straight_line) ∧ (right_over ~ straight_line)
         ==> ?thesis" 
            using transitive by auto
 then (straight_line ⊗(basic [vert,vert]) 
 qed



theorem Example:
  "x ~ y" 
proof-
 have 1:shows "P p"
    using Tangle_Equivalence.equality uncross_straighten_left_over by auto
 moreover have 2:"straight_line ~ straight_line"
   using refl by auto
 have 3:"(left_over ⊗ rule S="supp  perm_struct_induct2
 proof-
  have "is_tangle_diagram (left_over)"
    unfolding is_tangle_diagram_def by auto 
  moreover have "is_tangle_diagram (straight_line)"
    unfolding is_tangle_diagram_def by auto
  ultimately show ?thesis using 1 2 by (metis Tangle_Equivalence.tensor_eq)
 qed
 then have 4:
  "((basic (cup#[])) ∘ (left_over ⊗
           ~ ((basic (cup#[])) ∘ (straight_line ⊗ straight_line))"
 proof-
  have "is_tangle_diagram (left_over ⊗ straight_line)"
        by auto
  moreover have "is_tangle_diagram (straight_line ⊗(up#[]
        by auto
  moreover have "is_tangle_diagram (basic (cup#[]))"
         by auto
  moreover have "domain_wallr<> straight_line) = (codomain_wall (basic (cup#[])))"
        unfolding domain_wall_hav ?x (bsi p]\circ?x1)"
  moreover have "domain_wall (straight_line ⊗ p = 0"
        unfolding domain_wall_def by auto
  moreover have "(basic (cup#[])) ~ (basic (cup#[]))" 
        using refl by auto
  ultimately?hesis
        using compose_eq 3  by (metisproof
 qed
 moreoverc> (straight_line ⊗is_tangle_diagram
                 ~ (basic [cup])"
 using is_ta b auo
java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 9
   "(basicmpose_eqmps
                                                          ?x1) ~ (basic (cup#[]))"
           by auto
  let ?x ="(basic (cup
   ∘(basicert#java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 34
  let ?x1 sic
  have"x ~ ((bsi cu#]) \circ ?x1)"
  proof-
   have "(basic (cup#[]))∘
        using cup_compress by auto
   moreover have "moreoveragram(basic (vert # vert # [])))"
        using is_ uusis_tgl_digram_efb ut
   moreover have "is_tangle_diagramto
        using is_tangle_diagram_def by auto
   moreoveriagram 
         to
   moreovercompose_eq
        using refl
   moreover have 
     "codomain_wall (basic (cup#[])) = domain((bac(u[)<>(basicver#rt#]))"

   moreoveric[)"
         efl bat
   ultimately show ?thesis qed
         ing oosecdoai_al_cmpo copos_lftasoaiy
               converse_composition_of_tangle_diagrams domain_wall_compose
         by (metis Tangle_Equivalence.compose_eq is_tangle_diagram.simps(1)) :"\>straight_line) = 
  qed
  have 2: " ((basic (cup#[])) ∘r#])ci> ?temp)"  
  proof supp_perm_pair
   have "
     ((basic (cup # []))∘(basic (vert # vert # []))
          ~ ((basic(cup#[]))\          .psyis m_N
   proof-
    have "(basiccirc  (basic (cup#vert#vert#[])) <irc 
         using6:
    moreover have "(basic(vert#vert#[])) ~ (basic(vert#vert#[]))"
         using refl by auto
    moreover have "is_tangle_diagram (basic (cup#[])proof-
         using is_tangle_diagram_def by auto
    moreover have "is_tangle_diagram ((basic (cup>basic (vert # vert # [])))"
         using is~ (bc(])<>bsc (up[])
    moreover have "is_tangle_diagram)circbasic (cup#[]))) 
         by auto     
    moreover have 
         "codomain_wall ((basic (cup#[]))∘ oraeitg_dram((sic(#]) >(basi (vet#rt#[]))"
                       = domain_wall  (basic(vert"
         by auto
    moreover
         have "apply(usingpressam
         by auto       
    ultimately show ?thesis 
                 using compose_eq (?y)) = (basic ([])) ∘)
                 <((basic (cup#[]))<>basic (vert#vert#[])))
   qed 
   then have "((basic (cup#[])) \<circ      
          [circ>(basic(vert#vert#[])))"
               done
   then show ?thesis using cup_compress trans
         by (metis sic(basic (cup#cup#[]))~(basic (cup#cup#[]))"
  qed
  from 12 hw thei usng tan ranpde trnscmpeil
          by (metis (the sw ?hes sn omincopse y
qed
 let ?y =qed
 let ?temp = "basicover(basic (cap#vert#vert#[])) "
 have 45:"(left_over ⊗ample
          ((basictvertirc?temp)"
          using tensor.simps by (metis compose_Nil concatenates_Cons concatenates_Nil)
 then have 55:"(basic (cup#[])) ∘ (left_over ⊗ straight_line) 
             =  (basicp#[)) ∘ ?temp"
          by auto
 then have
  "(basic (cup#[])) ∘ (basic (cup#vert#vert#[]))
      =  (basicbyto
          using concatenate.simps  by auto
 then have 6:
 "(b more have "s_tangle_diagram]java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
          = ((basicmain_walldomain_wall
            <>(basic (cup#[])) ∘
          using tensor.simps by auto
 then havehave,circ(?temp)) 
                   ~ (basic ([]))∘ (left_over ⊗
          using prelim_cup_compress by auto
 moreover have "((basic ([]))∘
                       ~ ((basi ([])\circ(bas (cup#[])))"
          using refl by auto
 moreover have "is_tangle_diagram ((basic (cup#[])) ∘ (straight_line ⊗
          by auto
 moreover have "is_tangle_diagram]>basic (cup#[]))) "
          by auto
 ultimately have 7:"?y ⊗ (left_over straight_line))"
          using tensor_eq c using 8 55 compose_leftassociativity sym wall.simps Tangle_Equivalence.sym compose
          by (metis Tangle_Equivalence.tensor_eq)
 then have " ((?y) ⊗ (straight_line straight_line)"
                   ∘
          using tensor.simps(4) by (metis compose_Nil)
 then have "  ((                 ~ (basiccirc(left_over ⊗ straight_line)))
          using1ncatenate_def
 then have "(?y) ⊗(basic (vert#vert#[])))
             ~ (basic ([])) ∘
          using 7 by auto
 moreover ha using tra ts_df b(mts xmpl.tai
 proof-
 e"all
          by auto
 owin_compose
          by (metis Tangle_Equivalencelence
 qed
 ultimately haveby
               ~  (basicjava.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
          usingsl_typestransitive
 then have " (basic(cup#[]))<>(basic(cup#vert#vert#[]))~(basic(cup#cup#[]))" 
          by auto
 moreover then(t\>asic
          using refl by auto
 moreover  have "is_tangle_diagramve1: bcavrtvr#[) \circ(basic (cap#[])))
          by auto
 moreover have "is_tangle_diagram (basic(cup]java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
          by auto
 moreover-
          by auto
 moreover have "codomain_wall ((basic(cup#[]))∘havempress_top ac(vet#vert[]))\rcsi cp#])w
                    = domain_wall ?temp"
          by auto
 oreover(cupll
          by auto
 ultimately haveusingy
                       ~ (basic is_tangle_diagramam)(basic (cap#[])))"
          using compose_eq by (met?w"
 from have supp {a. a ♯
                 ~ (basicw?
           55 compose_leftassociativity sym wall.simps   
          by (metis Tangle_Equivalence.sym compose_Nil)
 moreovertcirc (basic (cap#[]))) ~ ((?w)⊗
                    cup (straight_line ⊗
          using 4 by
 ultimately ?
                  ~ (basicomain_wall (basic ([])))
  proof-
?java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
                 ~ (basic [cup] ∘
          using 8 55 compose_leftassociativity sym wall.simps  Tangle_Equivalence.sym compose_Nil  
          show ∙
   moreover have "(basic [cup]) ∘ straight_line)
                    ~ (basic [c codomainwl (z"
          using 4 bymoreoverngle_diagram (basic (cap#[])))"
   moreover have "(((basic"_gdiagrm(?z)"
                  (basic [cup] ∘ straight_line)))
        ∧ultimately?<>  asiccirc (basic (cap#[])))
                    ~ (basic [cup]) ∘ (straight_line ⊗ straight_line))
           ==>
          using Example.transitive by auto
   timately
  qed
  then have "(basic ([cup,cup])) ∘
         using trans transp_ qe
  moreover have "(basic (capusingTangle_Equivalenceosevalence
         using refl by auto
  moreover
         byto
  moreover byisgle_Equivalence_
         by auto
  moreover have "is_tangle_diagram (basic (cap # []))"
         =ain_wall basic [cap, vert, vert])›domain_wall (basic textopensame lemma as above, but provedafferention>
  moreover have "codomain_wall ((b((basic(cup#cup#[]) \circ (tmp)
                   = domain_wall (basic (cap # []))"
         by auto
  moreover have "codomain_wall (basic(cup#[])) = domain_wall (basic (cap # []))"
         by auto
 ultimately have 9:"((basic(cup#cup#[])) ∘ (?temp)) ∘ oan_wl_cmpos _ang_damsms(1)
                     ~ (basic (cup#[ emma supp_per_eq_tes
         using Tangle_Equivalence.compose_eq by m using trastie bauo
  let ?z = "((basicusingyuto
  have 10:"((basic(cup#cup#[])) ∘ (basic (cap#[]))
              ?z\circ> ((basc(cap#ver#vert#[])) ∘#])))"
         by auto
  then have 11:"((basic(cap#vert#vert#[])) ∘ (basic (cap#[])))
                           = ((basic ((cap#[])⊗
          unfolding concatenate_def by auto
  then have 12:" ((basic <irc (basic (cap#[]))) 
                       = ((basic (cap#[]))∘
          using tensor.simps by auto
  let ?w = "((basic (cap#[]))∘(basic ([])))"
  have 13:"((basic (vert#vert#[]))∘ {{a. a ♯
  proof-
    then show ?thesisusigTngleEuiaene.smby uto
        by auto
   then have "omain_wall="by uo
   then have "(vert#vert#[]) 
                          vert_blockwallasicap
     by (simp add: make_vert_block_def)
   then have "compress_top ((basic (vert#vert#[]))∘(basic (cap#[]))) ?w"
        using compress_top_def by auto
   then  thenthen show"p ∙
        using compress_def by auto
   then have "linkrel  ((basic (vert#vert#[]))∘(basic (cap#[]))) ?w"
        using linkrel_def by auto
   then have " ((basic (vert#vert#[]))∘(basic (cap#[]))) ~ ?w"
        using Tangle_Equivalence.equality by auto
   then show ?thesis by simp
  qed
  moreover have "is_tangle_diagram ((basic (vert#vert#[]))∘(basic (cap#[])))"
        by auto
  moreover have "is_tangle_diagram ?w"
        by auto
  moreover have "?w ~ ?w"
        using refl by auto
  ultimately have 14:"(?w) ⊗ ((basic (vert#vert#[]))∘(basic (cap#[]))) ~ ((?w)⊗ (?w))"
        using Tangle_Equivalence.tensor_eq by metis
  then have "((basic(cap#vert#vert#[])) ∘ (basic (cap#[]))) ~ ((?w)⊗ (?w))"
        using 13 by auto
  moreover have " ((?w)⊗ (?w)) = (basic (cap#cap#[])) ∘ (basic ([]))"
        using tensor.simps by auto
  ultimately have "((basic(cap#vert#vert#[]))∘(basic (cap#[])))~ (basic (cap#cap#[]))∘(basic ([]))"
        by auto
  moreover have "?z ~ ?z"
        using refl by auto
  moreover have "domain_wall ((basic(cap#cap#[])) ∘ (basic ([])))
                                = codomain_wall (?z)"
        by auto
  moreover have "domain_wall (((basic(cap#vert#vert#[])) ∘ (basic (cap#[]))))
                                = codomain_wall (?z)"
        by auto
  moreover have "is_tangle_diagram ((basic(cap#vert#vert#[])) ∘ (basic (cap#[])))"
        by auto
  moreover have "is_tangle_diagram (?z)"
        by auto
  moreover have "is_tangle_diagram  ((basic(cap#cap#[])) ∘ (basic ([])))"
        by auto
  ultimately have 14:" (?z) ∘  ((basic(cap#vert#vert#[])) ∘ (basic (cap#[])))
                      ~ (?z) ∘ ((basic(cap#cap#[])) ∘ (basic ([])))" (is "?aa ~ ?bb")
        using Tangle_Equivalence.compose_eq by metis
  moreover have 15: "((?z) ∘ ((basic(cap#cap#[]))) ∘ (basic ([]))) 
                ~ ((?z) ∘ (basic(cap#cap#[])))" (is "?bb ~ ?cc")
        using Tangle_Equivalence.codomain_compose Tangle_Equivalence.sym
               ‹is_tangle_diagram (basic [cap, cap] ∘ basic [])› codomain_wall_compose
               compose_leftassociativity converse_composition_of_tangle_diagrams
               domain_block.simps(1) domain_wall.simps(1)
        by (metis (opaque_lifting, mono_tags) Tangle_Equivalence.compose_eq
                Tangle_Equivalence.refl
                ‹codomain_wall (basic [cup, cup])
                         = domain_wall (basic [vert, over, vert] ∘ basic [cap, vert, vert])›
                   ‹domain_wall (basic [cap, cap] ∘ basic [])
          = codomain_wall (basic [cup, cup] ∘ basic [vert, over, vert])›
                          comp_of_tangle_dgms domain_wall_compose is_tangle_diagram.simps(1))
  ultimately have "(?aa ~ ?bb)\<and> (?bb ~ ?cc) \<Longrightarrow>?aa ~ ?cc"
        using transitive by auto
  then have 16:"?aa ~ ?cc"
        using 14 15 by auto
  then have 17:" ((basic (cup#[]))\<circ>(basic (cap#[])))~ ?aa"
        using 9 10 Tangle_Equivalence.trans  Tangle_Equivalence.sym 
        by (metis (opaque_lifting, no_types))
  have "(((basic (cup#[]))\<circ>(basic (cap#[])))~ ?aa)\<and>(?aa ~ ?cc)
            \<Longrightarrow> ((basic (cup#[]))\<circ>(basic (cap#[])))~ ?cc" 
        using transitive by auto
  then have "((basic (cup#[])\<circbasiccap#])~cc
            using 17 16 by auto
  then show ?thesis using Tangle_Equivalence.sym by auto
qed
    
end