ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Sum.traverse_eq_map_id
protected theorem traverse_eq_map_id {α β} (f : α → β) (x : σ ⊕ α) :
    Sum.traverse ((pure : _ → Id _) ∘ f) x = (pure : _ → Id _) (f <$> x) 
Arguments: {σ α β : Type u} (f : α → β) (x : σ ⊕ α)
Goal: Sum.traverse (pure ∘ f) x = pure (f <$> x)
-- Sum.map_traverse
protected theorem map_traverse {α β γ} (g : α → G β) (f : β → γ) (x : σ ⊕ α) :
    (f <$> ·) <$> Sum.traverse g x = Sum.traverse (f <$> g ·) x 
Arguments: {σ : Type u} {G : Type u → Type u} [Applicative G] [LawfulApplicative G] {α : Type u_1} {β γ : Type u} (g : α → G β) (f : β → γ) (x : σ ⊕ α)
Goal: (fun x => f <$> x) <$> Sum.traverse g x = Sum.traverse (fun x => f <$> g x) x
-- Sum.naturality
protected theorem naturality {α β} (f : α → F β) (x : σ ⊕ α) :
    η (Sum.traverse f x) = Sum.traverse (@η _ ∘ f) x 
Arguments: {σ : Type u} {F G : Type u → Type u} [Applicative F] [Applicative G] [LawfulApplicative G] [LawfulApplicative F] (η : ApplicativeTransformation F G) {α : Type u_1} {β : Type u} (f : α → F β) (x : σ ⊕ α)
Goal: (fun {α} => η.app α) (Sum.traverse f x) = Sum.traverse ((fun {α} => η.app α) ∘ f) x
-- FreeAddGroup.Red.refl
@[to_additive (attr := refl)]
theorem Red.refl : Red L L 
Arguments: {α : Type u} {L : List (α × Bool)}
Goal: FreeAddGroup.Red L L
-- FreeGroup.Red.refl
@[to_additive (attr := refl)]
theorem Red.refl : Red L L 
Arguments: {α : Type u} {L : List (α × Bool)}
Goal: FreeGroup.Red L L
-- FreeAddGroup.Red.trans
@[to_additive (attr := trans)]
theorem Red.trans : Red L₁ L₂ → Red L₂ L₃ → Red L₁ L₃ 
Arguments: {α : Type u} {L₁ L₂ L₃ : List (α × Bool)}
Goal: FreeAddGroup.Red L₁ L₂ → FreeAddGroup.Red L₂ L₃ → FreeAddGroup.Red L₁ L₃
-- FreeGroup.Red.trans
@[to_additive (attr := trans)]
theorem Red.trans : Red L₁ L₂ → Red L₂ L₃ → Red L₁ L₃ 
Arguments: {α : Type u} {L₁ L₂ L₃ : List (α × Bool)}
Goal: FreeGroup.Red L₁ L₂ → FreeGroup.Red L₂ L₃ → FreeGroup.Red L₁ L₃
-- FreeAddGroup.Red.Step.length
@[to_additive "Predicate asserting that the word `w₁` can be reduced to `w₂` in one step, i.e. there
  are words `w₃ w₄` and letter `x` such that `w₁ = w₃ + x + (-x) + w₄` and `w₂ = w₃w₄`"]
theorem Step.length : ∀ {L₁ L₂ : List (α × Bool)}, Step L₁ L₂ → L₂.length + 2 = L₁.length
  
Arguments: {α : Type u} {L₁ L₂ : List (α × Bool)}
Goal: FreeAddGroup.Red.Step L₁ L₂ → L₂.length + 2 = L₁.length
-- FreeGroup.Red.Step.length
@[to_additive "Predicate asserting that the word `w₁` can be reduced to `w₂` in one step, i.e. there
  are words `w₃ w₄` and letter `x` such that `w₁ = w₃ + x + (-x) + w₄` and `w₂ = w₃w₄`"]
theorem Step.length : ∀ {L₁ L₂ : List (α × Bool)}, Step L₁ L₂ → L₂.length + 2 = L₁.length
  
Arguments: {α : Type u} {L₁ L₂ : List (α × Bool)}
Goal: FreeGroup.Red.Step L₁ L₂ → L₂.length + 2 = L₁.length
-- FreeGroup.Red.Step.not_rev
@[to_additive (attr := simp)]
theorem Step.not_rev {x b} : Step (L₁ ++ (x, !b) :: (x, b) :: L₂) (L₁ ++ L₂) 
Arguments: {α : Type u} {L₁ L₂ : List (α × Bool)} {x : α} {b : Bool}
Goal: FreeGroup.Red.Step (L₁ ++ (x, !b) :: (x, b) :: L₂) (L₁ ++ L₂)
-- FreeAddGroup.Red.Step.not_rev
@[to_additive (attr := simp)]
theorem Step.not_rev {x b} : Step (L₁ ++ (x, !b) :: (x, b) :: L₂) (L₁ ++ L₂) 
Arguments: {α : Type u} {L₁ L₂ : List (α × Bool)} {x : α} {b : Bool}
Goal: FreeAddGroup.Red.Step (L₁ ++ (x, !b) :: (x, b) :: L₂) (L₁ ++ L₂)
-- FreeGroup.Red.Step.cons_not
@[to_additive (attr := simp)]
theorem Step.cons_not {x b} : Red.Step ((x, b) :: (x, !b) :: L) L 
Arguments: {α : Type u} {L : List (α × Bool)} {x : α} {b : Bool}
Goal: FreeGroup.Red.Step ((x, b) :: (x, !b) :: L) L
-- FreeAddGroup.Red.Step.cons_not
@[to_additive (attr := simp)]
theorem Step.cons_not {x b} : Red.Step ((x, b) :: (x, !b) :: L) L 
Arguments: {α : Type u} {L : List (α × Bool)} {x : α} {b : Bool}
Goal: FreeAddGroup.Red.Step ((x, b) :: (x, !b) :: L) L
-- FreeAddGroup.Red.Step.cons_not_rev
@[to_additive (attr := simp)]
theorem Step.cons_not_rev {x b} : Red.Step ((x, !b) :: (x, b) :: L) L 
Arguments: {α : Type u} {L : List (α × Bool)} {x : α} {b : Bool}
Goal: FreeAddGroup.Red.Step ((x, !b) :: (x, b) :: L) L
-- FreeGroup.Red.Step.cons_not_rev
@[to_additive (attr := simp)]
theorem Step.cons_not_rev {x b} : Red.Step ((x, !b) :: (x, b) :: L) L 
Arguments: {α : Type u} {L : List (α × Bool)} {x : α} {b : Bool}
Goal: FreeGroup.Red.Step ((x, !b) :: (x, b) :: L) L
-- FreeAddGroup.Red.Step.append_left
@[to_additive]
theorem Step.append_left : ∀ {L₁ L₂ L₃ : List (α × Bool)}, Step L₂ L₃ → Step (L₁ ++ L₂) (L₁ ++ L₃)
  
Arguments: {α : Type u} {L₁ L₂ L₃ : List (α × Bool)}
Goal: FreeAddGroup.Red.Step L₂ L₃ → FreeAddGroup.Red.Step (L₁ ++ L₂) (L₁ ++ L₃)
-- FreeGroup.Red.Step.append_left
@[to_additive]
theorem Step.append_left : ∀ {L₁ L₂ L₃ : List (α × Bool)}, Step L₂ L₃ → Step (L₁ ++ L₂) (L₁ ++ L₃)
  
Arguments: {α : Type u} {L₁ L₂ L₃ : List (α × Bool)}
Goal: FreeGroup.Red.Step L₂ L₃ → FreeGroup.Red.Step (L₁ ++ L₂) (L₁ ++ L₃)
-- FreeAddGroup.Red.Step.cons
@[to_additive]
theorem Step.cons {x} (H : Red.Step L₁ L₂) : Red.Step (x :: L₁) (x :: L₂) 
Arguments: {α : Type u} {L₁ L₂ : List (α × Bool)} {x : α × Bool} (H : FreeAddGroup.Red.Step L₁ L₂)
Goal: FreeAddGroup.Red.Step (x :: L₁) (x :: L₂)
-- FreeGroup.Red.Step.cons
@[to_additive]
theorem Step.cons {x} (H : Red.Step L₁ L₂) : Red.Step (x :: L₁) (x :: L₂) 
Arguments: {α : Type u} {L₁ L₂ : List (α × Bool)} {x : α × Bool} (H : FreeGroup.Red.Step L₁ L₂)
Goal: FreeGroup.Red.Step (x :: L₁) (x :: L₂)
-- FreeAddGroup.Red.Step.append_right
@[to_additive]
theorem Step.append_right : ∀ {L₁ L₂ L₃ : List (α × Bool)}, Step L₁ L₂ → Step (L₁ ++ L₃) (L₂ ++ L₃)
  
Arguments: {α : Type u} {L₁ L₂ L₃ : List (α × Bool)}
Goal: FreeAddGroup.Red.Step L₁ L₂ → FreeAddGroup.Red.Step (L₁ ++ L₃) (L₂ ++ L₃)
-- FreeGroup.Red.Step.append_right
@[to_additive]
theorem Step.append_right : ∀ {L₁ L₂ L₃ : List (α × Bool)}, Step L₁ L₂ → Step (L₁ ++ L₃) (L₂ ++ L₃)
  
Arguments: {α : Type u} {L₁ L₂ L₃ : List (α × Bool)}
Goal: FreeGroup.Red.Step L₁ L₂ → FreeGroup.Red.Step (L₁ ++ L₃) (L₂ ++ L₃)
-- FreeGroup.Red.not_step_nil
@[to_additive]
theorem not_step_nil : ¬Step [] L 
Arguments: {α : Type u} {L : List (α × Bool)}
Goal: ¬FreeGroup.Red.Step [] L
-- FreeAddGroup.Red.not_step_nil
@[to_additive]
theorem not_step_nil : ¬Step [] L 
Arguments: {α : Type u} {L : List (α × Bool)}
Goal: ¬FreeAddGroup.Red.Step [] L
-- FreeAddGroup.Red.Step.cons_left_iff
@[to_additive]
theorem Step.cons_left_iff {a : α} {b : Bool} :
    Step ((a, b) :: L₁) L₂ ↔ (∃ L, Step L₁ L ∧ L₂ = (a, b) :: L) ∨ L₁ = (a, ! b) :: L₂ 
Arguments: {α : Type u} {L₁ L₂ : List (α × Bool)} {a : α} {b : Bool}
Goal: FreeAddGroup.Red.Step ((a, b) :: L₁) L₂ ↔ (∃ L, FreeAddGroup.Red.Step L₁ L ∧ L₂ = (a, b) :: L) ∨ L₁ = (a, !b) :: L₂
-- FreeGroup.Red.Step.cons_left_iff
@[to_additive]
theorem Step.cons_left_iff {a : α} {b : Bool} :
    Step ((a, b) :: L₁) L₂ ↔ (∃ L, Step L₁ L ∧ L₂ = (a, b) :: L) ∨ L₁ = (a, ! b) :: L₂ 
Arguments: {α : Type u} {L₁ L₂ : List (α × Bool)} {a : α} {b : Bool}
Goal: FreeGroup.Red.Step ((a, b) :: L₁) L₂ ↔ (∃ L, FreeGroup.Red.Step L₁ L ∧ L₂ = (a, b) :: L) ∨ L₁ = (a, !b) :: L₂
-- FreeGroup.Red.not_step_singleton
@[to_additive]
theorem not_step_singleton : ∀ {p : α × Bool}, ¬Step [p] L
  
Arguments: {α : Type u} {L : List (α × Bool)} {p : α × Bool}
Goal: ¬FreeGroup.Red.Step [p] L
-- FreeAddGroup.Red.not_step_singleton
@[to_additive]
theorem not_step_singleton : ∀ {p : α × Bool}, ¬Step [p] L
  
Arguments: {α : Type u} {L : List (α × Bool)} {p : α × Bool}
Goal: ¬FreeAddGroup.Red.Step [p] L
-- FreeAddGroup.Red.Step.cons_cons_iff
@[to_additive]
theorem Step.cons_cons_iff : ∀ {p : α × Bool}, Step (p :: L₁) (p :: L₂) ↔ Step L₁ L₂ 
Arguments: {α : Type u} {L₁ L₂ : List (α × Bool)} {p : α × Bool}
Goal: FreeAddGroup.Red.Step (p :: L₁) (p :: L₂) ↔ FreeAddGroup.Red.Step L₁ L₂
-- FreeGroup.Red.Step.cons_cons_iff
@[to_additive]
theorem Step.cons_cons_iff : ∀ {p : α × Bool}, Step (p :: L₁) (p :: L₂) ↔ Step L₁ L₂ 
Arguments: {α : Type u} {L₁ L₂ : List (α × Bool)} {p : α × Bool}
Goal: FreeGroup.Red.Step (p :: L₁) (p :: L₂) ↔ FreeGroup.Red.Step L₁ L₂
-- FreeGroup.Red.Step.append_left_iff
@[to_additive]
theorem Step.append_left_iff : ∀ L, Step (L ++ L₁) (L ++ L₂) ↔ Step L₁ L₂
  
Arguments: {α : Type u} {L₁ L₂ : List (α × Bool)} (L : List (α × Bool))
Goal: FreeGroup.Red.Step (L ++ L₁) (L ++ L₂) ↔ FreeGroup.Red.Step L₁ L₂
-- FreeAddGroup.Red.Step.append_left_iff
@[to_additive]
theorem Step.append_left_iff : ∀ L, Step (L ++ L₁) (L ++ L₂) ↔ Step L₁ L₂
  
Arguments: {α : Type u} {L₁ L₂ : List (α × Bool)} (L : List (α × Bool))
Goal: FreeAddGroup.Red.Step (L ++ L₁) (L ++ L₂) ↔ FreeAddGroup.Red.Step L₁ L₂
-- FreeAddGroup.Red.Step.diamond_aux
@[to_additive]
theorem Step.diamond_aux :
    ∀ {L₁ L₂ L₃ L₄ : List (α × Bool)} {x1 b1 x2 b2},
      L₁ ++ (x1, b1) :: (x1, !b1) :: L₂ = L₃ ++ (x2, b2) :: (x2, !b2) :: L₄ →
        L₁ ++ L₂ = L₃ ++ L₄ ∨ ∃ L₅, Red.Step (L₁ ++ L₂) L₅ ∧ Red.Step (L₃ ++ L₄) L₅
  
Arguments: {α : Type u} {L₁ L₂ L₃ L₄ : List (α × Bool)} {x1 : α} {b1 : Bool} {x2 : α} {b2 : Bool}
Goal: L₁ ++ (x1, b1) :: (x1, !b1) :: L₂ = L₃ ++ (x2, b2) :: (x2, !b2) :: L₄ →
  L₁ ++ L₂ = L₃ ++ L₄ ∨ ∃ L₅, FreeAddGroup.Red.Step (L₁ ++ L₂) L₅ ∧ FreeAddGroup.Red.Step (L₃ ++ L₄) L₅
-- FreeGroup.Red.Step.diamond_aux
@[to_additive]
theorem Step.diamond_aux :
    ∀ {L₁ L₂ L₃ L₄ : List (α × Bool)} {x1 b1 x2 b2},
      L₁ ++ (x1, b1) :: (x1, !b1) :: L₂ = L₃ ++ (x2, b2) :: (x2, !b2) :: L₄ →
        L₁ ++ L₂ = L₃ ++ L₄ ∨ ∃ L₅, Red.Step (L₁ ++ L₂) L₅ ∧ Red.Step (L₃ ++ L₄) L₅
  
Arguments: {α : Type u} {L₁ L₂ L₃ L₄ : List (α × Bool)} {x1 : α} {b1 : Bool} {x2 : α} {b2 : Bool}
Goal: L₁ ++ (x1, b1) :: (x1, !b1) :: L₂ = L₃ ++ (x2, b2) :: (x2, !b2) :: L₄ →
  L₁ ++ L₂ = L₃ ++ L₄ ∨ ∃ L₅, FreeGroup.Red.Step (L₁ ++ L₂) L₅ ∧ FreeGroup.Red.Step (L₃ ++ L₄) L₅
-- FreeAddGroup.Red.Step.diamond
@[to_additive]
theorem Step.diamond :
    ∀ {L₁ L₂ L₃ L₄ : List (α × Bool)},
      Red.Step L₁ L₃ → Red.Step L₂ L₄ → L₁ = L₂ → L₃ = L₄ ∨ ∃ L₅, Red.Step L₃ L₅ ∧ Red.Step L₄ L₅
  
Arguments: {α : Type u} {L₁ L₂ L₃ L₄ : List (α × Bool)}
Goal: FreeAddGroup.Red.Step L₁ L₃ →
  FreeAddGroup.Red.Step L₂ L₄ → L₁ = L₂ → L₃ = L₄ ∨ ∃ L₅, FreeAddGroup.Red.Step L₃ L₅ ∧ FreeAddGroup.Red.Step L₄ L₅
-- FreeGroup.Red.Step.diamond
@[to_additive]
theorem Step.diamond :
    ∀ {L₁ L₂ L₃ L₄ : List (α × Bool)},
      Red.Step L₁ L₃ → Red.Step L₂ L₄ → L₁ = L₂ → L₃ = L₄ ∨ ∃ L₅, Red.Step L₃ L₅ ∧ Red.Step L₄ L₅
  
Arguments: {α : Type u} {L₁ L₂ L₃ L₄ : List (α × Bool)}
Goal: FreeGroup.Red.Step L₁ L₃ →
  FreeGroup.Red.Step L₂ L₄ → L₁ = L₂ → L₃ = L₄ ∨ ∃ L₅, FreeGroup.Red.Step L₃ L₅ ∧ FreeGroup.Red.Step L₄ L₅
-- FreeGroup.Red.Step.to_red
@[to_additive]
theorem Step.to_red : Step L₁ L₂ → Red L₁ L₂ 
Arguments: {α : Type u} {L₁ L₂ : List (α × Bool)}
Goal: FreeGroup.Red.Step L₁ L₂ → FreeGroup.Red L₁ L₂
-- FreeAddGroup.Red.Step.to_red
@[to_additive]
theorem Step.to_red : Step L₁ L₂ → Red L₁ L₂ 
Arguments: {α : Type u} {L₁ L₂ : List (α × Bool)}
Goal: FreeAddGroup.Red.Step L₁ L₂ → FreeAddGroup.Red L₁ L₂
-- FreeAddGroup.Red.church_rosser
@[to_additive
  "**Church-Rosser theorem** for word reduction: If `w1 w2 w3` are words such that `w1` reduces
  to `w2` and `w3` respectively, then there is a word `w4` such that `w2` and `w3` reduce to `w4`
  respectively. This is also known as Newman's diamond lemma."]
theorem church_rosser : Red L₁ L₂ → Red L₁ L₃ → Join Red L₂ L₃ 
Arguments: {α : Type u} {L₁ L₂ L₃ : List (α × Bool)}
Goal: FreeAddGroup.Red L₁ L₂ → FreeAddGroup.Red L₁ L₃ → Relation.Join FreeAddGroup.Red L₂ L₃
-- FreeGroup.Red.church_rosser
@[to_additive
  "**Church-Rosser theorem** for word reduction: If `w1 w2 w3` are words such that `w1` reduces
  to `w2` and `w3` respectively, then there is a word `w4` such that `w2` and `w3` reduce to `w4`
  respectively. This is also known as Newman's diamond lemma."]
theorem church_rosser : Red L₁ L₂ → Red L₁ L₃ → Join Red L₂ L₃ 
Arguments: {α : Type u} {L₁ L₂ L₃ : List (α × Bool)}
Goal: FreeGroup.Red L₁ L₂ → FreeGroup.Red L₁ L₃ → Relation.Join FreeGroup.Red L₂ L₃
-- FreeGroup.Red.cons_cons
@[to_additive]
theorem cons_cons {p} : Red L₁ L₂ → Red (p :: L₁) (p :: L₂) 
Arguments: {α : Type u} {L₁ L₂ : List (α × Bool)} {p : α × Bool}
Goal: FreeGroup.Red L₁ L₂ → FreeGroup.Red (p :: L₁) (p :: L₂)
-- FreeAddGroup.Red.cons_cons
@[to_additive]
theorem cons_cons {p} : Red L₁ L₂ → Red (p :: L₁) (p :: L₂) 
Arguments: {α : Type u} {L₁ L₂ : List (α × Bool)} {p : α × Bool}
Goal: FreeAddGroup.Red L₁ L₂ → FreeAddGroup.Red (p :: L₁) (p :: L₂)
-- FreeAddGroup.Red.cons_cons_iff
@[to_additive]
theorem cons_cons_iff (p) : Red (p :: L₁) (p :: L₂) ↔ Red L₁ L₂ 
Arguments: {α : Type u} {L₁ L₂ : List (α × Bool)} (p : α × Bool)
Goal: FreeAddGroup.Red (p :: L₁) (p :: L₂) ↔ FreeAddGroup.Red L₁ L₂
-- FreeGroup.Red.cons_cons_iff
@[to_additive]
theorem cons_cons_iff (p) : Red (p :: L₁) (p :: L₂) ↔ Red L₁ L₂ 
Arguments: {α : Type u} {L₁ L₂ : List (α × Bool)} (p : α × Bool)
Goal: FreeGroup.Red (p :: L₁) (p :: L₂) ↔ FreeGroup.Red L₁ L₂
-- FreeAddGroup.Red.append_append_left_iff
@[to_additive]
theorem append_append_left_iff : ∀ L, Red (L ++ L₁) (L ++ L₂) ↔ Red L₁ L₂
  
Arguments: {α : Type u} {L₁ L₂ : List (α × Bool)} (L : List (α × Bool))
Goal: FreeAddGroup.Red (L ++ L₁) (L ++ L₂) ↔ FreeAddGroup.Red L₁ L₂
-- FreeGroup.Red.append_append_left_iff
@[to_additive]
theorem append_append_left_iff : ∀ L, Red (L ++ L₁) (L ++ L₂) ↔ Red L₁ L₂
  
Arguments: {α : Type u} {L₁ L₂ : List (α × Bool)} (L : List (α × Bool))
Goal: FreeGroup.Red (L ++ L₁) (L ++ L₂) ↔ FreeGroup.Red L₁ L₂
-- FreeGroup.Red.append_append
@[to_additive]
theorem append_append (h₁ : Red L₁ L₃) (h₂ : Red L₂ L₄) : Red (L₁ ++ L₂) (L₃ ++ L₄) 
Arguments: {α : Type u} {L₁ L₂ L₃ L₄ : List (α × Bool)} (h₁ : FreeGroup.Red L₁ L₃) (h₂ : FreeGroup.Red L₂ L₄)
Goal: FreeGroup.Red (L₁ ++ L₂) (L₃ ++ L₄)
-- FreeAddGroup.Red.append_append
@[to_additive]
theorem append_append (h₁ : Red L₁ L₃) (h₂ : Red L₂ L₄) : Red (L₁ ++ L₂) (L₃ ++ L₄) 
Arguments: {α : Type u} {L₁ L₂ L₃ L₄ : List (α × Bool)} (h₁ : FreeAddGroup.Red L₁ L₃) (h₂ : FreeAddGroup.Red L₂ L₄)
Goal: FreeAddGroup.Red (L₁ ++ L₂) (L₃ ++ L₄)
-- FreeAddGroup.Red.to_append_iff
@[to_additive]
theorem to_append_iff : Red L (L₁ ++ L₂) ↔ ∃ L₃ L₄, L = L₃ ++ L₄ ∧ Red L₃ L₁ ∧ Red L₄ L₂ 
Arguments: {α : Type u} {L L₁ L₂ : List (α × Bool)}
Goal: FreeAddGroup.Red L (L₁ ++ L₂) ↔ ∃ L₃ L₄, L = L₃ ++ L₄ ∧ FreeAddGroup.Red L₃ L₁ ∧ FreeAddGroup.Red L₄ L₂
-- FreeGroup.Red.to_append_iff
@[to_additive]
theorem to_append_iff : Red L (L₁ ++ L₂) ↔ ∃ L₃ L₄, L = L₃ ++ L₄ ∧ Red L₃ L₁ ∧ Red L₄ L₂ 
Arguments: {α : Type u} {L L₁ L₂ : List (α × Bool)}
Goal: FreeGroup.Red L (L₁ ++ L₂) ↔ ∃ L₃ L₄, L = L₃ ++ L₄ ∧ FreeGroup.Red L₃ L₁ ∧ FreeGroup.Red L₄ L₂
-- FreeAddGroup.Red.nil_iff
@[to_additive "The empty word `[]` only reduces to itself."]
theorem nil_iff : Red [] L ↔ L = [] 
Arguments: {α : Type u} {L : List (α × Bool)}
Goal: FreeAddGroup.Red [] L ↔ L = []
-- FreeGroup.Red.nil_iff
@[to_additive "The empty word `[]` only reduces to itself."]
theorem nil_iff : Red [] L ↔ L = [] 
Arguments: {α : Type u} {L : List (α × Bool)}
Goal: FreeGroup.Red [] L ↔ L = []
-- FreeAddGroup.Red.singleton_iff
@[to_additive "A letter only reduces to itself."]
theorem singleton_iff {x} : Red [x] L₁ ↔ L₁ = [x] 
Arguments: {α : Type u} {L₁ : List (α × Bool)} {x : α × Bool}
Goal: FreeAddGroup.Red [x] L₁ ↔ L₁ = [x]
-- FreeGroup.Red.singleton_iff
@[to_additive "A letter only reduces to itself."]
theorem singleton_iff {x} : Red [x] L₁ ↔ L₁ = [x] 
Arguments: {α : Type u} {L₁ : List (α × Bool)} {x : α × Bool}
Goal: FreeGroup.Red [x] L₁ ↔ L₁ = [x]
-- FreeAddGroup.Red.cons_nil_iff_singleton
@[to_additive
  "If `x` is a letter and `w` is a word such that `x + w` reduces to the empty word, then `w`
  reduces to `-x`."]
theorem cons_nil_iff_singleton {x b} : Red ((x, b) :: L) [] ↔ Red L [(x, not b)] 
Arguments: {α : Type u} {L : List (α × Bool)} {x : α} {b : Bool}
Goal: FreeAddGroup.Red ((x, b) :: L) [] ↔ FreeAddGroup.Red L [(x, !b)]
-- FreeGroup.Red.cons_nil_iff_singleton
@[to_additive
  "If `x` is a letter and `w` is a word such that `x + w` reduces to the empty word, then `w`
  reduces to `-x`."]
theorem cons_nil_iff_singleton {x b} : Red ((x, b) :: L) [] ↔ Red L [(x, not b)] 
Arguments: {α : Type u} {L : List (α × Bool)} {x : α} {b : Bool}
Goal: FreeGroup.Red ((x, b) :: L) [] ↔ FreeGroup.Red L [(x, !b)]
-- FreeAddGroup.Red.red_iff_irreducible
@[to_additive]
theorem red_iff_irreducible {x1 b1 x2 b2} (h : (x1, b1) ≠ (x2, b2)) :
    Red [(x1, !b1), (x2, b2)] L ↔ L = [(x1, !b1), (x2, b2)] 
Arguments: {α : Type u} {L : List (α × Bool)} {x1 : α} {b1 : Bool} {x2 : α} {b2 : Bool} (h : (x1, b1) ≠ (x2, b2))
Goal: FreeAddGroup.Red [(x1, !b1), (x2, b2)] L ↔ L = [(x1, !b1), (x2, b2)]
-- FreeGroup.Red.red_iff_irreducible
@[to_additive]
theorem red_iff_irreducible {x1 b1 x2 b2} (h : (x1, b1) ≠ (x2, b2)) :
    Red [(x1, !b1), (x2, b2)] L ↔ L = [(x1, !b1), (x2, b2)] 
Arguments: {α : Type u} {L : List (α × Bool)} {x1 : α} {b1 : Bool} {x2 : α} {b2 : Bool} (h : (x1, b1) ≠ (x2, b2))
Goal: FreeGroup.Red [(x1, !b1), (x2, b2)] L ↔ L = [(x1, !b1), (x2, b2)]
-- FreeAddGroup.Red.neg_of_red_of_ne
@[to_additive "If `x` and `y` are distinct letters and `w₁ w₂` are words such that `x + w₁` reduces
  to `y + w₂`, then `w₁` reduces to `-x + y + w₂`."]
theorem inv_of_red_of_ne {x1 b1 x2 b2} (H1 : (x1, b1) ≠ (x2, b2))
    (H2 : Red ((x1, b1) :: L₁) ((x2, b2) :: L₂)) : Red L₁ ((x1, not b1) :: (x2, b2) :: L₂) 
Arguments: {α : Type u} {L₁ L₂ : List (α × Bool)} {x1 : α} {b1 : Bool} {x2 : α} {b2 : Bool} (H1 : (x1, b1) ≠ (x2, b2)) (H2 : FreeAddGroup.Red ((x1, b1) :: L₁) ((x2, b2) :: L₂))
Goal: FreeAddGroup.Red L₁ ((x1, !b1) :: (x2, b2) :: L₂)
-- FreeGroup.Red.inv_of_red_of_ne
@[to_additive "If `x` and `y` are distinct letters and `w₁ w₂` are words such that `x + w₁` reduces
  to `y + w₂`, then `w₁` reduces to `-x + y + w₂`."]
theorem inv_of_red_of_ne {x1 b1 x2 b2} (H1 : (x1, b1) ≠ (x2, b2))
    (H2 : Red ((x1, b1) :: L₁) ((x2, b2) :: L₂)) : Red L₁ ((x1, not b1) :: (x2, b2) :: L₂) 
Arguments: {α : Type u} {L₁ L₂ : List (α × Bool)} {x1 : α} {b1 : Bool} {x2 : α} {b2 : Bool} (H1 : (x1, b1) ≠ (x2, b2)) (H2 : FreeGroup.Red ((x1, b1) :: L₁) ((x2, b2) :: L₂))
Goal: FreeGroup.Red L₁ ((x1, !b1) :: (x2, b2) :: L₂)
-- FreeAddGroup.Red.Step.sublist
@[to_additive]
theorem Step.sublist (H : Red.Step L₁ L₂) : Sublist L₂ L₁ 
Arguments: {α : Type u} {L₁ L₂ : List (α × Bool)} (H : FreeAddGroup.Red.Step L₁ L₂)
Goal: L₂.Sublist L₁
-- FreeGroup.Red.Step.sublist
@[to_additive]
theorem Step.sublist (H : Red.Step L₁ L₂) : Sublist L₂ L₁ 
Arguments: {α : Type u} {L₁ L₂ : List (α × Bool)} (H : FreeGroup.Red.Step L₁ L₂)
Goal: L₂.Sublist L₁
-- FreeAddGroup.Red.sublist
@[to_additive "If `w₁ w₂` are words such that `w₁` reduces to `w₂`, then `w₂` is a sublist of
  `w₁`."]
protected theorem sublist : Red L₁ L₂ → L₂ <+ L₁ 
Arguments: {α : Type u} {L₁ L₂ : List (α × Bool)}
Goal: FreeAddGroup.Red L₁ L₂ → L₂.Sublist L₁
-- FreeGroup.Red.sublist
@[to_additive "If `w₁ w₂` are words such that `w₁` reduces to `w₂`, then `w₂` is a sublist of
  `w₁`."]
protected theorem sublist : Red L₁ L₂ → L₂ <+ L₁ 
Arguments: {α : Type u} {L₁ L₂ : List (α × Bool)}
Goal: FreeGroup.Red L₁ L₂ → L₂.Sublist L₁
-- FreeGroup.Red.length_le
@[to_additive]
theorem length_le (h : Red L₁ L₂) : L₂.length ≤ L₁.length 
Arguments: {α : Type u} {L₁ L₂ : List (α × Bool)} (h : FreeGroup.Red L₁ L₂)
Goal: L₂.length ≤ L₁.length
-- FreeAddGroup.Red.length_le
@[to_additive]
theorem length_le (h : Red L₁ L₂) : L₂.length ≤ L₁.length 
Arguments: {α : Type u} {L₁ L₂ : List (α × Bool)} (h : FreeAddGroup.Red L₁ L₂)
Goal: L₂.length ≤ L₁.length
-- FreeGroup.Red.sizeof_of_step
@[to_additive]
theorem sizeof_of_step : ∀ {L₁ L₂ : List (α × Bool)},
    Step L₁ L₂ → sizeOf L₂ < sizeOf L₁
  
Arguments: {α : Type u} {L₁ L₂ : List (α × Bool)}
Goal: FreeGroup.Red.Step L₁ L₂ → sizeOf L₂ < sizeOf L₁
-- FreeAddGroup.Red.sizeof_of_step
@[to_additive]
theorem sizeof_of_step : ∀ {L₁ L₂ : List (α × Bool)},
    Step L₁ L₂ → sizeOf L₂ < sizeOf L₁
  
Arguments: {α : Type u} {L₁ L₂ : List (α × Bool)}
Goal: FreeAddGroup.Red.Step L₁ L₂ → sizeOf L₂ < sizeOf L₁
-- FreeAddGroup.Red.length
@[to_additive]
theorem length (h : Red L₁ L₂) : ∃ n, L₁.length = L₂.length + 2 * n 
Arguments: {α : Type u} {L₁ L₂ : List (α × Bool)} (h : FreeAddGroup.Red L₁ L₂)
Goal: ∃ n, L₁.length = L₂.length + 2 * n
-- FreeGroup.Red.length
@[to_additive]
theorem length (h : Red L₁ L₂) : ∃ n, L₁.length = L₂.length + 2 * n 
Arguments: {α : Type u} {L₁ L₂ : List (α × Bool)} (h : FreeGroup.Red L₁ L₂)
Goal: ∃ n, L₁.length = L₂.length + 2 * n
-- FreeAddGroup.Red.antisymm
@[to_additive]
theorem antisymm (h₁₂ : Red L₁ L₂) (h₂₁ : Red L₂ L₁) : L₁ = L₂ 
Arguments: {α : Type u} {L₁ L₂ : List (α × Bool)} (h₁₂ : FreeAddGroup.Red L₁ L₂) (h₂₁ : FreeAddGroup.Red L₂ L₁)
Goal: L₁ = L₂
-- FreeGroup.Red.antisymm
@[to_additive]
theorem antisymm (h₁₂ : Red L₁ L₂) (h₂₁ : Red L₂ L₁) : L₁ = L₂ 
Arguments: {α : Type u} {L₁ L₂ : List (α × Bool)} (h₁₂ : FreeGroup.Red L₁ L₂) (h₂₁ : FreeGroup.Red L₂ L₁)
Goal: L₁ = L₂
-- FreeGroup.equivalence_join_red
@[to_additive FreeAddGroup.equivalence_join_red]
theorem equivalence_join_red : Equivalence (Join (@Red α)) 
Arguments: {α : Type u}
Goal: Equivalence (Relation.Join FreeGroup.Red)
-- FreeAddGroup.equivalence_join_red
@[to_additive FreeAddGroup.equivalence_join_red]
theorem equivalence_join_red : Equivalence (Join (@Red α)) 
Arguments: {α : Type u}
Goal: Equivalence (Relation.Join FreeAddGroup.Red)
-- FreeGroup.join_red_of_step
@[to_additive FreeAddGroup.join_red_of_step]
theorem join_red_of_step (h : Red.Step L₁ L₂) : Join Red L₁ L₂ 
Arguments: {α : Type u} {L₁ L₂ : List (α × Bool)} (h : FreeGroup.Red.Step L₁ L₂)
Goal: Relation.Join FreeGroup.Red L₁ L₂
-- FreeAddGroup.join_red_of_step
@[to_additive FreeAddGroup.join_red_of_step]
theorem join_red_of_step (h : Red.Step L₁ L₂) : Join Red L₁ L₂ 
Arguments: {α : Type u} {L₁ L₂ : List (α × Bool)} (h : FreeAddGroup.Red.Step L₁ L₂)
Goal: Relation.Join FreeAddGroup.Red L₁ L₂
-- FreeAddGroup.eqvGen_step_iff_join_red
@[to_additive FreeAddGroup.eqvGen_step_iff_join_red]
theorem eqvGen_step_iff_join_red : EqvGen Red.Step L₁ L₂ ↔ Join Red L₁ L₂ 
Arguments: {α : Type u} {L₁ L₂ : List (α × Bool)}
Goal: EqvGen FreeAddGroup.Red.Step L₁ L₂ ↔ Relation.Join FreeAddGroup.Red L₁ L₂
-- FreeGroup.eqvGen_step_iff_join_red
@[to_additive FreeAddGroup.eqvGen_step_iff_join_red]
theorem eqvGen_step_iff_join_red : EqvGen Red.Step L₁ L₂ ↔ Join Red L₁ L₂ 
Arguments: {α : Type u} {L₁ L₂ : List (α × Bool)}
Goal: EqvGen FreeGroup.Red.Step L₁ L₂ ↔ Relation.Join FreeGroup.Red L₁ L₂
-- FreeAddGroup.quot_mk_eq_mk
@[to_additive (attr := simp)]
theorem quot_mk_eq_mk : Quot.mk Red.Step L = mk L 
Arguments: {α : Type u} {L : List (α × Bool)}
Goal: Quot.mk FreeAddGroup.Red.Step L = FreeAddGroup.mk L
-- FreeGroup.quot_mk_eq_mk
@[to_additive (attr := simp)]
theorem quot_mk_eq_mk : Quot.mk Red.Step L = mk L 
Arguments: {α : Type u} {L : List (α × Bool)}
Goal: Quot.mk FreeGroup.Red.Step L = FreeGroup.mk L
-- FreeAddGroup.quot_lift_mk
@[to_additive (attr := simp)]
theorem quot_lift_mk (β : Type v) (f : List (α × Bool) → β)
    (H : ∀ L₁ L₂, Red.Step L₁ L₂ → f L₁ = f L₂) : Quot.lift f H (mk L) = f L 
Arguments: {α : Type u} {L : List (α × Bool)} (β : Type v) (f : List (α × Bool) → β) (H : ∀ (L₁ L₂ : List (α × Bool)), FreeAddGroup.Red.Step L₁ L₂ → f L₁ = f L₂)
Goal: Quot.lift f H (FreeAddGroup.mk L) = f L
-- FreeGroup.quot_lift_mk
@[to_additive (attr := simp)]
theorem quot_lift_mk (β : Type v) (f : List (α × Bool) → β)
    (H : ∀ L₁ L₂, Red.Step L₁ L₂ → f L₁ = f L₂) : Quot.lift f H (mk L) = f L 
Arguments: {α : Type u} {L : List (α × Bool)} (β : Type v) (f : List (α × Bool) → β) (H : ∀ (L₁ L₂ : List (α × Bool)), FreeGroup.Red.Step L₁ L₂ → f L₁ = f L₂)
Goal: Quot.lift f H (FreeGroup.mk L) = f L
-- FreeGroup.quot_liftOn_mk
@[to_additive (attr := simp)]
theorem quot_liftOn_mk (β : Type v) (f : List (α × Bool) → β)
    (H : ∀ L₁ L₂, Red.Step L₁ L₂ → f L₁ = f L₂) : Quot.liftOn (mk L) f H = f L 
Arguments: {α : Type u} {L : List (α × Bool)} (β : Type v) (f : List (α × Bool) → β) (H : ∀ (L₁ L₂ : List (α × Bool)), FreeGroup.Red.Step L₁ L₂ → f L₁ = f L₂)
Goal: Quot.liftOn (FreeGroup.mk L) f H = f L