Datasets:
Tasks:
Text Generation
Modalities:
Text
Sub-tasks:
language-modeling
Languages:
English
Size:
100K - 1M
License:
:: Basic Algebraic Structures | |
:: by Library Committee | |
environ | |
vocabularies XBOOLE_0, SUBSET_1, BINOP_1, ZFMISC_1, STRUCT_0, ARYTM_3, | |
FUNCT_1, FUNCT_5, SUPINF_2, ARYTM_1, RELAT_1, MESFUNC1, ALGSTR_0, CARD_1; | |
notations TARSKI, XBOOLE_0, SUBSET_1, ZFMISC_1, BINOP_1, FUNCT_5, ORDINAL1, | |
CARD_1, STRUCT_0; | |
constructors BINOP_1, STRUCT_0, ZFMISC_1, FUNCT_5; | |
registrations ZFMISC_1, CARD_1, STRUCT_0; | |
theorems STRUCT_0; | |
begin :: Additive structures | |
reserve D for non empty set, | |
d,e for Element of D, | |
o,o1 for BinOp of D; | |
reserve T for trivial set, | |
s,t for Element of T, | |
f,f1 for BinOp of T; | |
reserve N for non trivial set, | |
n,m for Element of N, | |
b,b1 for BinOp of N; | |
definition | |
struct (1-sorted) addMagma (# carrier -> set, addF -> BinOp of the carrier | |
#); | |
end; | |
registration | |
let D,o; | |
cluster addMagma(#D,o#) -> non empty; | |
coherence; | |
end; | |
registration | |
let T,f; | |
cluster addMagma(#T,f#) -> trivial; | |
coherence; | |
end; | |
registration | |
let N,b; | |
cluster addMagma(#N,b#) -> non trivial; | |
coherence; | |
end; | |
definition | |
let M be addMagma; | |
let x,y be Element of M; | |
func x+y -> Element of M equals | |
(the addF of M).(x,y); | |
coherence; | |
end; | |
definition | |
func Trivial-addMagma -> addMagma equals | |
addMagma(#{0}, op2 #); | |
coherence; | |
end; | |
registration | |
cluster Trivial-addMagma -> 1-element strict; | |
coherence; | |
end; | |
registration | |
cluster strict 1-element for addMagma; | |
existence | |
proof | |
take Trivial-addMagma; | |
thus thesis; | |
end; | |
end; | |
definition | |
let M be addMagma, x be Element of M; | |
attr x is left_add-cancelable means | |
for y,z being Element of M st x+y = x+z holds y = z; | |
attr x is right_add-cancelable means | |
for y,z being Element of M st y+ x = z+x holds y = z; | |
end; | |
definition | |
let M be addMagma, x be Element of M; | |
attr x is add-cancelable means | |
x is right_add-cancelable left_add-cancelable; | |
end; | |
registration | |
let M be addMagma; | |
cluster right_add-cancelable left_add-cancelable -> add-cancelable for | |
Element | |
of M; | |
coherence; | |
cluster add-cancelable -> right_add-cancelable left_add-cancelable for | |
Element | |
of M; | |
coherence; | |
end; | |
definition | |
let M be addMagma; | |
attr M is left_add-cancelable means | |
:Def6: | |
for x being Element of M holds x is left_add-cancelable; | |
attr M is right_add-cancelable means | |
:Def7: | |
for x being Element of M holds x is right_add-cancelable; | |
end; | |
definition | |
let M be addMagma; | |
attr M is add-cancelable means | |
M is right_add-cancelable left_add-cancelable; | |
end; | |
registration | |
cluster right_add-cancelable left_add-cancelable -> add-cancelable for | |
addMagma; | |
coherence; | |
cluster add-cancelable -> right_add-cancelable left_add-cancelable for | |
addMagma; | |
coherence; | |
end; | |
registration | |
cluster Trivial-addMagma -> add-cancelable; | |
coherence | |
proof | |
set M = Trivial-addMagma; | |
thus M is right_add-cancelable | |
proof | |
let x,y,z be Element of M; | |
assume y+x = z+x; | |
thus thesis by STRUCT_0:def 10; | |
end; | |
let x,y,z being Element of M; | |
assume x+y = x+z; | |
thus thesis by STRUCT_0:def 10; | |
end; | |
end; | |
registration | |
cluster add-cancelable strict 1-element for addMagma; | |
existence | |
proof | |
take Trivial-addMagma; | |
thus thesis; | |
end; | |
end; | |
registration | |
let M be left_add-cancelable addMagma; | |
cluster -> left_add-cancelable for Element of M; | |
coherence by Def6; | |
end; | |
registration | |
let M be right_add-cancelable addMagma; | |
cluster -> right_add-cancelable for Element of M; | |
coherence by Def7; | |
end; | |
definition | |
struct (ZeroStr,addMagma) addLoopStr (# carrier -> set, addF -> BinOp of the | |
carrier, ZeroF -> Element of the carrier #); | |
end; | |
registration | |
let D,o,d; | |
cluster addLoopStr(#D,o,d#) -> non empty; | |
coherence; | |
end; | |
registration | |
let T,f,t; | |
cluster addLoopStr(#T,f,t#) -> trivial; | |
coherence; | |
end; | |
registration | |
let N,b,m; | |
cluster addLoopStr(#N,b,m#) -> non trivial; | |
coherence; | |
end; | |
definition | |
func Trivial-addLoopStr -> addLoopStr equals | |
addLoopStr(#{0}, op2, op0 #); | |
coherence; | |
end; | |
registration | |
cluster Trivial-addLoopStr -> 1-element strict; | |
coherence; | |
end; | |
registration | |
cluster strict 1-element for addLoopStr; | |
existence | |
proof | |
take Trivial-addLoopStr; | |
thus thesis; | |
end; | |
end; | |
definition | |
let M be addLoopStr, x be Element of M; | |
attr x is left_complementable means | |
ex y being Element of M st y+x = 0.M; | |
attr x is right_complementable means | |
ex y being Element of M st x+y = 0.M; | |
end; | |
definition | |
let M be addLoopStr, x be Element of M; | |
attr x is complementable means | |
x is right_complementable left_complementable; | |
end; | |
registration | |
let M be addLoopStr; | |
cluster right_complementable left_complementable -> complementable for | |
Element | |
of M; | |
coherence; | |
cluster complementable -> right_complementable left_complementable for | |
Element | |
of M; | |
coherence; | |
end; | |
definition | |
let M be addLoopStr, x be Element of M; | |
assume | |
A1: x is left_complementable right_add-cancelable; | |
func -x -> Element of M means | |
it + x = 0.M; | |
existence by A1; | |
uniqueness by A1; | |
end; | |
definition | |
let V be addLoopStr; | |
let v,w be Element of V; | |
func v - w -> Element of V equals | |
v + -w; | |
correctness; | |
end; | |
registration | |
cluster Trivial-addLoopStr -> add-cancelable; | |
coherence | |
proof | |
set M = Trivial-addLoopStr; | |
thus M is right_add-cancelable | |
proof | |
let x,y,z be Element of M; | |
assume y+x = z+x; | |
thus thesis by STRUCT_0:def 10; | |
end; | |
let x,y,z being Element of M; | |
assume x+y = x+z; | |
thus thesis by STRUCT_0:def 10; | |
end; | |
end; | |
definition | |
let M be addLoopStr; | |
attr M is left_complementable means | |
:Def15: | |
for x being Element of M holds x is left_complementable; | |
attr M is right_complementable means | |
:Def16: | |
for x being Element of M holds x is right_complementable; | |
end; | |
definition | |
let M be addLoopStr; | |
attr M is complementable means | |
M is right_complementable left_complementable; | |
end; | |
registration | |
cluster right_complementable left_complementable -> complementable | |
for addLoopStr; | |
coherence; | |
cluster complementable -> right_complementable left_complementable | |
for addLoopStr; | |
coherence; | |
end; | |
registration | |
cluster Trivial-addLoopStr -> complementable; | |
coherence | |
proof | |
set M = Trivial-addLoopStr; | |
thus M is right_complementable | |
proof | |
let x be Element of M; | |
take x; | |
thus thesis by STRUCT_0:def 10; | |
end; | |
let x being Element of M; | |
take x; | |
thus thesis by STRUCT_0:def 10; | |
end; | |
end; | |
registration | |
cluster complementable add-cancelable strict 1-element for addLoopStr; | |
existence | |
proof | |
take Trivial-addLoopStr; | |
thus thesis; | |
end; | |
end; | |
registration | |
let M be left_complementable addLoopStr; | |
cluster -> left_complementable for Element of M; | |
coherence by Def15; | |
end; | |
registration | |
let M be right_complementable addLoopStr; | |
cluster -> right_complementable for Element of M; | |
coherence by Def16; | |
end; | |
begin :: Multiplicative structures | |
definition | |
struct (1-sorted) multMagma (# carrier -> set, multF -> BinOp of the carrier | |
#); | |
end; | |
registration | |
let D,o; | |
cluster multMagma(#D,o#) -> non empty; | |
coherence; | |
end; | |
registration | |
let T,f; | |
cluster multMagma(#T,f#) -> trivial; | |
coherence; | |
end; | |
registration | |
let N,b; | |
cluster multMagma(#N,b#) -> non trivial; | |
coherence; | |
end; | |
definition | |
let M be multMagma; | |
let x,y be Element of M; | |
func x*y -> Element of M equals | |
(the multF of M).(x,y); | |
coherence; | |
end; | |
definition | |
func Trivial-multMagma -> multMagma equals | |
multMagma(#{0}, op2 #); | |
coherence; | |
end; | |
registration | |
cluster Trivial-multMagma -> 1-element strict; | |
coherence; | |
end; | |
registration | |
cluster strict 1-element for multMagma; | |
existence | |
proof | |
take Trivial-multMagma; | |
thus thesis; | |
end; | |
end; | |
definition | |
let M be multMagma, x be Element of M; | |
attr x is left_mult-cancelable means | |
for y,z being Element of M st x*y = x*z holds y = z; | |
attr x is right_mult-cancelable means | |
for y,z being Element of M st y*x = z*x holds y = z; | |
end; | |
definition | |
let M be multMagma, x be Element of M; | |
attr x is mult-cancelable means | |
x is right_mult-cancelable left_mult-cancelable; | |
end; | |
registration | |
let M be multMagma; | |
cluster right_mult-cancelable left_mult-cancelable -> mult-cancelable | |
for Element of M; | |
coherence; | |
cluster mult-cancelable -> right_mult-cancelable left_mult-cancelable | |
for Element of M; | |
coherence; | |
end; | |
definition | |
let M be multMagma; | |
attr M is left_mult-cancelable means | |
:Def23: | |
for x being Element of M holds x is left_mult-cancelable; | |
attr M is right_mult-cancelable means | |
:Def24: | |
for x being Element of M holds x is right_mult-cancelable; | |
end; | |
definition | |
let M be multMagma; | |
attr M is mult-cancelable means | |
M is left_mult-cancelable right_mult-cancelable; | |
end; | |
registration | |
cluster right_mult-cancelable left_mult-cancelable -> mult-cancelable | |
for multMagma; | |
coherence; | |
cluster mult-cancelable -> right_mult-cancelable left_mult-cancelable | |
for multMagma; | |
coherence; | |
end; | |
registration | |
cluster Trivial-multMagma -> mult-cancelable; | |
coherence | |
proof | |
set M = Trivial-multMagma; | |
thus M is left_mult-cancelable | |
proof | |
let x,y,z be Element of M; | |
assume x*y = x*z; | |
thus thesis by STRUCT_0:def 10; | |
end; | |
let x,y,z being Element of M; | |
assume y*x = z*x; | |
thus thesis by STRUCT_0:def 10; | |
end; | |
end; | |
registration | |
cluster mult-cancelable strict 1-element for multMagma; | |
existence | |
proof | |
take Trivial-multMagma; | |
thus thesis; | |
end; | |
end; | |
registration | |
let M be left_mult-cancelable multMagma; | |
cluster -> left_mult-cancelable for Element of M; | |
coherence by Def23; | |
end; | |
registration | |
let M be right_mult-cancelable multMagma; | |
cluster -> right_mult-cancelable for Element of M; | |
coherence by Def24; | |
end; | |
definition | |
struct (OneStr,multMagma) multLoopStr (# carrier -> set, multF -> BinOp of | |
the carrier, OneF -> Element of the carrier #); | |
end; | |
registration | |
let D,o,d; | |
cluster multLoopStr(#D,o,d#) -> non empty; | |
coherence; | |
end; | |
registration | |
let T,f,t; | |
cluster multLoopStr(#T,f,t#) -> trivial; | |
coherence; | |
end; | |
registration | |
let N,b,m; | |
cluster multLoopStr(#N,b,m#) -> non trivial; | |
coherence; | |
end; | |
definition | |
func Trivial-multLoopStr -> multLoopStr equals | |
multLoopStr(#{0}, op2, op0 #); | |
coherence; | |
end; | |
registration | |
cluster Trivial-multLoopStr -> 1-element strict; | |
coherence; | |
end; | |
registration | |
cluster strict 1-element for multLoopStr; | |
existence | |
proof | |
take Trivial-multLoopStr; | |
thus thesis; | |
end; | |
end; | |
registration | |
cluster Trivial-multLoopStr -> mult-cancelable; | |
coherence | |
proof | |
set M = Trivial-multLoopStr; | |
thus M is left_mult-cancelable | |
proof | |
let x,y,z be Element of M; | |
assume x*y = x*z; | |
thus thesis by STRUCT_0:def 10; | |
end; | |
let x,y,z being Element of M; | |
assume y*x = z*x; | |
thus thesis by STRUCT_0:def 10; | |
end; | |
end; | |
definition | |
let M be multLoopStr, x be Element of M; | |
attr x is left_invertible means | |
ex y being Element of M st y*x = 1.M; | |
attr x is right_invertible means | |
ex y being Element of M st x*y = 1.M; | |
end; | |
definition | |
let M be multLoopStr, x be Element of M; | |
attr x is invertible means | |
x is right_invertible left_invertible; | |
end; | |
registration | |
let M be multLoopStr; | |
cluster right_invertible left_invertible -> invertible for Element of M; | |
coherence; | |
cluster invertible -> right_invertible left_invertible for Element of M; | |
coherence; | |
end; | |
definition | |
let M be multLoopStr, x be Element of M; | |
assume that | |
A1: x is left_invertible and | |
A2: x is right_mult-cancelable; | |
func /x -> Element of M means | |
it * x = 1.M; | |
existence by A1; | |
uniqueness by A2; | |
end; | |
definition | |
let M be multLoopStr; | |
attr M is left_invertible means | |
:Def31: | |
for x being Element of M holds x is left_invertible; | |
attr M is right_invertible means | |
:Def32: | |
for x being Element of M holds x is right_invertible; | |
end; | |
definition | |
let M be multLoopStr; | |
attr M is invertible means | |
M is right_invertible left_invertible; | |
end; | |
registration | |
cluster right_invertible left_invertible -> invertible for multLoopStr; | |
coherence; | |
cluster invertible -> right_invertible left_invertible for multLoopStr; | |
coherence; | |
end; | |
registration | |
cluster Trivial-multLoopStr -> invertible; | |
coherence | |
proof | |
set M = Trivial-multLoopStr; | |
thus M is right_invertible | |
proof | |
let x be Element of M; | |
take x; | |
thus thesis by STRUCT_0:def 10; | |
end; | |
let x being Element of M; | |
take x; | |
thus thesis by STRUCT_0:def 10; | |
end; | |
end; | |
registration | |
cluster invertible mult-cancelable strict 1-element for multLoopStr; | |
existence | |
proof | |
take Trivial-multLoopStr; | |
thus thesis; | |
end; | |
end; | |
registration | |
let M be left_invertible multLoopStr; | |
cluster -> left_invertible for Element of M; | |
coherence by Def31; | |
end; | |
registration | |
let M be right_invertible multLoopStr; | |
cluster -> right_invertible for Element of M; | |
coherence by Def32; | |
end; | |
begin :: Almost | |
definition | |
struct (multLoopStr,ZeroOneStr) multLoopStr_0 (# carrier -> set, multF -> | |
BinOp of the carrier, ZeroF, OneF -> Element of the carrier #); | |
end; | |
registration | |
let D,o,d,e; | |
cluster multLoopStr_0(#D,o,d,e#) -> non empty; | |
coherence; | |
end; | |
registration | |
let T,f,s,t; | |
cluster multLoopStr_0(#T,f,s,t#) -> trivial; | |
coherence; | |
end; | |
registration | |
let N,b,m,n; | |
cluster multLoopStr_0(#N,b,m,n#) -> non trivial; | |
coherence; | |
end; | |
definition | |
func Trivial-multLoopStr_0 -> multLoopStr_0 equals | |
multLoopStr_0(#{0}, op2,op0, op0 #); | |
coherence; | |
end; | |
registration | |
cluster Trivial-multLoopStr_0 -> 1-element strict; | |
coherence; | |
end; | |
registration | |
cluster strict 1-element for multLoopStr_0; | |
existence | |
proof | |
take Trivial-multLoopStr_0; | |
thus thesis; | |
end; | |
end; | |
::$CD | |
definition | |
let M be multLoopStr_0; | |
attr M is almost_left_cancelable means | |
for x being Element of M st x <> 0.M holds x is left_mult-cancelable; | |
attr M is almost_right_cancelable means | |
for x being Element of M st x <> 0.M holds x is right_mult-cancelable; | |
end; | |
definition | |
let M be multLoopStr_0; | |
attr M is almost_cancelable means | |
M is almost_left_cancelable almost_right_cancelable; | |
end; | |
registration | |
cluster almost_right_cancelable almost_left_cancelable -> almost_cancelable | |
for multLoopStr_0; | |
coherence; | |
cluster almost_cancelable -> almost_right_cancelable almost_left_cancelable | |
for multLoopStr_0; | |
coherence; | |
end; | |
registration | |
cluster Trivial-multLoopStr_0 -> almost_cancelable; | |
coherence | |
proof | |
set M = Trivial-multLoopStr_0; | |
thus M is almost_left_cancelable | |
by STRUCT_0:def 10; | |
let x be Element of M; | |
assume x <> 0.M; | |
let y,z being Element of M; | |
assume y*x = z*x; | |
thus thesis by STRUCT_0:def 10; | |
end; | |
end; | |
registration | |
cluster almost_cancelable strict 1-element for multLoopStr_0; | |
existence | |
proof | |
take Trivial-multLoopStr_0; | |
thus thesis; | |
end; | |
end; | |
definition | |
let M be multLoopStr_0; | |
attr M is almost_left_invertible means | |
for x being Element of M st x <> 0.M holds x is left_invertible; | |
attr M is almost_right_invertible means | |
for x being Element of M st x <> 0.M holds x is right_invertible; | |
end; | |
definition | |
let M be multLoopStr_0; | |
attr M is almost_invertible means | |
M is almost_right_invertible almost_left_invertible; | |
end; | |
registration | |
cluster almost_right_invertible almost_left_invertible -> almost_invertible | |
for multLoopStr_0; | |
coherence; | |
cluster almost_invertible -> almost_right_invertible almost_left_invertible | |
for multLoopStr_0; | |
coherence; | |
end; | |
registration | |
cluster Trivial-multLoopStr_0 -> almost_invertible; | |
coherence | |
proof | |
set M = Trivial-multLoopStr_0; | |
thus M is almost_right_invertible | |
by STRUCT_0:def 10; | |
let x being Element of M; | |
assume x <> 0.M; | |
take x; | |
thus thesis by STRUCT_0:def 10; | |
end; | |
end; | |
registration | |
cluster almost_invertible almost_cancelable strict 1-element | |
for multLoopStr_0; | |
existence | |
proof | |
take Trivial-multLoopStr_0; | |
thus thesis; | |
end; | |
end; | |
begin :: Double | |
definition | |
struct(addLoopStr,multLoopStr_0) doubleLoopStr (# carrier -> set, addF, | |
multF -> BinOp of the carrier, OneF, ZeroF -> Element of the carrier #); | |
end; | |
registration | |
let D,o,o1,d,e; | |
cluster doubleLoopStr(#D,o,o1,d,e#) -> non empty; | |
coherence; | |
end; | |
registration | |
let T,f,f1,s,t; | |
cluster doubleLoopStr(#T,f,f1,s,t#) -> trivial; | |
coherence; | |
end; | |
registration | |
let N,b,b1,m,n; | |
cluster doubleLoopStr(#N,b,b1,m,n#) -> non trivial; | |
coherence; | |
end; | |
definition | |
func Trivial-doubleLoopStr -> doubleLoopStr equals | |
doubleLoopStr(#{0}, op2, op2, op0, op0 #); | |
coherence; | |
end; | |
registration | |
cluster Trivial-doubleLoopStr -> 1-element strict; | |
coherence; | |
end; | |
registration | |
cluster strict 1-element for doubleLoopStr; | |
existence | |
proof | |
take Trivial-doubleLoopStr; | |
thus thesis; | |
end; | |
end; | |
definition | |
let M be multLoopStr, x,y be Element of M; | |
func x/y -> Element of M equals x*/y; | |
coherence; | |
end; | |