fullname
stringlengths 21
72
| header
stringlengths 137
382
| imported_modules
stringlengths 91
330
| opened_namespaces
stringlengths 1
100
| formal_statement
stringlengths 73
428
| formal_statement_original
stringlengths 85
440
| formal_statement_references
stringlengths 0
113
| formal_proof
stringclasses 1
value | formal_proof_references
stringclasses 1
value | doc_string
stringclasses 1
value | problem_id
stringclasses 1
value | problem_kind
stringclasses 1
value | informal_statement
stringclasses 1
value | informal_proof
stringclasses 1
value | ref
stringclasses 1
value | inv_references
stringclasses 1
value | module_name
stringlengths 37
66
| head
null | lean_toolchain
stringclasses 1
value | package_name
stringclasses 1
value | passed
bool 2
classes | validation_detail
stringlengths 0
1.49k
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Monoid.CoprodI.NeWord.of_word_tac_26830 | import Init
import Mathlib.Algebra.Group.Submonoid.Membership
import Mathlib.GroupTheory.Congruence.Basic
import Mathlib.GroupTheory.FreeGroup.IsFreeGroup
import Mathlib.SetTheory.Cardinal.Basic
import Mathlib.Data.Set.Pointwise.SMul
import Mathlib.GroupTheory.CoprodI
open Set
open Word
| import Init
import Mathlib.Algebra.Group.Submonoid.Membership
import Mathlib.GroupTheory.Congruence.Basic
import Mathlib.GroupTheory.FreeGroup.IsFreeGroup
import Mathlib.SetTheory.Cardinal.Basic
import Mathlib.Data.Set.Pointwise.SMul
import Mathlib.GroupTheory.CoprodI
| open Set
open Word
| lemma of_word_tac_26830 [(i : ι) → Monoid (M i)] (i : ι) (j : ι) (w : NeWord M i j) (h : w.toWord.toList = w✝.toList) : a✝ ∈ w✝.toList[n✝]? ↔ a✝ ∈ w✝.toList[n✝]? := sorry | lemma of_word_tac_26830 {ι : Type*} {M : Type*} [(i : ι) → Monoid (M i)] (w✝ : Word M) (h✝ : w✝ ≠ empty) (i : ι) (j : ι) (w : NeWord M i j) (h : w.toWord.toList = w✝.toList) (n✝ : ℕ) (a✝ : (i : ι) × M i) : a✝ ∈ w✝.toList[n✝]? ↔ a✝ ∈ w✝.toList[n✝]? := sorry | tactic | ['Mathlib', 'GroupTheory', 'CoprodI'] | null | leanprover/lean4:v4.11.0
| Mathlib | false | {"messages":
[{"severity": "error",
"pos": {"line": 9, "column": 5},
"endPos": {"line": 9, "column": 9},
"data": "unknown namespace 'Word'"},
{"severity": "error",
"pos": {"line": 11, "column": 75},
"endPos": null,
"data": "expected token"}],
"env": 0}
|
|||||||||
Subgroup.instMulActionQuotientDiff_tac_3011 | import Init
import Mathlib.GroupTheory.Transfer
import Mathlib.GroupTheory.SchurZassenhaus
open MulOpposite MulAction Subgroup.leftTransversals MemLeftTransversals
| import Init
import Mathlib.GroupTheory.Transfer
import Mathlib.GroupTheory.SchurZassenhaus
| open MulOpposite MulAction Subgroup.leftTransversals MemLeftTransversals
| lemma instMulActionQuotientDiff_tac_3011 [Group G] (H : Subgroup G) [H.IsCommutative] [H.FiniteIndex] (α : ↑(leftTransversals ↑H)) (β : ↑(leftTransversals ↑H)) [H.Normal] (q : H.QuotientDiff) (T : ↑(leftTransversals ↑H)) : (fun α => op 1⁻¹ • α) T = T := sorry | lemma instMulActionQuotientDiff_tac_3011 {G : Type*} [Group G] (H : Subgroup G) [H.IsCommutative] [H.FiniteIndex] (α : ↑(leftTransversals ↑H)) (β : ↑(leftTransversals ↑H)) [H.Normal] (q : H.QuotientDiff) (T : ↑(leftTransversals ↑H)) : (fun α => op 1⁻¹ • α) T = T := sorry | [['inv_one']] | tactic | ['Mathlib', 'GroupTheory', 'SchurZassenhaus'] | null | leanprover/lean4:v4.11.0
| Mathlib | false | {"sorries":
[{"proofState": 0,
"pos": {"line": 6, "column": 266},
"goal":
"x✝¹ : Sort u_2\nleftTransversals : x✝¹\nx✝ : Sort u_3\nop : x✝\nG : Type u_1\ninst✝³ : Group G\nH : Subgroup G\ninst✝² : H.IsCommutative\ninst✝¹ : H.FiniteIndex\nα : sorryAx (Sort u_4) true\nβ : sorryAx (Sort u_5) true\ninst✝ : H.Normal\nq : H.QuotientDiff\nT : sorryAx (Type u_6) true\n⊢ (fun α_1 => ?m.2111 H α β q T α_1 • α_1) T = T",
"endPos": {"line": 6, "column": 271}}],
"messages":
[{"severity": "error",
"pos": {"line": 4, "column": 53},
"endPos": {"line": 4, "column": 72},
"data": "unknown namespace 'MemLeftTransversals'"},
{"severity": "error",
"pos": {"line": 6, "column": 121},
"endPos": {"line": 6, "column": 140},
"data": "function expected at\n leftTransversals\nterm has type\n ?m.37"},
{"severity": "error",
"pos": {"line": 6, "column": 150},
"endPos": {"line": 6, "column": 169},
"data": "function expected at\n leftTransversals\nterm has type\n ?m.37"},
{"severity": "error",
"pos": {"line": 6, "column": 211},
"endPos": {"line": 6, "column": 230},
"data": "function expected at\n leftTransversals\nterm has type\n ?m.37"},
{"severity": "error",
"pos": {"line": 6, "column": 245},
"endPos": {"line": 6, "column": 251},
"data": "function expected at\n op\nterm has type\n ?m.133"}],
"env": 0}
|
||||||||
FreeGroup.instLawfulMonad_tac_33581 | import Init
import Mathlib.Algebra.Group.Subgroup.Basic
import Mathlib.Data.Fintype.Basic
import Mathlib.Data.List.Sublists
import Mathlib.Data.List.InsertNth
import Mathlib.GroupTheory.FreeGroup.Basic
open Relation
open List -- for <+ notation
| import Init
import Mathlib.Algebra.Group.Subgroup.Basic
import Mathlib.Data.Fintype.Basic
import Mathlib.Data.List.Sublists
import Mathlib.Data.List.InsertNth
import Mathlib.GroupTheory.FreeGroup.Basic
| open Relation
open List -- for <+ notation
| lemma instLawfulMonad_tac_33581 (L : List (α × Bool)) (L₁ : List (α × Bool)) (L₂ : List (α × Bool)) (L₃ : List (α × Bool)) (L₄ : List (α × Bool)) (x : α✝) (ih : id <$> pure x = pure x) : id <$> (pure x)⁻¹ = (pure x)⁻¹ := sorry | lemma instLawfulMonad_tac_33581 {α : Type*} (L : List (α × Bool)) (L₁ : List (α × Bool)) (L₂ : List (α × Bool)) (L₃ : List (α × Bool)) (L₄ : List (α × Bool)) {β : Type*} {α✝ : Type*} (x✝ : FreeGroup α✝) (x : α✝) (ih : id <$> pure x = pure x) : id <$> (pure x)⁻¹ = (pure x)⁻¹ := sorry | [['map_inv'], ['ih']] | tactic | ['Mathlib', 'GroupTheory', 'FreeGroup', 'Basic'] | null | leanprover/lean4:v4.11.0
| Mathlib | false | {"messages":
[{"severity": "error",
"pos": {"line": 10, "column": 172},
"endPos": null,
"data": "expected token"}],
"env": 0}
|
||||||||
MulAction.mem_stabilizer_of_finite_iff_smul_le_tac_28985 | import Init
import Mathlib.Algebra.Group.Subgroup.Basic
import Mathlib.Algebra.GroupWithZero.Action.Defs
import Mathlib.Data.Fintype.Card
import Mathlib.Data.Set.Finite
import Mathlib.Data.Set.Pointwise.SMul
import Mathlib.Data.Setoid.Basic
import Mathlib.GroupTheory.GroupAction.Basic
open Pointwise
open Function
| import Init
import Mathlib.Algebra.Group.Subgroup.Basic
import Mathlib.Algebra.GroupWithZero.Action.Defs
import Mathlib.Data.Fintype.Card
import Mathlib.Data.Set.Finite
import Mathlib.Data.Set.Pointwise.SMul
import Mathlib.Data.Setoid.Basic
import Mathlib.GroupTheory.GroupAction.Basic
| open Pointwise
open Function
| lemma mem_stabilizer_of_finite_iff_smul_le_tac_28985 [Group G] [MulAction G α] (s : Set α) (hs : s.Finite) (g : G) (h : (g • s).toFinset ⊆ s.toFinset) (this : (g • s).toFinset = Finset.map { toFun := fun x => g • x, inj' := ⋯ } hs.toFinset) : s.toFinset.card = s.toFinset.card := sorry | lemma mem_stabilizer_of_finite_iff_smul_le_tac_28985 {G : Type*} [Group G] {α : Type*} [MulAction G α] (s : Set α) (hs : s.Finite) (g : G) {this✝¹ : Type*} {this✝ : Type*} (h : (g • s).toFinset ⊆ s.toFinset) (this : (g • s).toFinset = Finset.map { toFun := fun x => g • x, inj' := ⋯ } hs.toFinset) : s.toFinset.card = s.toFinset.card := sorry | tactic | ['Mathlib', 'GroupTheory', 'GroupAction', 'Basic'] | null | leanprover/lean4:v4.11.0
| Mathlib | null | ||||||||||
QuotientGroup.sound_tac_3186 | import Init
import Mathlib.Algebra.Group.Subgroup.Pointwise
import Mathlib.GroupTheory.Congruence.Basic
import Mathlib.GroupTheory.Coset.Basic
import Mathlib.GroupTheory.QuotientGroup.Basic
open Function
open scoped Pointwise
open scoped Pointwise in
| import Init
import Mathlib.Algebra.Group.Subgroup.Pointwise
import Mathlib.GroupTheory.Congruence.Basic
import Mathlib.GroupTheory.Coset.Basic
import Mathlib.GroupTheory.QuotientGroup.Basic
| open Function
open scoped Pointwise
open scoped Pointwise in
| lemma sound_tac_3186 [Group G] (N : Subgroup G) (nN : N.Normal) (U : Set (G ⧸ N)) (g : ↥N.op) : g • ⇑(mk' N) ⁻¹' U = ⇑(mk' N) ⁻¹' U := sorry | lemma sound_tac_3186 {G : Type*} [Group G] (N : Subgroup G) (nN : N.Normal) (U : Set (G ⧸ N)) (g : ↥N.op) : g • ⇑(mk' N) ⁻¹' U = ⇑(mk' N) ⁻¹' U := sorry | [['x'], ['Set', 'mem_preimage'], ['Set', 'mem_smul_set_iff_inv_smul_mem'], ['rfl'], ['g'], ['Quotient', 'sound']] | tactic | ['Mathlib', 'GroupTheory', 'QuotientGroup', 'Basic'] | null | leanprover/lean4:v4.11.0
| Mathlib | null | |||||||||
Equiv.Perm.disjoint_prod_right_tac_3734 | import Init
import Mathlib.Algebra.Group.Commute.Basic
import Mathlib.Data.Fintype.Card
import Mathlib.GroupTheory.Perm.Basic
import Mathlib.GroupTheory.Perm.Support
open Equiv Finset
| import Init
import Mathlib.Algebra.Group.Commute.Basic
import Mathlib.Data.Fintype.Card
import Mathlib.GroupTheory.Perm.Basic
import Mathlib.GroupTheory.Perm.Support
| open Equiv Finset
| lemma disjoint_prod_right_tac_3734 (f : Perm α) (h : ∀ g ∈ [], f.Disjoint g) : f.Disjoint [].prod := sorry | lemma disjoint_prod_right_tac_3734 {α : Type*} (f : Perm α) (h : ∀ g ∈ [], f.Disjoint g) : f.Disjoint [].prod := sorry | [['disjoint_one_right']] | tactic | ['Mathlib', 'GroupTheory', 'Perm', 'Support'] | null | leanprover/lean4:v4.11.0
| Mathlib | true | {"sorries":
[{"proofState": 0,
"pos": {"line": 8, "column": 113},
"goal":
"α : Type u_1\nf : Perm α\nh : ∀ g ∈ [], f.Disjoint g\n⊢ f.Disjoint [].prod",
"endPos": {"line": 8, "column": 118}}],
"messages":
[{"severity": "warning",
"pos": {"line": 8, "column": 6},
"endPos": {"line": 8, "column": 34},
"data": "declaration uses 'sorry'"}],
"env": 0}
|
||||||||
Monoid.CoprodI.lift_tac_7061 | import Init
import Mathlib.Algebra.Group.Submonoid.Membership
import Mathlib.GroupTheory.Congruence.Basic
import Mathlib.GroupTheory.FreeGroup.IsFreeGroup
import Mathlib.SetTheory.Cardinal.Basic
import Mathlib.Data.Set.Pointwise.SMul
import Mathlib.GroupTheory.CoprodI
open Set
| import Init
import Mathlib.Algebra.Group.Submonoid.Membership
import Mathlib.GroupTheory.Congruence.Basic
import Mathlib.GroupTheory.FreeGroup.IsFreeGroup
import Mathlib.SetTheory.Cardinal.Basic
import Mathlib.Data.Set.Pointwise.SMul
import Mathlib.GroupTheory.CoprodI
| open Set
| lemma lift_tac_7061 [(i : ι) → Monoid (M i)] [Monoid N] : Function.RightInverse (fun f i => f.comp of) fun fi =>
(conGen (Rel M)).lift (FreeMonoid.lift fun p => (fi p.fst) p.snd) ⋯ := sorry | lemma lift_tac_7061 {ι : Type*} {M : Type*} [(i : ι) → Monoid (M i)] {N : Type*} [Monoid N] : Function.RightInverse (fun f i => f.comp of) fun fi =>
(conGen (Rel M)).lift (FreeMonoid.lift fun p => (fi p.fst) p.snd) ⋯ := sorry | [['x'], ['f'], ['i']] | tactic | ['Mathlib', 'GroupTheory', 'CoprodI'] | null | leanprover/lean4:v4.11.0
| Mathlib | null | |||||||||
Monoid.CoprodI.Word.mem_smul_iff_tac_21643 | import Init
import Mathlib.Algebra.Group.Submonoid.Membership
import Mathlib.GroupTheory.Congruence.Basic
import Mathlib.GroupTheory.FreeGroup.IsFreeGroup
import Mathlib.SetTheory.Cardinal.Basic
import Mathlib.Data.Set.Pointwise.SMul
import Mathlib.GroupTheory.CoprodI
open Set
| import Init
import Mathlib.Algebra.Group.Submonoid.Membership
import Mathlib.GroupTheory.Congruence.Basic
import Mathlib.GroupTheory.FreeGroup.IsFreeGroup
import Mathlib.SetTheory.Cardinal.Basic
import Mathlib.Data.Set.Pointwise.SMul
import Mathlib.GroupTheory.CoprodI
| open Set
| lemma mem_smul_iff_tac_21643 [(i : ι) → Monoid (M i)] [DecidableEq ι] [(i : ι) → DecidableEq (M i)] (j : ι) (m₂ : M j) (w : Word M) (m₁ : M j) (hw : ⟨j, m₁⟩ ∉ w.toList.tail) (hm1 : ¬m₁ = 1) : (¬∃ (h : ¬w.toList = []), (w.toList.head h).fst = j) →
(m₁ = m₂ * 1 ↔ (∃ m', w.toList.head? = some ⟨j, m'⟩ ∧ m₁ = m₂ * m') ∨ ¬w.fstIdx = some j ∧ m₁ = m₂) := sorry | lemma mem_smul_iff_tac_21643 {ι : Type*} {M : Type*} [(i : ι) → Monoid (M i)] [DecidableEq ι] [(i : ι) → DecidableEq (M i)] (j : ι) (m₂ : M j) (w : Word M) (m₁ : M j) (hw : ⟨j, m₁⟩ ∉ w.toList.tail) (hm1 : ¬m₁ = 1) : (¬∃ (h : ¬w.toList = []), (w.toList.head h).fst = j) →
(m₁ = m₂ * 1 ↔ (∃ m', w.toList.head? = some ⟨j, m'⟩ ∧ m₁ = m₂ * m') ∨ ¬w.fstIdx = some j ∧ m₁ = m₂) := sorry | tactic | ['Mathlib', 'GroupTheory', 'CoprodI'] | null | leanprover/lean4:v4.11.0
| Mathlib | null | ||||||||||
QuotientGroup.quotientRightRelEquivQuotientLeftRel_tac_11249 | import Init
import Mathlib.Algebra.Quotient
import Mathlib.Algebra.Group.Subgroup.Actions
import Mathlib.Algebra.Group.Subgroup.MulOpposite
import Mathlib.GroupTheory.GroupAction.Basic
import Mathlib.GroupTheory.Coset.Basic
open Function MulOpposite Set
open scoped Pointwise
open Submonoid
open Subgroup
| import Init
import Mathlib.Algebra.Quotient
import Mathlib.Algebra.Group.Subgroup.Actions
import Mathlib.Algebra.Group.Subgroup.MulOpposite
import Mathlib.GroupTheory.GroupAction.Basic
import Mathlib.GroupTheory.Coset.Basic
| open Function MulOpposite Set
open scoped Pointwise
open Submonoid
open Subgroup
| lemma quotientRightRelEquivQuotientLeftRel_tac_11249 [Group α] (s : Subgroup α) (a : α) (b : α) : b * a⁻¹ ∈ s → ((fun g => g⁻¹) a)⁻¹ * (fun g => g⁻¹) b ∈ s := sorry | lemma quotientRightRelEquivQuotientLeftRel_tac_11249 {α : Type*} [Group α] (s : Subgroup α) (a : α) (b : α) : b * a⁻¹ ∈ s → ((fun g => g⁻¹) a)⁻¹ * (fun g => g⁻¹) b ∈ s := sorry | tactic | ['Mathlib', 'GroupTheory', 'Coset', 'Basic'] | null | leanprover/lean4:v4.11.0
| Mathlib | true | {"sorries":
[{"proofState": 0,
"pos": {"line": 12, "column": 171},
"goal":
"α : Type u_1\ninst✝ : Group α\ns : Subgroup α\na b : α\n⊢ b * a⁻¹ ∈ s → ((fun g => g⁻¹) a)⁻¹ * (fun g => g⁻¹) b ∈ s",
"endPos": {"line": 12, "column": 176}}],
"messages":
[{"severity": "warning",
"pos": {"line": 12, "column": 6},
"endPos": {"line": 12, "column": 52},
"data": "declaration uses 'sorry'"}],
"env": 0}
|
|||||||||
List.formPerm_apply_lt_get_tac_7336 | import Init
import Mathlib.Algebra.Order.Group.Nat
import Mathlib.Data.List.Rotate
import Mathlib.GroupTheory.Perm.Support
import Mathlib.GroupTheory.Perm.List
open Equiv Equiv.Perm
| import Init
import Mathlib.Algebra.Order.Group.Nat
import Mathlib.Data.List.Rotate
import Mathlib.GroupTheory.Perm.Support
import Mathlib.GroupTheory.Perm.List
| open Equiv Equiv.Perm
| lemma formPerm_apply_lt_get_tac_7336 [DecidableEq α] (xs : List α) (h : xs.Nodup) (n : ℕ) (hn : n + 1 < xs.length) : xs.formPerm (xs.get ⟨n, ⋯⟩) = xs.get ⟨n + 1, hn⟩ := sorry | lemma formPerm_apply_lt_get_tac_7336 {α : Type*} [DecidableEq α] (xs : List α) (h : xs.Nodup) (n : ℕ) (hn : n + 1 < xs.length) : xs.formPerm (xs.get ⟨n, ⋯⟩) = xs.get ⟨n + 1, hn⟩ := sorry | [['formPerm_apply_lt_getElem']] | tactic | ['Mathlib', 'GroupTheory', 'Perm', 'List'] | null | leanprover/lean4:v4.11.0
| Mathlib | false | {"sorries":
[{"proofState": 0,
"pos": {"line": 8, "column": 181},
"goal":
"α : Type u_1\ninst✝ : DecidableEq α\nxs : List α\nh : xs.Nodup\nn : ℕ\nhn : n + 1 < xs.length\n⊢ xs.formPerm (xs.get ⟨n, ⋯⟩) = xs.get ⟨n + 1, hn⟩",
"endPos": {"line": 8, "column": 186}}],
"messages":
[{"severity": "warning",
"pos": {"line": 8, "column": 153},
"endPos": {"line": 8, "column": 154},
"data":
"The '⋯' token is used by the pretty printer to indicate omitted terms, and it should not be used directly. It logs this warning and then elaborates like `_`.\n\nThe presence of `⋯` in pretty printing output is controlled by the 'pp.deepTerms' and `pp.proofs` options. These options can be further adjusted using `pp.deepTerms.threshold` and `pp.proofs.threshold`."},
{"severity": "error",
"pos": {"line": 8, "column": 153},
"endPos": {"line": 8, "column": 154},
"data":
"don't know how to synthesize placeholder for argument 'isLt'\ncontext:\nα : Type u_1\ninst✝ : DecidableEq α\nxs : List α\nh : xs.Nodup\nn : ℕ\nhn : n + 1 < xs.length\n⊢ n < xs.length\nwhen the resulting type of a declaration is explicitly provided, all holes (e.g., `_`) in the header are resolved before the declaration body is processed"}],
"env": 0}
|
||||||||
Con.coe_iInf_tac_17952 | import Init
import Mathlib.Algebra.Group.Equiv.Basic
import Mathlib.Algebra.Group.Submonoid.Operations
import Mathlib.Algebra.GroupWithZero.Action.Defs
import Mathlib.Data.Setoid.Basic
import Mathlib.GroupTheory.Congruence.Basic
open Function Setoid
| import Init
import Mathlib.Algebra.Group.Equiv.Basic
import Mathlib.Algebra.Group.Submonoid.Operations
import Mathlib.Algebra.GroupWithZero.Action.Defs
import Mathlib.Data.Setoid.Basic
import Mathlib.GroupTheory.Congruence.Basic
| open Function Setoid
| lemma coe_iInf_tac_17952 [Mul M] (ι : Sort u_4) (f : ι → Con M) : ⨅ x, ⇑(f x) = ⨅ i, ⇑(f i) := sorry | lemma coe_iInf_tac_17952 {M : Type*} [Mul M] (ι : Sort u_4) (f : ι → Con M) : ⨅ x, ⇑(f x) = ⨅ i, ⇑(f i) := sorry | tactic | ['Mathlib', 'GroupTheory', 'Congruence', 'Basic'] | null | leanprover/lean4:v4.11.0
| Mathlib | true | {"sorries":
[{"proofState": 0,
"pos": {"line": 9, "column": 107},
"goal":
"M : Type u_1\ninst✝ : Mul M\nι : Sort u_4\nf : ι → Con M\n⊢ ⨅ x, ⇑(f x) = ⨅ i, ⇑(f i)",
"endPos": {"line": 9, "column": 112}}],
"messages":
[{"severity": "warning",
"pos": {"line": 9, "column": 6},
"endPos": {"line": 9, "column": 24},
"data": "declaration uses 'sorry'"}],
"env": 0}
|
|||||||||
Equiv.Perm.prod_list_swap_mem_alternatingGroup_iff_even_length_tac_2396 | import Init
import Mathlib.GroupTheory.Perm.Fin
import Mathlib.GroupTheory.Subgroup.Simple
import Mathlib.Tactic.IntervalCases
import Mathlib.Data.Fintype.Units
import Mathlib.GroupTheory.SpecificGroups.Alternating
open Equiv Equiv.Perm Subgroup Fintype
| import Init
import Mathlib.GroupTheory.Perm.Fin
import Mathlib.GroupTheory.Subgroup.Simple
import Mathlib.Tactic.IntervalCases
import Mathlib.Data.Fintype.Units
import Mathlib.GroupTheory.SpecificGroups.Alternating
| open Equiv Equiv.Perm Subgroup Fintype
| lemma prod_list_swap_mem_alternatingGroup_iff_even_length_tac_2396 [DecidableEq α] (l : List (Perm α)) (hl : ∀ g ∈ l, g.IsSwap) : Even l.length ↔ Even l.length := sorry | lemma prod_list_swap_mem_alternatingGroup_iff_even_length_tac_2396 {α : Type*} {inst✝¹ : Type*} [DecidableEq α] (l : List (Perm α)) (hl : ∀ g ∈ l, g.IsSwap) : Even l.length ↔ Even l.length := sorry | tactic | ['Mathlib', 'GroupTheory', 'SpecificGroups', 'Alternating'] | null | leanprover/lean4:v4.11.0
| Mathlib | false | {"messages":
[{"severity": "error",
"pos": {"line": 9, "column": 84},
"endPos": null,
"data": "expected token"}],
"env": 0}
|
|||||||||
DomMulAct.instMulOfMulOpposite_tac_4876 | import Init
import Mathlib.Algebra.Group.Opposite
import Mathlib.Algebra.Group.Pi.Lemmas
import Mathlib.Algebra.GroupWithZero.Action.Defs
import Mathlib.Algebra.Ring.Defs
import Mathlib.GroupTheory.GroupAction.DomAct.Basic
open Function
| import Init
import Mathlib.Algebra.Group.Opposite
import Mathlib.Algebra.Group.Pi.Lemmas
import Mathlib.Algebra.GroupWithZero.Action.Defs
import Mathlib.Algebra.Ring.Defs
import Mathlib.GroupTheory.GroupAction.DomAct.Basic
| open Function
| lemma instMulOfMulOpposite_tac_4876 [MulOneClass Mᵐᵒᵖ] : MulOneClass Mᵈᵐᵃ := sorry | lemma instMulOfMulOpposite_tac_4876 {M : Type*} [MulOneClass Mᵐᵒᵖ] : MulOneClass Mᵈᵐᵃ := sorry | tactic | ['Mathlib', 'GroupTheory', 'GroupAction', 'DomAct', 'Basic'] | null | leanprover/lean4:v4.11.0
| Mathlib | false | {"sorries":
[{"proofState": 0,
"pos": {"line": 9, "column": 89},
"goal": "M : Type u_1\ninst✝ : MulOneClass Mᵐᵒᵖ\n⊢ MulOneClass Mᵈᵐᵃ",
"endPos": {"line": 9, "column": 94}}],
"messages":
[{"severity": "error",
"pos": {"line": 9, "column": 0},
"endPos": {"line": 9, "column": 94},
"data":
"type of theorem 'instMulOfMulOpposite_tac_4876' is not a proposition\n {M : Type u_1} → [inst : MulOneClass Mᵐᵒᵖ] → MulOneClass Mᵈᵐᵃ"}],
"env": 0}
|
|||||||||
Con.list_prod_tac_759 | import Init
import Mathlib.GroupTheory.Congruence.Basic
import Mathlib.Algebra.BigOperators.Group.Finset
import Mathlib.Algebra.BigOperators.Group.Multiset
import Mathlib.Algebra.BigOperators.Group.List
import Mathlib.GroupTheory.Congruence.BigOperators
| import Init
import Mathlib.GroupTheory.Congruence.Basic
import Mathlib.Algebra.BigOperators.Group.Finset
import Mathlib.Algebra.BigOperators.Group.Multiset
import Mathlib.Algebra.BigOperators.Group.List
import Mathlib.GroupTheory.Congruence.BigOperators
| lemma list_prod_tac_759 [Monoid M] (c : Con M) (l : List ι) (f : ι → M) (g : ι → M) (h : ∀ x ∈ l, c (f x) (g x)) : c (List.map f l).prod (List.map g l).prod := sorry | lemma list_prod_tac_759 {ι : Type*} {M : Type*} [Monoid M] (c : Con M) (l : List ι) (f : ι → M) (g : ι → M) (h : ∀ x ∈ l, c (f x) (g x)) : c (List.map f l).prod (List.map g l).prod := sorry | tactic | ['Mathlib', 'GroupTheory', 'Congruence', 'BigOperators'] | null | leanprover/lean4:v4.11.0
| Mathlib | true | {"sorries":
[{"proofState": 0,
"pos": {"line": 9, "column": 184},
"goal":
"ι : Type u_1\nM : Type u_2\ninst✝ : Monoid M\nc : Con M\nl : List ι\nf g : ι → M\nh : ∀ x ∈ l, c (f x) (g x)\n⊢ c (List.map f l).prod (List.map g l).prod",
"endPos": {"line": 9, "column": 189}}],
"messages":
[{"severity": "warning",
"pos": {"line": 9, "column": 6},
"endPos": {"line": 9, "column": 23},
"data": "declaration uses 'sorry'"}],
"env": 0}
|
||||||||||
Monoid.CoprodI.NeWord.of_word_tac_26830 | import Init
import Mathlib.Algebra.Group.Submonoid.Membership
import Mathlib.GroupTheory.Congruence.Basic
import Mathlib.GroupTheory.FreeGroup.IsFreeGroup
import Mathlib.SetTheory.Cardinal.Basic
import Mathlib.Data.Set.Pointwise.SMul
import Mathlib.GroupTheory.CoprodI
open Set
open Word
| import Init
import Mathlib.Algebra.Group.Submonoid.Membership
import Mathlib.GroupTheory.Congruence.Basic
import Mathlib.GroupTheory.FreeGroup.IsFreeGroup
import Mathlib.SetTheory.Cardinal.Basic
import Mathlib.Data.Set.Pointwise.SMul
import Mathlib.GroupTheory.CoprodI
| open Set
open Word
| lemma of_word_tac_26830 [(i : ι) → Monoid (M i)] (i : ι) (j : ι) (w : NeWord M i j) (h : w.toWord.toList = w✝.toList) : a✝ ∈ w✝.toList[n✝]? ↔ a✝ ∈ w✝.toList[n✝]? := sorry | lemma of_word_tac_26830 {ι : Type*} {M : Type*} [(i : ι) → Monoid (M i)] (w✝ : Word M) (h✝ : w✝ ≠ empty) (i : ι) (j : ι) (w : NeWord M i j) (h : w.toWord.toList = w✝.toList) (n✝ : ℕ) (a✝ : (i : ι) × M i) : a✝ ∈ w✝.toList[n✝]? ↔ a✝ ∈ w✝.toList[n✝]? := sorry | tactic | ['Mathlib', 'GroupTheory', 'CoprodI'] | null | leanprover/lean4:v4.11.0
| Mathlib | false | {"messages":
[{"severity": "error",
"pos": {"line": 9, "column": 5},
"endPos": {"line": 9, "column": 9},
"data": "unknown namespace 'Word'"},
{"severity": "error",
"pos": {"line": 11, "column": 75},
"endPos": null,
"data": "expected token"}],
"env": 0}
|
|||||||||
FreeAbelianGroup.toFinsupp_toFreeAbelianGroup_tac_3133 | import Init
import Mathlib.Algebra.Group.Equiv.TypeTags
import Mathlib.GroupTheory.FreeAbelianGroup
import Mathlib.GroupTheory.FreeGroup.IsFreeGroup
import Mathlib.LinearAlgebra.Dimension.StrongRankCondition
import Mathlib.GroupTheory.FreeAbelianGroupFinsupp
open Finsupp FreeAbelianGroup
open Finsupp
| import Init
import Mathlib.Algebra.Group.Equiv.TypeTags
import Mathlib.GroupTheory.FreeAbelianGroup
import Mathlib.GroupTheory.FreeGroup.IsFreeGroup
import Mathlib.LinearAlgebra.Dimension.StrongRankCondition
import Mathlib.GroupTheory.FreeAbelianGroupFinsupp
| open Finsupp FreeAbelianGroup
open Finsupp
| lemma toFinsupp_toFreeAbelianGroup_tac_3133 (f : X →₀ ℤ) : f = f := sorry | lemma toFinsupp_toFreeAbelianGroup_tac_3133 {X : Type*} (f : X →₀ ℤ) : f = f := sorry | tactic | ['Mathlib', 'GroupTheory', 'FreeAbelianGroupFinsupp'] | null | leanprover/lean4:v4.11.0
| Mathlib | true | {"sorries":
[{"proofState": 0,
"pos": {"line": 10, "column": 80},
"goal": "X : Type u_1\nf : X →₀ ℤ\n⊢ f = f",
"endPos": {"line": 10, "column": 85}}],
"messages":
[{"severity": "warning",
"pos": {"line": 10, "column": 6},
"endPos": {"line": 10, "column": 43},
"data": "declaration uses 'sorry'"}],
"env": 0}
|
|||||||||
MulAction.quotient_preimage_image_eq_union_mul_tac_12971 | import Init
import Mathlib.Algebra.Group.Subgroup.Basic
import Mathlib.Algebra.GroupWithZero.Action.Defs
import Mathlib.Data.Fintype.Card
import Mathlib.Data.Set.Finite
import Mathlib.Data.Set.Pointwise.SMul
import Mathlib.Data.Setoid.Basic
import Mathlib.GroupTheory.GroupAction.Basic
open Pointwise
open Function
| import Init
import Mathlib.Algebra.Group.Subgroup.Basic
import Mathlib.Algebra.GroupWithZero.Action.Defs
import Mathlib.Data.Fintype.Card
import Mathlib.Data.Set.Finite
import Mathlib.Data.Set.Pointwise.SMul
import Mathlib.Data.Setoid.Basic
import Mathlib.GroupTheory.GroupAction.Basic
| open Pointwise
open Function
| lemma quotient_preimage_image_eq_union_mul_tac_12971 [Group G] [MulAction G α] (U : Set α) (this : Setoid α) (f : α → Quotient (orbitRel G α)) (a : α) (g : G) (hb : (fun m => m • a) g ∈ U) (hab : f ((fun m => m • a) g) = f a) : a ∈ ⋃ g, (fun x => g • x) '' U := sorry | lemma quotient_preimage_image_eq_union_mul_tac_12971 {G : Type*} {α : Type*} [Group G] [MulAction G α] (U : Set α) (this : Setoid α) (f : α → Quotient (orbitRel G α)) (a : α) (g : G) (hb : (fun m => m • a) g ∈ U) (hab : f ((fun m => m • a) g) = f a) : a ∈ ⋃ g, (fun x => g • x) '' U := sorry | [['Set', 'mem_iUnion']] | tactic | ['Mathlib', 'GroupTheory', 'GroupAction', 'Basic'] | null | leanprover/lean4:v4.11.0
| Mathlib | false | {"sorries":
[{"proofState": 0,
"pos": {"line": 12, "column": 284},
"goal":
"x✝ : Sort u_3\norbitRel : x✝\nG : Type u_1\nα : Type u_2\ninst✝¹ : Group G\ninst✝ : MulAction G α\nU : Set α\nthis : Setoid α\nf : α → Quotient (sorryAx (Setoid (?m.1438 U this)) true)\na : α\ng : G\nhb : (fun m => m • a) g ∈ U\nhab : f ((fun m => m • a) g) = f a\n⊢ a ∈ ⋃ g_1, (fun x => g_1 • x) U",
"endPos": {"line": 12, "column": 289}}],
"messages":
[{"severity": "error",
"pos": {"line": 12, "column": 152},
"endPos": {"line": 12, "column": 164},
"data": "function expected at\n orbitRel\nterm has type\n ?m.117"}],
"env": 0}
|
||||||||
List.isCycle_formPerm_tac_2862 | import Init
import Mathlib.Data.List.Cycle
import Mathlib.GroupTheory.Perm.Cycle.Type
import Mathlib.GroupTheory.Perm.List
import Mathlib.GroupTheory.Perm.Cycle.Concrete
open Equiv Equiv.Perm List
| import Init
import Mathlib.Data.List.Cycle
import Mathlib.GroupTheory.Perm.Cycle.Type
import Mathlib.GroupTheory.Perm.List
import Mathlib.GroupTheory.Perm.Cycle.Concrete
| open Equiv Equiv.Perm List
| lemma isCycle_formPerm_tac_2862 [DecidableEq α] (y : α) (l : List α) (x : α) (hl : (x :: y :: l).Nodup) (hn : 2 ≤ (x :: y :: l).length) (w : α) (hw : (x :: y :: l).formPerm w ≠ w) : (x :: y :: l).formPerm.SameCycle x w := sorry | lemma isCycle_formPerm_tac_2862 {α : Type*} [DecidableEq α] (y : α) (l : List α) (tail_ih✝ : ∀ (x : α), (x :: l).Nodup → 2 ≤ (x :: l).length → (x :: l).formPerm.IsCycle) (x : α) (hl : (x :: y :: l).Nodup) (hn : 2 ≤ (x :: y :: l).length) (w : α) (hw : (x :: y :: l).formPerm w ≠ w) : (x :: y :: l).formPerm.SameCycle x w := sorry | [['mem_of_formPerm_ne_self'], ['x'], ['hw'], ['y'], [], ['l'], ['w']] | tactic | ['Mathlib', 'GroupTheory', 'Perm', 'Cycle', 'Concrete'] | null | leanprover/lean4:v4.11.0
| Mathlib | false | {"messages":
[{"severity": "error",
"pos": {"line": 8, "column": 89},
"endPos": null,
"data": "expected token"}],
"env": 0}
|
||||||||
CoxeterSystem.prod_alternatingWord_eq_prod_alternatingWord_sub_tac_19833 | import Init
import Mathlib.Algebra.Ring.Int
import Mathlib.GroupTheory.PresentedGroup
import Mathlib.GroupTheory.Coxeter.Matrix
import Mathlib.Tactic.Ring
import Mathlib.Tactic.Use
import Mathlib.Tactic.NormNum.DivMod
import Mathlib.GroupTheory.Coxeter.Basic
open Function Set List
open CoxeterMatrix
| import Init
import Mathlib.Algebra.Ring.Int
import Mathlib.GroupTheory.PresentedGroup
import Mathlib.GroupTheory.Coxeter.Matrix
import Mathlib.Tactic.Ring
import Mathlib.Tactic.Use
import Mathlib.Tactic.NormNum.DivMod
import Mathlib.GroupTheory.Coxeter.Basic
| open Function Set List
open CoxeterMatrix
| lemma prod_alternatingWord_eq_prod_alternatingWord_sub_tac_19833 [Group W] (M : CoxeterMatrix B) (cs : CoxeterSystem M W) (i : B) (i' : B) (m : ℕ) (k : ℤ) (this : ¬Even (↑(M.M i i') * 2 - (2 * k + 1))) : cs.simple i' * (cs.simple i * cs.simple i') ^ ((2 * k + 1) / 2) =
cs.simple i * (cs.simple i' * cs.simple i) ^ ((↑(M.M i i') * 2 - (2 * k + 1)) / 2) := sorry | lemma prod_alternatingWord_eq_prod_alternatingWord_sub_tac_19833 {B : Type*} {W : Type*} [Group W] (M : CoxeterMatrix B) (cs : CoxeterSystem M W) (i : B) (i' : B) (m : ℕ) (k : ℤ) (this✝ : ¬Even (2 * k + 1)) (this : ¬Even (↑(M.M i i') * 2 - (2 * k + 1))) : cs.simple i' * (cs.simple i * cs.simple i') ^ ((2 * k + 1) / 2) =
cs.simple i * (cs.simple i' * cs.simple i) ^ ((↑(M.M i i') * 2 - (2 * k + 1)) / 2) := sorry | tactic | ['Mathlib', 'GroupTheory', 'Coxeter', 'Basic'] | null | leanprover/lean4:v4.11.0
| Mathlib | null | ||||||||||
Submonoid.LocalizationMap.subsingleton_tac_1368 | import Init
import Mathlib.Algebra.Regular.Basic
import Mathlib.GroupTheory.MonoidLocalization.Basic
import Mathlib.GroupTheory.MonoidLocalization.MonoidWithZero
open Function
| import Init
import Mathlib.Algebra.Regular.Basic
import Mathlib.GroupTheory.MonoidLocalization.Basic
import Mathlib.GroupTheory.MonoidLocalization.MonoidWithZero
| open Function
| lemma subsingleton_tac_1368 [CommMonoidWithZero M] (S : Submonoid M) [CommMonoidWithZero N] (f : S.LocalizationMap N) (h : 0 ∈ S) (a : N) (b : N) : ∃ c, ↑c * (↑(f.sec b).2 * (f.sec a).1) = ↑c * (↑(f.sec a).2 * (f.sec b).1) := sorry | lemma subsingleton_tac_1368 {M : Type*} [CommMonoidWithZero M] (S : Submonoid M) {N : Type*} [CommMonoidWithZero N] (f : S.LocalizationMap N) (h : 0 ∈ S) (a : N) (b : N) : ∃ c, ↑c * (↑(f.sec b).2 * (f.sec a).1) = ↑c * (↑(f.sec a).2 * (f.sec b).1) := sorry | tactic | ['Mathlib', 'GroupTheory', 'MonoidLocalization', 'MonoidWithZero'] | null | leanprover/lean4:v4.11.0
| Mathlib | true | {"sorries":
[{"proofState": 0,
"pos": {"line": 7, "column": 250},
"goal":
"M : Type u_1\ninst✝¹ : CommMonoidWithZero M\nS : Submonoid M\nN : Type u_2\ninst✝ : CommMonoidWithZero N\nf : S.LocalizationMap N\nh : 0 ∈ S\na b : N\n⊢ ∃ c, c * (↑(f.sec b).2 * (f.sec a).1) = c * (↑(f.sec a).2 * (f.sec b).1)",
"endPos": {"line": 7, "column": 255}}],
"messages":
[{"severity": "warning",
"pos": {"line": 7, "column": 6},
"endPos": {"line": 7, "column": 27},
"data": "declaration uses 'sorry'"}],
"env": 0}
|
|||||||||
HNNExtension.NormalWord.unitsSMulGroup_snd_tac_14178 | import Init
import Mathlib.GroupTheory.Coprod.Basic
import Mathlib.GroupTheory.Complement
import Mathlib.GroupTheory.HNNExtension
open Monoid Coprod Multiplicative Subgroup Function
| import Init
import Mathlib.GroupTheory.Coprod.Basic
import Mathlib.GroupTheory.Complement
import Mathlib.GroupTheory.HNNExtension
| open Monoid Coprod Multiplicative Subgroup Function
| lemma unitsSMulGroup_snd_tac_14178 [Group G] (A : Subgroup G) (B : Subgroup G) (φ : ↥A ≃* ↥B) (d : TransversalPair G A B) (u : ℤˣ) (g : G) : (unitsSMulGroup φ d u g).2 = (⋯.equiv g).2 := sorry | lemma unitsSMulGroup_snd_tac_14178 {G : Type*} [Group G] (A : Subgroup G) (B : Subgroup G) (φ : ↥A ≃* ↥B) (d : TransversalPair G A B) (u : ℤˣ) (g : G) : (unitsSMulGroup φ d u g).2 = (⋯.equiv g).2 := sorry | tactic | ['Mathlib', 'GroupTheory', 'HNNExtension'] | null | leanprover/lean4:v4.11.0
| Mathlib | false | {"sorries":
[{"proofState": 0,
"pos": {"line": 7, "column": 199},
"goal":
"x✝¹ : Sort u_2\nTransversalPair : x✝¹\nx✝ : Sort u_3\nunitsSMulGroup : x✝\nG : Type u_1\ninst✝ : Group G\nA B : Subgroup G\nφ : ↥A ≃* ↥B\nd : sorryAx (Sort u_4) true\nu : ℤˣ\ng : G\n⊢ sorryAx (?m.627 A B φ d u g) true = sorryAx (?m.627 A B φ d u g) true",
"endPos": {"line": 7, "column": 204}}],
"messages":
[{"severity": "error",
"pos": {"line": 7, "column": 111},
"endPos": {"line": 7, "column": 132},
"data": "function expected at\n TransversalPair\nterm has type\n ?m.157"},
{"severity": "error",
"pos": {"line": 7, "column": 154},
"endPos": {"line": 7, "column": 176},
"data": "function expected at\n unitsSMulGroup\nterm has type\n ?m.290"},
{"severity": "warning",
"pos": {"line": 7, "column": 183},
"endPos": {"line": 7, "column": 184},
"data":
"The '⋯' token is used by the pretty printer to indicate omitted terms, and it should not be used directly. It logs this warning and then elaborates like `_`.\n\nThe presence of `⋯` in pretty printing output is controlled by the 'pp.deepTerms' and `pp.proofs` options. These options can be further adjusted using `pp.deepTerms.threshold` and `pp.proofs.threshold`."},
{"severity": "error",
"pos": {"line": 7, "column": 183},
"endPos": {"line": 7, "column": 192},
"data":
"invalid field notation, type is not of the form (C ...) where C is a constant\n ?m.622\nhas type\n ?m.621"}],
"env": 0}
|
|||||||||
Equiv.Perm.perm_mapsTo_inl_iff_mapsTo_inr_tac_4186 | import Init
import Mathlib.Data.Finset.Fin
import Mathlib.Data.Int.Order.Units
import Mathlib.GroupTheory.OrderOfElement
import Mathlib.GroupTheory.Perm.Support
import Mathlib.Logic.Equiv.Fintype
import Mathlib.GroupTheory.Perm.Finite
open Equiv Function Fintype Finset
| import Init
import Mathlib.Data.Finset.Fin
import Mathlib.Data.Int.Order.Units
import Mathlib.GroupTheory.OrderOfElement
import Mathlib.GroupTheory.Perm.Support
import Mathlib.Logic.Equiv.Fintype
import Mathlib.GroupTheory.Perm.Finite
| open Equiv Function Fintype Finset
| lemma perm_mapsTo_inl_iff_mapsTo_inr_tac_4186 [Finite m] [Finite n] (σ : Perm (m ⊕ n)) (h : Set.MapsTo (⇑σ⁻¹) (Set.range Sum.inr) (Set.range Sum.inr)) : Set.MapsTo (⇑σ) (Set.range Sum.inl) (Set.range Sum.inl) := sorry | lemma perm_mapsTo_inl_iff_mapsTo_inr_tac_4186 {m : Type*} {n : Type*} [Finite m] [Finite n] (σ : Perm (m ⊕ n)) (h : Set.MapsTo (⇑σ⁻¹) (Set.range Sum.inr) (Set.range Sum.inr)) : Set.MapsTo (⇑σ) (Set.range Sum.inl) (Set.range Sum.inl) := sorry | tactic | ['Mathlib', 'GroupTheory', 'Perm', 'Finite'] | null | leanprover/lean4:v4.11.0
| Mathlib | true | {"sorries":
[{"proofState": 0,
"pos": {"line": 10, "column": 236},
"goal":
"m : Type u_1\nn : Type u_2\ninst✝¹ : Finite m\ninst✝ : Finite n\nσ : Perm (m ⊕ n)\nh : Set.MapsTo (⇑σ⁻¹) (Set.range Sum.inr) (Set.range Sum.inr)\n⊢ Set.MapsTo (⇑σ) (Set.range Sum.inl) (Set.range Sum.inl)",
"endPos": {"line": 10, "column": 241}}],
"messages":
[{"severity": "warning",
"pos": {"line": 10, "column": 6},
"endPos": {"line": 10, "column": 45},
"data": "declaration uses 'sorry'"}],
"env": 0}
|
|||||||||
Equiv.Perm.closure_cycle_adjacent_swap_tac_1268 | import Init
import Mathlib.GroupTheory.Perm.Cycle.Basic
import Mathlib.GroupTheory.Perm.Closure
open Equiv Function Finset
open Subgroup
| import Init
import Mathlib.GroupTheory.Perm.Cycle.Basic
import Mathlib.GroupTheory.Perm.Closure
| open Equiv Function Finset
open Subgroup
| lemma closure_cycle_adjacent_swap_tac_1268 [DecidableEq α] (σ : Perm α) (h1 : σ.IsCycle) (h2 : σ.support = ⊤) (x : α) : closure {σ, swap x (σ x)} = ⊤ := sorry | lemma closure_cycle_adjacent_swap_tac_1268 {α : Type*} [DecidableEq α] {inst✝ : Type*} (σ : Perm α) (h1 : σ.IsCycle) (h2 : σ.support = ⊤) (x : α) : closure {σ, swap x (σ x)} = ⊤ := sorry | [['closure'], ['H'], ['swap'], ['x'], ['α'], ['Set'], ['σ'], ['Perm']] | tactic | ['Mathlib', 'GroupTheory', 'Perm', 'Closure'] | null | leanprover/lean4:v4.11.0
| Mathlib | false | {"messages":
[{"severity": "error",
"pos": {"line": 7, "column": 76},
"endPos": null,
"data": "expected token"}],
"env": 0}
|
||||||||
List.formPerm_apply_lt_getElem_tac_6944 | import Init
import Mathlib.Algebra.Order.Group.Nat
import Mathlib.Data.List.Rotate
import Mathlib.GroupTheory.Perm.Support
import Mathlib.GroupTheory.Perm.List
open Equiv Equiv.Perm
| import Init
import Mathlib.Algebra.Order.Group.Nat
import Mathlib.Data.List.Rotate
import Mathlib.GroupTheory.Perm.Support
import Mathlib.GroupTheory.Perm.List
| open Equiv Equiv.Perm
| lemma formPerm_apply_lt_getElem_tac_6944 [DecidableEq α] (n : ℕ) (x : α) (y : α) (l : List α) (h : (x :: y :: l).Nodup) (hn : n + 1 + 1 < (x :: y :: l).length) (IH : (y :: l).formPerm (y :: l)[n] = l[n]) : (y :: l).formPerm (y :: l)[n] ≠ x := sorry | lemma formPerm_apply_lt_getElem_tac_6944 {α : Type*} [DecidableEq α] (n : ℕ) (IH✝ : ∀ (xs : List α), xs.Nodup → ∀ (hn : n + 1 < xs.length), xs.formPerm xs[n] = xs[n + 1]) (x : α) (y : α) (l : List α) (h : (x :: y :: l).Nodup) (hn : n + 1 + 1 < (x :: y :: l).length) (IH : (y :: l).formPerm (y :: l)[n] = l[n]) : (y :: l).formPerm (y :: l)[n] ≠ x := sorry | [['getElem_mem'], ['h'], ['hx'], ['IH']] | tactic | ['Mathlib', 'GroupTheory', 'Perm', 'List'] | null | leanprover/lean4:v4.11.0
| Mathlib | false | {"messages":
[{"severity": "error",
"pos": {"line": 8, "column": 80},
"endPos": null,
"data": "expected token"}],
"env": 0}
|
||||||||
Con.quotientKerEquivOfRightInverse_tac_44000 | import Init
import Mathlib.Algebra.Group.Equiv.Basic
import Mathlib.Algebra.Group.Submonoid.Operations
import Mathlib.Algebra.GroupWithZero.Action.Defs
import Mathlib.Data.Setoid.Basic
import Mathlib.GroupTheory.Congruence.Basic
open Function Setoid
open Quotient
| import Init
import Mathlib.Algebra.Group.Equiv.Basic
import Mathlib.Algebra.Group.Submonoid.Operations
import Mathlib.Algebra.GroupWithZero.Action.Defs
import Mathlib.Data.Setoid.Basic
import Mathlib.GroupTheory.Congruence.Basic
| open Function Setoid
open Quotient
| lemma quotientKerEquivOfRightInverse_tac_44000 [MulOneClass M] [MulOneClass N] [MulOneClass P] (c : Con M) (y : M) (f : M →* P) (g : P → M) (hf : Function.RightInverse g ⇑f) (x : P) : x := sorry | lemma quotientKerEquivOfRightInverse_tac_44000 {M : Type*} {N : Type*} {P : Type*} [MulOneClass M] [MulOneClass N] [MulOneClass P] (c : Con M) (x✝ : M) (y : M) (f✝ : M →* P) (f : M →* P) (g : P → M) (hf : Function.RightInverse g ⇑f) (x : P) : x := sorry | [['x'], ['hf']] | tactic | ['Mathlib', 'GroupTheory', 'Congruence', 'Basic'] | null | leanprover/lean4:v4.11.0
| Mathlib | false | {"messages":
[{"severity": "error",
"pos": {"line": 10, "column": 145},
"endPos": null,
"data": "expected token"}],
"env": 0}
|
||||||||
Subgroup.commProb_subgroup_le_tac_4290 | import Init
import Mathlib.GroupTheory.Abelianization
import Mathlib.GroupTheory.GroupAction.CardCommute
import Mathlib.GroupTheory.SpecificGroups.Dihedral
import Mathlib.Tactic.FieldSimp
import Mathlib.Tactic.LinearCombination
import Mathlib.Tactic.Qify
import Mathlib.GroupTheory.CommutingProbability
open scoped Classical
open Fintype
| import Init
import Mathlib.GroupTheory.Abelianization
import Mathlib.GroupTheory.GroupAction.CardCommute
import Mathlib.GroupTheory.SpecificGroups.Dihedral
import Mathlib.Tactic.FieldSimp
import Mathlib.Tactic.LinearCombination
import Mathlib.Tactic.Qify
import Mathlib.GroupTheory.CommutingProbability
| open scoped Classical
open Fintype
| lemma commProb_subgroup_le_tac_4290 [Group G] [Finite G] (H : Subgroup G) : 0 < ↑(Nat.card ↥H) ^ 2 := sorry | lemma commProb_subgroup_le_tac_4290 {G : Type*} [Group G] [Finite G] (H : Subgroup G) : 0 < ↑(Nat.card ↥H) ^ 2 := sorry | tactic | ['Mathlib', 'GroupTheory', 'CommutingProbability'] | null | leanprover/lean4:v4.11.0
| Mathlib | true | {"sorries":
[{"proofState": 0,
"pos": {"line": 12, "column": 114},
"goal":
"G : Type u_1\ninst✝¹ : Group G\ninst✝ : Finite G\nH : Subgroup G\n⊢ 0 < Nat.card ↥H ^ 2",
"endPos": {"line": 12, "column": 119}}],
"messages":
[{"severity": "warning",
"pos": {"line": 12, "column": 6},
"endPos": {"line": 12, "column": 35},
"data": "declaration uses 'sorry'"}],
"env": 0}
|
|||||||||
HNNExtension.induction_on_tac_4814 | import Init
import Mathlib.GroupTheory.Coprod.Basic
import Mathlib.GroupTheory.Complement
import Mathlib.GroupTheory.HNNExtension
open Monoid Coprod Multiplicative Subgroup Function
| import Init
import Mathlib.GroupTheory.Coprod.Basic
import Mathlib.GroupTheory.Complement
import Mathlib.GroupTheory.HNNExtension
| open Monoid Coprod Multiplicative Subgroup Function
| lemma induction_on_tac_4814 [Group G] (A : Subgroup G) (B : Subgroup G) (φ : ↥A ≃* ↥B) (motive : HNNExtension G A B φ → Prop) (x : HNNExtension G A B φ) (of : ∀ (g : G), motive (HNNExtension.of g)) (t : motive HNNExtension.t) (mul : ∀ (x y : HNNExtension G A B φ), motive x → motive y → motive (x * y)) (inv : ∀ (x : HNNExtension G A B φ), motive x → motive x⁻¹) : 1 ∈ { carrier := setOf motive, mul_mem' := ⋯ }.carrier := sorry | lemma induction_on_tac_4814 {G : Type*} [Group G] (A : Subgroup G) (B : Subgroup G) (φ : ↥A ≃* ↥B) (motive : HNNExtension G A B φ → Prop) (x : HNNExtension G A B φ) (of : ∀ (g : G), motive (HNNExtension.of g)) (t : motive HNNExtension.t) (mul : ∀ (x y : HNNExtension G A B φ), motive x → motive y → motive (x * y)) (inv : ∀ (x : HNNExtension G A B φ), motive x → motive x⁻¹) : 1 ∈ { carrier := setOf motive, mul_mem' := ⋯ }.carrier := sorry | [['of']] | tactic | ['Mathlib', 'GroupTheory', 'HNNExtension'] | null | leanprover/lean4:v4.11.0
| Mathlib | null | |||||||||
IsCyclic.card_pow_eq_one_le_tac_12574 | import Init
import Mathlib.Algebra.Order.BigOperators.Ring.Finset
import Mathlib.Data.Nat.Totient
import Mathlib.Data.ZMod.Quotient
import Mathlib.GroupTheory.OrderOfElement
import Mathlib.GroupTheory.Subgroup.Simple
import Mathlib.Tactic.Group
import Mathlib.GroupTheory.Exponent
import Mathlib.GroupTheory.SpecificGroups.Cyclic
open Subgroup
open Finset Nat
open scoped Classical
| import Init
import Mathlib.Algebra.Order.BigOperators.Ring.Finset
import Mathlib.Data.Nat.Totient
import Mathlib.Data.ZMod.Quotient
import Mathlib.GroupTheory.OrderOfElement
import Mathlib.GroupTheory.Subgroup.Simple
import Mathlib.Tactic.Group
import Mathlib.GroupTheory.Exponent
import Mathlib.GroupTheory.SpecificGroups.Cyclic
| open Subgroup
open Finset Nat
open scoped Classical
| lemma card_pow_eq_one_le_tac_12574 [Group α] [DecidableEq α] [IsCyclic α] (n : ℕ) (hn0 : 0 < n) (g : α) (hg : ∀ (x : α), x ∈ zpowers g) (x : α) (hx : x ∈ filter (fun a => a ^ n = 1) univ) (m : ℕ) (hm : g ^ m = x) : x = x := sorry | lemma card_pow_eq_one_le_tac_12574 {α : Type*} [Group α] [DecidableEq α] {inst✝¹ : Type*} [IsCyclic α] (n : ℕ) (hn0 : 0 < n) (g : α) (hg : ∀ (x : α), x ∈ zpowers g) (x : α) (hx : x ∈ filter (fun a => a ^ n = 1) univ) (m : ℕ) (hm : g ^ m = x) {hgmn : Type*} : x = x := sorry | tactic | ['Mathlib', 'GroupTheory', 'SpecificGroups', 'Cyclic'] | null | leanprover/lean4:v4.11.0
| Mathlib | false | {"messages":
[{"severity": "error",
"pos": {"line": 14, "column": 78},
"endPos": null,
"data": "expected token"}],
"env": 0}
|
|||||||||
CoxeterSystem.not_isReduced_alternatingWord_tac_10351 | import Init
import Mathlib.Data.ZMod.Basic
import Mathlib.GroupTheory.Coxeter.Basic
import Mathlib.Tactic.Zify
import Mathlib.GroupTheory.Coxeter.Length
open List Matrix Function Classical
| import Init
import Mathlib.Data.ZMod.Basic
import Mathlib.GroupTheory.Coxeter.Basic
import Mathlib.Tactic.Zify
import Mathlib.GroupTheory.Coxeter.Length
| open List Matrix Function Classical
| lemma not_isReduced_alternatingWord_tac_10351 [Group W] (M : CoxeterMatrix B) (cs : CoxeterSystem M W) (i : B) (i' : B) (m : ℕ) (hM : M.M i i' ≠ 0) (this : M.M i i' * 2 - (M.M i i' + 1) = M.M i i' - 1) : cs.length (cs.wordProd (alternatingWord i' i (M.M i i' - 1))) < M.M i i' + 1 := sorry | lemma not_isReduced_alternatingWord_tac_10351 {B : Type*} {W : Type*} [Group W] (M : CoxeterMatrix B) (cs : CoxeterSystem M W) (i : B) (i' : B) (m : ℕ) (hM : M.M i i' ≠ 0) (this✝ : M.M i i' + 1 ≤ M.M i i' * 2) (this : M.M i i' * 2 - (M.M i i' + 1) = M.M i i' - 1) : cs.length (cs.wordProd (alternatingWord i' i (M.M i i' - 1))) < M.M i i' + 1 := sorry | tactic | ['Mathlib', 'GroupTheory', 'Coxeter', 'Length'] | null | leanprover/lean4:v4.11.0
| Mathlib | null | ||||||||||
Submonoid.LocalizationMap.lift_surjective_iff_tac_40455 | import Init
import Mathlib.Algebra.Group.Submonoid.Membership
import Mathlib.GroupTheory.Congruence.Basic
import Mathlib.RingTheory.OreLocalization.Basic
import Mathlib.GroupTheory.MonoidLocalization.Basic
open Function
| import Init
import Mathlib.Algebra.Group.Submonoid.Membership
import Mathlib.GroupTheory.Congruence.Basic
import Mathlib.RingTheory.OreLocalization.Basic
import Mathlib.GroupTheory.MonoidLocalization.Basic
| open Function
| lemma lift_surjective_iff_tac_40455 [CommMonoid M] (S : Submonoid M) [CommMonoid N] [CommMonoid P] (f : S.LocalizationMap N) (g : M →* P) (hg : ∀ (y : ↥S), IsUnit (g ↑y)) (H : ∀ (v : P), ∃ x, v * g ↑x.2 = g x.1) (v : P) (x : M × ↥S) (hx : v * g ↑x.2 = g x.1) : (f.lift hg) (f.mk' x.1 x.2) = v := sorry | lemma lift_surjective_iff_tac_40455 {M : Type*} [CommMonoid M] (S : Submonoid M) {N : Type*} [CommMonoid N] {P : Type*} [CommMonoid P] (f : S.LocalizationMap N) (g : M →* P) (hg : ∀ (y : ↥S), IsUnit (g ↑y)) (H : ∀ (v : P), ∃ x, v * g ↑x.2 = g x.1) (v : P) (x : M × ↥S) (hx : v * g ↑x.2 = g x.1) : (f.lift hg) (f.mk' x.1 x.2) = v := sorry | tactic | ['Mathlib', 'GroupTheory', 'MonoidLocalization', 'Basic'] | null | leanprover/lean4:v4.11.0
| Mathlib | null | ||||||||||
QuotientGroup.map_tac_7575 | import Init
import Mathlib.Algebra.Group.Subgroup.Pointwise
import Mathlib.GroupTheory.Congruence.Basic
import Mathlib.GroupTheory.Coset.Basic
import Mathlib.GroupTheory.QuotientGroup.Basic
open Function
open scoped Pointwise
open scoped Pointwise in
| import Init
import Mathlib.Algebra.Group.Subgroup.Pointwise
import Mathlib.GroupTheory.Congruence.Basic
import Mathlib.GroupTheory.Coset.Basic
import Mathlib.GroupTheory.QuotientGroup.Basic
| open Function
open scoped Pointwise
open scoped Pointwise in
| lemma map_tac_7575 [Group G] (N : Subgroup G) (nN : N.Normal) [Group H] [Monoid M✝] (M : Subgroup H) [M.Normal] (f : G →* H) (h : N ≤ Subgroup.comap f M) (x : G) (hx : x ∈ N) : (f x)⁻¹ * 1 ∈ M := sorry | lemma map_tac_7575 {G : Type*} [Group G] (N : Subgroup G) (nN : N.Normal) {H : Type*} [Group H] {M✝ : Type*} [Monoid M✝] (M : Subgroup H) [M.Normal] (f : G →* H) (h : N ≤ Subgroup.comap f M) (x : G) (hx : x ∈ N) : (f x)⁻¹ * 1 ∈ M := sorry | [['Subgroup', 'inv_mem_iff'], ['mul_one']] | tactic | ['Mathlib', 'GroupTheory', 'QuotientGroup', 'Basic'] | null | leanprover/lean4:v4.11.0
| Mathlib | false | {"messages":
[{"severity": "error",
"pos": {"line": 10, "column": 98},
"endPos": null,
"data": "expected token"}],
"env": 0}
|
||||||||
Submonoid.LocalizationMap.inv_unique_tac_23449 | import Init
import Mathlib.Algebra.Group.Submonoid.Membership
import Mathlib.GroupTheory.Congruence.Basic
import Mathlib.RingTheory.OreLocalization.Basic
import Mathlib.GroupTheory.MonoidLocalization.Basic
open Function
| import Init
import Mathlib.Algebra.Group.Submonoid.Membership
import Mathlib.GroupTheory.Congruence.Basic
import Mathlib.RingTheory.OreLocalization.Basic
import Mathlib.GroupTheory.MonoidLocalization.Basic
| open Function
| lemma inv_unique_tac_23449 [CommMonoid M] (S : Submonoid M) [CommMonoid N] (f : M →* N) (h : ∀ (y : ↥S), IsUnit (f ↑y)) (y : ↥S) (z : N) (H : f ↑y * z = 1) : ↑1 = f ↑y * z := sorry | lemma inv_unique_tac_23449 {M : Type*} [CommMonoid M] (S : Submonoid M) {N : Type*} [CommMonoid N] (f : M →* N) (h : ∀ (y : ↥S), IsUnit (f ↑y)) (y : ↥S) (z : N) (H : f ↑y * z = 1) : ↑1 = f ↑y * z := sorry | tactic | ['Mathlib', 'GroupTheory', 'MonoidLocalization', 'Basic'] | null | leanprover/lean4:v4.11.0
| Mathlib | true | {"sorries":
[{"proofState": 0,
"pos": {"line": 8, "column": 199},
"goal":
"M : Type u_1\ninst✝¹ : CommMonoid M\nS : Submonoid M\nN : Type u_2\ninst✝ : CommMonoid N\nf : M →* N\nh : ∀ (y : ↥S), IsUnit (f ↑y)\ny : ↥S\nz : N\nH : f ↑y * z = 1\n⊢ 1 = f ↑y * z",
"endPos": {"line": 8, "column": 204}}],
"messages":
[{"severity": "warning",
"pos": {"line": 8, "column": 6},
"endPos": {"line": 8, "column": 26},
"data": "declaration uses 'sorry'"}],
"env": 0}
|
|||||||||
Submonoid.LocalizationMap.eq'_tac_27372 | import Init
import Mathlib.Algebra.Group.Submonoid.Membership
import Mathlib.GroupTheory.Congruence.Basic
import Mathlib.RingTheory.OreLocalization.Basic
import Mathlib.GroupTheory.MonoidLocalization.Basic
open Function
| import Init
import Mathlib.Algebra.Group.Submonoid.Membership
import Mathlib.GroupTheory.Congruence.Basic
import Mathlib.RingTheory.OreLocalization.Basic
import Mathlib.GroupTheory.MonoidLocalization.Basic
| open Function
| lemma eq'_tac_27372 [CommMonoid M] (S : Submonoid M) [CommMonoid N] (f : S.LocalizationMap N) (a₁ : M) (b₁ : M) (a₂ : ↥S) (b₂ : ↥S) : f.mk' a₁ a₂ = f.mk' b₁ b₂ ↔ (Localization.r S) (a₁, a₂) (b₁, b₂) := sorry | lemma eq'_tac_27372 {M : Type*} [CommMonoid M] (S : Submonoid M) {N : Type*} [CommMonoid N] (f : S.LocalizationMap N) (a₁ : M) (b₁ : M) (a₂ : ↥S) (b₂ : ↥S) : f.mk' a₁ a₂ = f.mk' b₁ b₂ ↔ (Localization.r S) (a₁, a₂) (b₁, b₂) := sorry | [['f', 'eq'], ['Localization', 'r_iff_exists']] | tactic | ['Mathlib', 'GroupTheory', 'MonoidLocalization', 'Basic'] | null | leanprover/lean4:v4.11.0
| Mathlib | null | |||||||||
MonoidHom.noncommPiCoprod_mrange_tac_6137 | import Init
import Mathlib.GroupTheory.OrderOfElement
import Mathlib.Data.Nat.GCD.BigOperators
import Mathlib.Order.SupIndep
import Mathlib.GroupTheory.NoncommPiCoprod
| import Init
import Mathlib.GroupTheory.OrderOfElement
import Mathlib.Data.Nat.GCD.BigOperators
import Mathlib.Order.SupIndep
import Mathlib.GroupTheory.NoncommPiCoprod
| lemma noncommPiCoprod_mrange_tac_6137 [Monoid M] [(i : ι) → Monoid (N i)] (ϕ : (i : ι) → N i →* M) (hcomm : Pairwise fun i j => ∀ (x : N i) (y : N j), Commute ((ϕ i) x) ((ϕ j) y)) (this : DecidableEq ι) : mrange (noncommPiCoprod ϕ hcomm) = ⨆ i, mrange (ϕ i) := sorry | lemma noncommPiCoprod_mrange_tac_6137 {M : Type*} [Monoid M] {ι : Type*} {inst✝¹ : Type*} {N : Type*} [(i : ι) → Monoid (N i)] (ϕ : (i : ι) → N i →* M) (hcomm : Pairwise fun i j => ∀ (x : N i) (y : N j), Commute ((ϕ i) x) ((ϕ j) y)) (this : DecidableEq ι) : mrange (noncommPiCoprod ϕ hcomm) = ⨆ i, mrange (ϕ i) := sorry | tactic | ['Mathlib', 'GroupTheory', 'NoncommPiCoprod'] | null | leanprover/lean4:v4.11.0
| Mathlib | false | {"messages":
[{"severity": "error",
"pos": {"line": 8, "column": 78},
"endPos": null,
"data": "expected token"}],
"env": 0}
|
||||||||||
FreeAbelianGroup.instCommRingOfCommMonoid_tac_18750 | import Init
import Mathlib.GroupTheory.Abelianization
import Mathlib.GroupTheory.FreeGroup.Basic
import Mathlib.GroupTheory.FreeAbelianGroup
open FreeAbelianGroup
open scoped Classical
| import Init
import Mathlib.GroupTheory.Abelianization
import Mathlib.GroupTheory.FreeGroup.Basic
import Mathlib.GroupTheory.FreeAbelianGroup
| open FreeAbelianGroup
open scoped Classical
| lemma instCommRingOfCommMonoid_tac_18750 [CommMonoid α] (x : FreeAbelianGroup α) (y : FreeAbelianGroup α) (s : α) (t : α) : (lift fun x₁ => of (Mul.mul x₁ t)) (of s) = (lift fun x₂ => (lift fun x₁ => of (Mul.mul x₁ x₂)) (of t)) (of s) := sorry | lemma instCommRingOfCommMonoid_tac_18750 {α : Type*} {β : Type*} {γ : Type*} [CommMonoid α] (x : FreeAbelianGroup α) (y : FreeAbelianGroup α) (s : α) (t : α) : (lift fun x₁ => of (Mul.mul x₁ t)) (of s) = (lift fun x₂ => (lift fun x₁ => of (Mul.mul x₁ x₂)) (of t)) (of s) := sorry | [['lift', 'of']] | tactic | ['Mathlib', 'GroupTheory', 'FreeAbelianGroup'] | null | leanprover/lean4:v4.11.0
| Mathlib | true | {"sorries":
[{"proofState": 0,
"pos": {"line": 8, "column": 274},
"goal":
"α : Type u_1\nβ : Type u_2\nγ : Type u_3\ninst✝ : CommMonoid α\nx y : FreeAbelianGroup α\ns t : α\n⊢ (lift fun x₁ => of (Mul.mul x₁ t)) (of s) = (lift fun x₂ => (lift fun x₁ => of (Mul.mul x₁ x₂)) (of t)) (of s)",
"endPos": {"line": 8, "column": 279}}],
"messages":
[{"severity": "warning",
"pos": {"line": 8, "column": 6},
"endPos": {"line": 8, "column": 40},
"data": "declaration uses 'sorry'"}],
"env": 0}
|
||||||||
Subgroup.quotientEquivProdOfLE'_tac_20080 | import Init
import Mathlib.Algebra.Quotient
import Mathlib.Algebra.Group.Subgroup.Actions
import Mathlib.Algebra.Group.Subgroup.MulOpposite
import Mathlib.GroupTheory.GroupAction.Basic
import Mathlib.GroupTheory.Coset.Basic
open Function MulOpposite Set
open scoped Pointwise
open Submonoid
open Subgroup
open QuotientGroup
| import Init
import Mathlib.Algebra.Quotient
import Mathlib.Algebra.Group.Subgroup.Actions
import Mathlib.Algebra.Group.Subgroup.MulOpposite
import Mathlib.GroupTheory.GroupAction.Basic
import Mathlib.GroupTheory.Coset.Basic
| open Function MulOpposite Set
open scoped Pointwise
open Submonoid
open Subgroup
open QuotientGroup
| lemma quotientEquivProdOfLE'_tac_20080 [Group α] (s : Subgroup α) (t : Subgroup α) (h_le : s ≤ t) (f : α ⧸ t → α) (hf : Function.RightInverse f QuotientGroup.mk) (a : α) (b : ↥t) : (fun a => (Quotient.map' id ⋯ a, Quotient.map' (fun g => ⟨(f (Quotient.mk'' g))⁻¹ * g, ⋯⟩) ⋯ a))
((fun a => Quotient.map' (fun b => f a.1 * ↑b) ⋯ a.2) (Quotient.mk'' a, Quotient.mk'' b)) =
(Quotient.mk'' a, Quotient.mk'' b) := sorry | lemma quotientEquivProdOfLE'_tac_20080 {α : Type*} [Group α] (s : Subgroup α) (t : Subgroup α) (h_le : s ≤ t) (f : α ⧸ t → α) (hf : Function.RightInverse f QuotientGroup.mk) (a : α) (b : ↥t) : (fun a => (Quotient.map' id ⋯ a, Quotient.map' (fun g => ⟨(f (Quotient.mk'' g))⁻¹ * g, ⋯⟩) ⋯ a))
((fun a => Quotient.map' (fun b => f a.1 * ↑b) ⋯ a.2) (Quotient.mk'' a, Quotient.mk'' b)) =
(Quotient.mk'' a, Quotient.mk'' b) := sorry | [['trans'], ['Quotient', "mk''"], ['a'], ['key'], ['hf'], ['f'], ['QuotientGroup', 'mk_mul_of_mem'], ['b']] | tactic | ['Mathlib', 'GroupTheory', 'Coset', 'Basic'] | null | leanprover/lean4:v4.11.0
| Mathlib | null | |||||||||
Equiv.Perm.support_congr_tac_10378 | import Init
import Mathlib.Algebra.Group.Commute.Basic
import Mathlib.Data.Fintype.Card
import Mathlib.GroupTheory.Perm.Basic
import Mathlib.GroupTheory.Perm.Support
open Equiv Finset
open scoped List in
| import Init
import Mathlib.Algebra.Group.Commute.Basic
import Mathlib.Data.Fintype.Card
import Mathlib.GroupTheory.Perm.Basic
import Mathlib.GroupTheory.Perm.Support
| open Equiv Finset
open scoped List in
| lemma support_congr_tac_10378 [DecidableEq α] (f : Perm α) (g : Perm α) (h : f.support ⊆ g.support) (h' : ∀ x ∈ g.support, f x = g x) (x : α) : f x = g x := sorry | lemma support_congr_tac_10378 {α : Type*} [DecidableEq α] {inst✝ : Type*} (f : Perm α) (g : Perm α) (h : f.support ⊆ g.support) (h' : ∀ x ∈ g.support, f x = g x) (x : α) : f x = g x := sorry | [['x'], ['neg', '_@', '_hyg', 3387], ['hx'], ['pos', '_@', '_hyg', 3387], ['g', 'support']] | tactic | ['Mathlib', 'GroupTheory', 'Perm', 'Support'] | null | leanprover/lean4:v4.11.0
| Mathlib | null | |||||||||
instIsAddKleinFourProdZModOfNatNat_tac_2371 | import Init
import Mathlib.GroupTheory.SpecificGroups.Cyclic
import Mathlib.GroupTheory.SpecificGroups.Dihedral
import Mathlib.GroupTheory.SpecificGroups.KleinFour
| import Init
import Mathlib.GroupTheory.SpecificGroups.Cyclic
import Mathlib.GroupTheory.SpecificGroups.Dihedral
import Mathlib.GroupTheory.SpecificGroups.KleinFour
| lemma instIsAddKleinFourProdZModOfNatNat_tac_2371 : AddMonoid.exponent (ZMod 2 × ZMod 2) = 2 := sorry | lemma instIsAddKleinFourProdZModOfNatNat_tac_2371 : AddMonoid.exponent (ZMod 2 × ZMod 2) = 2 := sorry | [['AddMonoid', 'exponent_prod']] | tactic | ['Mathlib', 'GroupTheory', 'SpecificGroups', 'KleinFour'] | null | leanprover/lean4:v4.11.0
| Mathlib | true | {"sorries":
[{"proofState": 0,
"pos": {"line": 7, "column": 97},
"goal": "⊢ AddMonoid.exponent (ZMod 2 × ZMod 2) = 2",
"endPos": {"line": 7, "column": 102}}],
"messages":
[{"severity": "warning",
"pos": {"line": 7, "column": 6},
"endPos": {"line": 7, "column": 49},
"data": "declaration uses 'sorry'"}],
"env": 0}
|
|||||||||
HNNExtension.NormalWord.not_cancels_of_cons_hyp_tac_16303 | import Init
import Mathlib.GroupTheory.Coprod.Basic
import Mathlib.GroupTheory.Complement
import Mathlib.GroupTheory.HNNExtension
open Monoid Coprod Multiplicative Subgroup Function
| import Init
import Mathlib.GroupTheory.Coprod.Basic
import Mathlib.GroupTheory.Complement
import Mathlib.GroupTheory.HNNExtension
| open Monoid Coprod Multiplicative Subgroup Function
| lemma not_cancels_of_cons_hyp_tac_16303 [Group G] (A : Subgroup G) (B : Subgroup G) (d : TransversalPair G A B) (u : ℤˣ) (w : NormalWord d) (hw : w.head ∈ toSubgroup A B u) (x : G) (h2 : ∀ u' ∈ Option.map Prod.fst (some (-u, x)), w.head ∈ toSubgroup A B u → u = u') (hx : w.toList.head? = some (-u, x)) : False := sorry | lemma not_cancels_of_cons_hyp_tac_16303 {G : Type*} [Group G] (A : Subgroup G) (B : Subgroup G) (d : TransversalPair G A B) (u : ℤˣ) (w : NormalWord d) (hw : w.head ∈ toSubgroup A B u) (x : G) (h2 : ∀ u' ∈ Option.map Prod.fst (some (-u, x)), w.head ∈ toSubgroup A B u → u = u') (hx : w.toList.head? = some (-u, x)) : False := sorry | tactic | ['Mathlib', 'GroupTheory', 'HNNExtension'] | null | leanprover/lean4:v4.11.0
| Mathlib | null | ||||||||||
IsCyclic.card_pow_eq_one_le_tac_13075 | import Init
import Mathlib.Algebra.Order.BigOperators.Ring.Finset
import Mathlib.Data.Nat.Totient
import Mathlib.Data.ZMod.Quotient
import Mathlib.GroupTheory.OrderOfElement
import Mathlib.GroupTheory.Subgroup.Simple
import Mathlib.Tactic.Group
import Mathlib.GroupTheory.Exponent
import Mathlib.GroupTheory.SpecificGroups.Cyclic
open Subgroup
open Finset Nat
open scoped Classical
| import Init
import Mathlib.Algebra.Order.BigOperators.Ring.Finset
import Mathlib.Data.Nat.Totient
import Mathlib.Data.ZMod.Quotient
import Mathlib.GroupTheory.OrderOfElement
import Mathlib.GroupTheory.Subgroup.Simple
import Mathlib.Tactic.Group
import Mathlib.GroupTheory.Exponent
import Mathlib.GroupTheory.SpecificGroups.Cyclic
| open Subgroup
open Finset Nat
open scoped Classical
| lemma card_pow_eq_one_le_tac_13075 [Group α] [DecidableEq α] [IsCyclic α] (n : ℕ) (hn0 : 0 < n) (g : α) (hg : ∀ (x : α), x ∈ zpowers g) (m : ℕ) (hm0 : m = 0) : False := sorry | lemma card_pow_eq_one_le_tac_13075 {α : Type*} [Group α] [DecidableEq α] {inst✝¹ : Type*} [IsCyclic α] (n : ℕ) (hn0 : 0 < n) (g : α) (hg : ∀ (x : α), x ∈ zpowers g) (m : ℕ) {hm : Type*} (hm0 : m = 0) : False := sorry | tactic | ['Mathlib', 'GroupTheory', 'SpecificGroups', 'Cyclic'] | null | leanprover/lean4:v4.11.0
| Mathlib | false | {"messages":
[{"severity": "error",
"pos": {"line": 14, "column": 78},
"endPos": null,
"data": "expected token"}],
"env": 0}
|
README.md exists but content is empty.
- Downloads last month
- 32