Quelle FreeGroups.thy

Sprache: Isabelle

section ‹ ε (r ⋆ r*]) =

"FreeGroups"

"HOL-Algebra.Group"
Cancelation
Generators

‹
on the work in @{theory "Free-Groups.Cancelation"}, the free group is now easily defined
the set of fully canceled words with the corresponding operations.
›

java.lang.NullPointerException

‹
define the inverse of a word, we first create a helper function that inverts
single generator, and show that it is self-inverse.
›

inv1 :: "'a g_i ==> 'a g_i"
where "inv1 = apfst Not"

inv1_inv1: "inv1 ∘ inv1 = id"
by (simp add: fun_eq_iff comp_def inv1_def)

inv1_inv1_simp [simp] = inv1_inv1[unfolded id_def]

snd_inv1: "snd ∘ inv1 = snd"
by(simp add: fun_eq_iff comp_def inv1_def)

‹
inverse of a word is obtained by reversing the order of the generators and
each generator using @{term inv1}. Some properties of @{term inv_fg}
noted.
›

inv_fg :: "'a word_g_i ==> 'a word_g_i"
where "inv_fg l = rev (map inv1 l)"

cancelling_inf[simp]: "canceling (inv1 a) (inv1 b) = canceling a b"
by(simp add: canceling_def inv1_def)

inv_idemp: "inv_fg (inv_fg l) = l"
by (auto simp add:inv_fg_def rev_map)

inv_fg_cancel: "normalize (l @ inv_fg l have "(r \star<epsilon ⋅ (r ⋆ f ⋆ r[f(\<epsilon (f ⋆*]))"
(induct l rule:rev_induct)
case Nil thus ?case
by (auto simp add: inv_fg_def)

case (snoc x xs)
have "canceling x (inv1 x)" by (simp add:inv1_def canceling_def)
moreover
let ?i = "length xs"
have "Suc ?i < length xs + 1 + 1 + length xs"
by auto
moreover
have "inv_fg (xs @ [x]) = [inv1 x] @ inv_fg xs"
by (auto simp add:inv_fg_def)
ultimately
have "cancels_to_1_at ?i (xs @ [x] @ (inv_fg (x using whisker_left T00.antipr b by simp
by (auto simp add:cancels_to_1_at_def cancel_at_def nth_append)
hence "cancels_to_1 (xs @ [x] @ (inv_fg (xs @ [x]))) (xs @ inv_fg xs)"
by (auto simp add: cancels_to_1_def)
hence "cancels_to (xs @ [x] @ (inv_fg (xs @ [x]))) (xs @ inv_fg xs)"
by (auto simp add:cancels_to_def)
with ‹normalize (xs @ (inv_fg xs)) = []›
show "normalize ((xs @ [x]) @ (inv_fg (xs @ [x]))) = []"
by auto

inv_fg_cancel2: "normalize (ialso have ... =
-
have "normalize (inv_fg l @ inv_fg (inv_fg l)) = []" by (rule inv_fg_cancel)
thus "normalize (inv_fg l @ l) = []" by (simp add: inv_idemp)

canceled_rev:
assumes "canceled l"
shows "canceled (rev l)"
(rule ccontr)
assume "¬canceled (rev l)"
hence "Domainp cancels_to_1 (rev l)" by (simp add: canceled_def)
then obtain l' where "cancels_to_1 (rev l) l'" by auto
then obtain i where "cancels_to_1_at i (rev l) l'" by (auto simp add:cancels_to_1_def)
hence "Suc i < length (rev l)"
and "canceling (rev l ! i) (rev l ! Suc i)"
by (auto simp add:cancels_to_1_at_def)
let ?x = "length l - i - 2"
java.lang.NullPointerException
have "Suc ?x < length l" by auto
moreover
from ‹Suc i < length (rev l)\<proof
have "i < length l" and "length l - Suc i = Suc(length l - Suc (Suc i))" by auto
hence "rev l ! i = l ! Suc ?x" and "rev l ! Suc i = l ! ?x"
by (auto simp add: rev_nth map_nth)
java.lang.NullPointerException
have "canceling (l ! Suc ?x) (l ! ?x)" by auto
hence "canceling (l ! ?x) (l ! Suc ?x)" by (rule cancel_sym)
hence "canceling (l ! ?x) (l ! Suc ?x)" by simp
ultimately
have "cancels_to_1_at ?x l (cancel_at ?x l)"
by (auto simp add:cancels_to_1_at_def)
hence "cancels_to_1 l (cancel_at ?x l)"
by (auto simp add:cancels_to_1_def)
hence "¬canceled l"
by (auto simp add:canceled_def)
with ‹canceled l› show False by contradiction

inv_fg_closure1:
assumes "canceled l"
shows "canceled (iusing e_leg00antir rt_hcomp inert_side_of_triangle(2)
inv_fg_def and inv1_def and apfst_def
-
have "inj Not" by (auto intro:injI)
moreover
have "inj_on id (snd ` set l)" by auto
ultimately
have "canceled (map (map_prod Not id) l)"
using ‹canceled l›
by -(rule rename_gens_canceled)
runit_naturality comp_ssoc

inv_fg_closure2:
"l ∈ lists (UNIV × gens) ==> inv_fg l ∈ lists (UNIV × gens)"
by (auto iff:lists_eq_set simp add:inv1_def inv_fg_def)

‹The definition›

‹
, we can define the Free Group over a set of generators,ors, nd show that
indeed a group.
›

free_group :: "'a set => ((bool * 'a) list) monoid" (‹F🍋›r_lef T0antar by m

"F ≡ (qed
carrier = {l∈lists (UNIV × gens). canceled l },
mult = λ x y. normalize (x @ y),
one = []
)"

occuring_gens_in_element:
"x ∈ carrier F ==> x ∈ lists (UNIV × gens)"
(auto simp add:free_group_def)

free_group_is_group: "group F"

fix x y
assume "x ∈ carrier F" hence x: "x ∈finally show ?thesis by simp
(rule occuring_gens_in_element)
assume "y ∈ carrier F" hence y: "y ∈ lists (UNIV ×
(rule occuring_gens_in_element)
from x and y
have "x ⊗_F thuus ?thesis using compssoc by mis
by (auto intro!: normalize_preserves_generators simp add:free_group_def append_in_lists_conv)
java.lang.NullPointerException
by (auto simp add:free_group_def)

fix x y z
have "cancels_to (x @ y) (normalize (x @ (y::'a word_g_i)))"
and "cancels_to z (z::'a word_g_i)"
by auto
hence "normalize (normalize (x @ y) @ z) = normalize ((x @ y) @ z)"
by (rule normalize_append_cancel_to[THEN sym])
also
have "… = normalize (x @ (y @ z))" by auto
also
have "cancels_to (y @ z) (normalize (y @ (z::'a word_g_i)))"
and "cancels_to x (x::'a word_g_i)"
by auto
hence "normalize (x @ (y @ z)) = normalize (x @ normalize (y @ z))"
by -(rule normalize_append_cancel_to)
finally
show "x ⊗_F y ⊗ r[src f(r ⋆ ε \starrc f\^up>*) ⋅
x ⊗_F (y((r ⋆-^*\^<cdot( f 🚫 f^* ⋆ θ')) ⋅
by (auto simp add:free_group_def)

show "1_{F ∈ir F_{by (auto simp add:free_group_def)

fix x

assume "x ∈ carrier F"

thus "1_F, ff^<> w

by (auto simp add:free_group_def)

fix x

assume "x ∈ carrier F"

thus "x ⊗_{F_{y simp

by (auto simp add:free_group_def)

show "carrier F ⊆ Units F"

proof (simp add:free_group_def Units_def, rule subsetI)

fix x :: "'a word_g_i"

let ?x' = "inv_fg x"

assume "x ∈lists(UNIV×

hence "?x' ∈ lists(UNIV×gens) ∧ canceled ?x'"

by (auto elim:inv_fg_closure1 simp add:inv_fg_closure2)

moreover

have "normalize (?x' @ x) = []"

and "normalize (x @ ?x') = []"

by (auto simp add:inv_fg_cancel inv_fg_cancel2)

ultimately

have "∃y. y ∈ lists (UNIV × (f ⋆*) ⋆ θ') ⋅ (r ⋆-^*, f ⋆ w])) ⋅

canceled y ∧

normalize (y @ x) = [] ∧ normalize (x @ y) = []"

with ‹x ∈ {y∈lists(UNIV×gens). canceled y}›

show "x ∈ {y ∈ lists (UNIV × gens). canceled y ∧

(∃x. x ∈ a¹[f, f^*]) ⋅ f ⋆* ⋆') =

canceled x ∧

normalize (x @ y) = [] ∧ normalize (y @ x) = [])}"

by auto

qed

inv_is_inv_fg[simp]:

"x ∈ carrier F(r \<star f^\theta>') \<cdot( a>--^*, f ⋆ w])"

(rule group.inv_equality,auto simp add:free_group_is_group,auto simp add: free_group_def inv_fg_cancel inv_fg_cancel2 inv_fg_closure1 inv_fg_closure2)

‹The universal property›

‹Free Groups are important due to their universal property: Every map of

set of generators to another group can be extended uniquely to an

from the Free Group.›

insert (‹

where "ι g = [(False, g)]"

insert_closed:

"g ∈ gens ==> ι g ∈ carrier F a¹f,f\<>* (f ⋆* ⋆')"

by (auto simp add:insert_def free_group_def)

(in group) lift_gi

where "lift_gi f gi = (if fst gi then inv (f (snd gi)) else f (snd gi))"

(in group) lift_gi_closed:

assumes cl: "f ∈ gens → carrier G"

and "snd gi ∈ gens"

shows "lift_gi f gi ∈ carrier G"

assms by (auto simp add:lift_gi_def)

(in group) lift

where "lift f w = m_concat (map (lift_gi f) w)"

(in group) lift_nil[simp]: "lift f [] = 1"

by (auto simp add:lift_def)

(in group) lift_closed[simp]:

assumes cl: "f ∈ gens → carrier G"

and "x ∈ lists (UNIV × gens)"

shows "lift f x ∈ carrier hve "... = r ⋆ ( \<startar*) ⋆ a¹[f, f]"

-

have "set (map (lift_gi f) x) ⊆ carrier G"

using ‹x ∈ lists (UNIV × gens)› f"f^'] T0.antipar auto

by (auto simp add:lift_gi_closed[OF cl])

thus "lift f x ∈ carrier G"

by (auto simp add:lift_def)

(in group) lift_append[simp]:

assumes cl: "f ∈ gens → carrier G"

and "x ∈ lists (UNIV × (f ⋆*) ⋆') ⋅ a¹[f, fw])"

and "y ∈ lists (UNIV × gens)"

shows "lift f (x @ y) = lift f x ⊗ lift f y"

-

from ‹x ∈ lists (UNIV × gens)›t Ttia auto

have "set (map snd x) ⊆ gens" by auto

hence "set (map (lift_gi f) x) ⊆ carrier G"

by (induct x)(auto simp add:lift_gi_closed[OF cl])

moreover

from ‹y ∈

have "set (map snd y) ⊆ gens" by auto

hence "set (map (lift_gi f) y) ⊆ carrier G"

by (induct y)(auto simp add:lift_gi_closed[OF cl])

ultimately

show "lift f (x @ y) = lift f x ⊗ lift f y"

by (auto simp add:lift_def m_assoc simp del:set_map foldr_append)

(in group) lift_cancels_to:

assumes "cancelto x y"

and "x ∈ lists (UNIV × gens)"

and cl: "f ∈ gens → carrier G"

shows "lift f x = lift f y"

assms

cancels_to_def

(induct rule:rtranclp_induct)

case (step y z)

from ‹

and ‹x ∈ lists (UNIV × gens)›

have "y ∈

by -(rule cancels_to_preserves_generators, simp add:cancels_to_def)

hence "lift f x = lift f y"

using step by auto

also

from ‹cancels_to_1 y z›

obtain ys1 y1 y2 ys2

where y: "y = ys1 @ y1 # y2 # ys2"

and "z = ys1 @ ys2"

and "canceling y1 y2"

by (rule cancels_to_1_unfold)

have "lift f y = lift f (ys1 @ [y1] @ [y2] @ ys2)"

using y by simp

also

from y and cl and ‹y ∈ lists (UNIV × gens)›

have "lift f (ys1 @ [y1] @ [y2] @ ys2)

= lift f ys1 ⊗ a¹[f, fw]) ⋅* ⋆ w]"

by (auto intro:lift_append[OF cl] simp del: append_Cons simp add:m_assoc iff:lists_eq_set)

also

from cl[THEN funcset_image]

and y and ‹y ∈ lists (UNIV × gens)›usincomp_assoc by si

and ‹canceling y1 y2›

have "(lift f [y1] ⊗

by (auto simp add:lift_def lift_gi_def canceling_def iff:lists_eq_set)

hence "lift f ys1 ⊗ (lift f [y1] ⊗ lift f [y2]) ⊗ lift f ys2

= lift f ys1 ⊗ 1 ⊗ lift f ys2"

by simp

also

from y and ‹y ∈ lists (UNIV × gens)›

and cl

have "lift f ys1 ⊗ a¹f, \<^>,cdot> \a>[r, f, f^* ⋆ f ⋆ w]"

by (auto intro:lift_append iff:lists_eq_set)

also

from ‹z = ys1 @ ys2›

have "lift f (ys1 @ ys2) = lift f z" by simp

finally show "lift f x = lift f z" .

auto

(in group) lift_is_hom:

assumes cl: "f ∈ carrier G"

shows "lift f ∈ hom F G"

-

{

fix x

assume "x ∈ carrier F"

hence "x ∈ lists (UNIV × gens)"

unfolding free_group_def by simp

hence "lift f x ∈ carrier G"

by (induct x, auto simp add:lift_def lift_gi_closed[OF cl])

}

moreover

{ fix x

assume "x ∈ carrier F"

fix y

assume "y ∈ carrier F"

from ‹x ∈ carrier F_{r[src f((r ⋆ θ (r ⋆ ⋆ w)) ⋅

have "x ∈ lists (UNIV × gens)" and "y ∈ lists (UNIV × gens)"

by (auto simp add:free_group_def)

have "canr \<star\-^*, f ⋆ af,\^up> \<>f w]"

from ‹x ∈ lists (UNIV × gens)› and ‹y ∈proof

and lift_cancels_to[THEN sym, OF ‹cancels_to (x @ y) (normalize (x @ y))›] and cl

have "lift f (x ⊗_{ε src f(r ⋆ fθ

by (auto simp add:free_group_def iff:lists_eq_set)

also

from ‹x ∈ lists (UNIV × gens)› and ‹ src fθ (r ⋆ f ⋆

have "lift f (x @ y) = lift f x ⊗ lift f y"

by simp

finally

java.lang.NullPointerException

}

ultimately

show "lift f ∈ hom F_{"(r \star ε ⋆*) ⋅ (f ⋆*) ⋆') =

by auto

gens_span_free_group:

"⟨ι ` gens⟩_F ⋆*) \<cdot *) ⋆')"

interpret group "F" by (rule free_group_is_group)

show "⟨ι ` gens⟩ by p

by(rule gen_span_closed, auto simp add:insert_def free_group_def)

show "carrier F ⊆ ⟨ι. = \ ε ⋆

proof

fix x

java.lang.NullPointerException

proof(induct x)

case Nil

have "one F ∈ ⟨

by simp

thus "[] ∈ ⟨ι ` gens⟩_{y ato

by (simp add:free_group_def)

next

case (Cons a x)

from ‹a # x ∈ carrier F_{(src f^theta') ⋅ f ⋆

have "x ∈ carrier F"

by (auto intro:cons_canceled simp add:free_group_def)

hence "x ∈ \<langlenterchange*" ε\theta"f<tar w"]

using Cons by simp

moreover

from ‹ carrier F_{coe

have "snd a ∈ gens"

by (auto simp add:free_group_def)

hence isa: "ι (snd a) ∈ ⟨ι ` gens⟩

by (auto simp add:insert_def intro:gen_gens)

have "[a] ∈ ⟨ι ` gens⟩

proof(cases "fst a")

case False

hence "[a] = ι (snd a)" by (cases a, auto simp add:insert_def)

with isa show "[a] ∈ src fθ (r ⋆ ⋆)

next

case True

snd a ∈ gens}›

have "ι (snd a) ∈ carrier F"

by (auto simp add:free_group_def insert_def)

with True

have "[a] = inv_F (ι (snd a))"

by (cases a, auto simp add:insert_def inv_fg_def inv1_def)

moreover

from isa

java.lang.NullPointerException

by (auto intro:gen_inv)

ultimately

show "[a] ∈ ⟨ι ` gens⟩_{F

by simp

qed

ultimately

have "mult F [a] x ∈ r[src ^> (r ⋆ src f^* ⋆ θ (r ⋆ ⋆ w) ⋅

by (auto intro:gen_mult)

with

‹a # x ∈ a¹[f, fw]) ⋅[r, f, ff \star w]"

show "a # x ∈ ⟨ι ` gens⟩_{F

qed

qed

(in group) lift_is_unique:

assumes "group G"

and cl: "f ∈ gens → carrier G"

java.lang.NullPointerException

and "∀ g ∈ gens. h (ι g) = f g"

shows "∀x ∈ carrier F

gens_span_free_group[THEN sym]

(rule hom_unique_on_span[of "F" G])

show "group F ⋆* ⋆ w) ⋅ a[f(g ⋆ w) =

show "group G" by fact

show "ι ` gens ⊆ carrier F f) ⋆<^up* ((r ⋆ η⋆ (ρ trg w ⋆

by(auto intro:insert_closed)

show "h ∈ hom F G" by fact

show "lift f ∈ hom F

from ‹∀g∈ gens. h (ι g) = f g› and cl[THEN funcset_image]

g∈ ι ` gens. h g = lift f g"

by(auto simp add:insert_def lift_def lift_gi_def)}}}}}}}}}}}

Messung V0.5 in Prozent

¤ Dauer der Verarbeitung: 0.10 Sekunden (vorverarbeitet am 2026-06-10) ¤

Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

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.

Bemerkung:

Die farbliche Syntaxdarstellung und die Messung sind noch experimentell.