ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- FreeGroup.induction_on
@[to_additive (attr := elab_as_elim, induction_eliminator)]
protected theorem induction_on {C : FreeGroup α → Prop} (z : FreeGroup α) (C1 : C 1)
    (Cp : ∀ x, C <| pure x) (Ci : ∀ x, C (pure x) → C (pure x)⁻¹)
    (Cm : ∀ x y, C x → C y → C (x * y)) : C z 
Arguments: {α : Type u} {C : FreeGroup α → Prop} (z : FreeGroup α) (C1 : C 1) (Cp : ∀ (x : α), C (pure x)) (Ci : ∀ (x : α), C (pure x) → C (pure x)⁻¹) (Cm : ∀ (x y : FreeGroup α), C x → C y → C (x * y))
Goal: C z
-- FreeGroup.map_pure
@[to_additive]
theorem map_pure (f : α → β) (x : α) : f <$> (pure x : FreeGroup α) = pure (f x) 
Arguments: {α β : Type u} (f : α → β) (x : α)
Goal: f <$> pure x = pure (f x)
-- FreeAddGroup.map_pure
@[to_additive]
theorem map_pure (f : α → β) (x : α) : f <$> (pure x : FreeGroup α) = pure (f x) 
Arguments: {α β : Type u} (f : α → β) (x : α)
Goal: f <$> pure x = pure (f x)
-- FreeGroup.map_one
@[to_additive (attr := simp)]
theorem map_one (f : α → β) : f <$> (1 : FreeGroup α) = 1 
Arguments: {α β : Type u} (f : α → β)
Goal: f <$> 1 = 1
-- FreeAddGroup.map_zero
@[to_additive (attr := simp)]
theorem map_one (f : α → β) : f <$> (1 : FreeGroup α) = 1 
Arguments: {α β : Type u} (f : α → β)
Goal: f <$> 0 = 0
-- FreeAddGroup.map_add
@[to_additive (attr := simp)]
theorem map_mul (f : α → β) (x y : FreeGroup α) : f <$> (x * y) = f <$> x * f <$> y 
Arguments: {α β : Type u} (f : α → β) (x y : FreeAddGroup α)
Goal: f <$> (x + y) = f <$> x + f <$> y
-- FreeGroup.map_mul
@[to_additive (attr := simp)]
theorem map_mul (f : α → β) (x y : FreeGroup α) : f <$> (x * y) = f <$> x * f <$> y 
Arguments: {α β : Type u} (f : α → β) (x y : FreeGroup α)
Goal: f <$> (x * y) = f <$> x * f <$> y
-- FreeAddGroup.map_neg
@[to_additive (attr := simp)]
theorem map_inv (f : α → β) (x : FreeGroup α) : f <$> x⁻¹ = (f <$> x)⁻¹ 
Arguments: {α β : Type u} (f : α → β) (x : FreeAddGroup α)
Goal: f <$> (-x) = -f <$> x
-- FreeGroup.map_inv
@[to_additive (attr := simp)]
theorem map_inv (f : α → β) (x : FreeGroup α) : f <$> x⁻¹ = (f <$> x)⁻¹ 
Arguments: {α β : Type u} (f : α → β) (x : FreeGroup α)
Goal: f <$> x⁻¹ = (f <$> x)⁻¹
-- FreeAddGroup.pure_bind
@[to_additive]
theorem pure_bind (f : α → FreeGroup β) (x) : pure x >>= f = f x 
Arguments: {α β : Type u} (f : α → FreeAddGroup β) (x : α)
Goal: pure x >>= f = f x
-- FreeGroup.pure_bind
@[to_additive]
theorem pure_bind (f : α → FreeGroup β) (x) : pure x >>= f = f x 
Arguments: {α β : Type u} (f : α → FreeGroup β) (x : α)
Goal: pure x >>= f = f x
-- FreeAddGroup.zero_bind
@[to_additive (attr := simp)]
theorem one_bind (f : α → FreeGroup β) : 1 >>= f = 1 
Arguments: {α β : Type u} (f : α → FreeAddGroup β)
Goal: 0 >>= f = 0
-- FreeGroup.one_bind
@[to_additive (attr := simp)]
theorem one_bind (f : α → FreeGroup β) : 1 >>= f = 1 
Arguments: {α β : Type u} (f : α → FreeGroup β)
Goal: 1 >>= f = 1
-- FreeAddGroup.add_bind
@[to_additive (attr := simp)]
theorem mul_bind (f : α → FreeGroup β) (x y : FreeGroup α) : x * y >>= f = (x >>= f) * (y >>= f) 
Arguments: {α β : Type u} (f : α → FreeAddGroup β) (x y : FreeAddGroup α)
Goal: x + y >>= f = (x >>= f) + (y >>= f)
-- FreeGroup.mul_bind
@[to_additive (attr := simp)]
theorem mul_bind (f : α → FreeGroup β) (x y : FreeGroup α) : x * y >>= f = (x >>= f) * (y >>= f) 
Arguments: {α β : Type u} (f : α → FreeGroup β) (x y : FreeGroup α)
Goal: x * y >>= f = (x >>= f) * (y >>= f)
-- FreeAddGroup.neg_bind
@[to_additive (attr := simp)]
theorem inv_bind (f : α → FreeGroup β) (x : FreeGroup α) : x⁻¹ >>= f = (x >>= f)⁻¹ 
Arguments: {α β : Type u} (f : α → FreeAddGroup β) (x : FreeAddGroup α)
Goal: -x >>= f = -(x >>= f)
-- FreeGroup.inv_bind
@[to_additive (attr := simp)]
theorem inv_bind (f : α → FreeGroup β) (x : FreeGroup α) : x⁻¹ >>= f = (x >>= f)⁻¹ 
Arguments: {α β : Type u} (f : α → FreeGroup β) (x : FreeGroup α)
Goal: x⁻¹ >>= f = (x >>= f)⁻¹
-- FreeAddGroup.reduce.cons
@[to_additive (attr := simp)]
theorem reduce.cons (x) :
    reduce (x :: L) =
      List.casesOn (reduce L) [x] fun hd tl =>
        if x.1 = hd.1 ∧ x.2 = not hd.2 then tl else x :: hd :: tl 
Arguments: {α : Type u} {L : List (α × Bool)} [DecidableEq α] (x : α × Bool)
Goal: FreeAddGroup.reduce (x :: L) =
  List.casesOn (FreeAddGroup.reduce L) [x] fun hd tl => if x.1 = hd.1 ∧ x.2 = !hd.2 then tl else x :: hd :: tl
-- FreeGroup.reduce.cons
@[to_additive (attr := simp)]
theorem reduce.cons (x) :
    reduce (x :: L) =
      List.casesOn (reduce L) [x] fun hd tl =>
        if x.1 = hd.1 ∧ x.2 = not hd.2 then tl else x :: hd :: tl 
Arguments: {α : Type u} {L : List (α × Bool)} [DecidableEq α] (x : α × Bool)
Goal: FreeGroup.reduce (x :: L) =
  List.casesOn (FreeGroup.reduce L) [x] fun hd tl => if x.1 = hd.1 ∧ x.2 = !hd.2 then tl else x :: hd :: tl
-- FreeGroup.reduce.red
@[to_additive "The first theorem that characterises the function `reduce`: a word reduces to its
  maximal reduction."]
theorem reduce.red : Red L (reduce L) 
Arguments: {α : Type u} {L : List (α × Bool)} [DecidableEq α]
Goal: FreeGroup.Red L (FreeGroup.reduce L)
-- FreeAddGroup.reduce.red
@[to_additive "The first theorem that characterises the function `reduce`: a word reduces to its
  maximal reduction."]
theorem reduce.red : Red L (reduce L) 
Arguments: {α : Type u} {L : List (α × Bool)} [DecidableEq α]
Goal: FreeAddGroup.Red L (FreeAddGroup.reduce L)
-- FreeGroup.reduce.not
@[to_additive]
theorem reduce.not {p : Prop} :
    ∀ {L₁ L₂ L₃ : List (α × Bool)} {x b}, reduce L₁ = L₂ ++ (x, b) :: (x, !b) :: L₃ → p
  
Arguments: {α : Type u} [DecidableEq α] {p : Prop} {L₁ L₂ L₃ : List (α × Bool)} {x : α} {b : Bool}
Goal: FreeGroup.reduce L₁ = L₂ ++ (x, b) :: (x, !b) :: L₃ → p
-- FreeAddGroup.reduce.not
@[to_additive]
theorem reduce.not {p : Prop} :
    ∀ {L₁ L₂ L₃ : List (α × Bool)} {x b}, reduce L₁ = L₂ ++ (x, b) :: (x, !b) :: L₃ → p
  
Arguments: {α : Type u} [DecidableEq α] {p : Prop} {L₁ L₂ L₃ : List (α × Bool)} {x : α} {b : Bool}
Goal: FreeAddGroup.reduce L₁ = L₂ ++ (x, b) :: (x, !b) :: L₃ → p
-- FreeGroup.reduce.min
@[to_additive "The second theorem that characterises the function `reduce`: the maximal reduction of
  a word only reduces to itself."]
theorem reduce.min (H : Red (reduce L₁) L₂) : reduce L₁ = L₂ 
Arguments: {α : Type u} {L₁ L₂ : List (α × Bool)} [DecidableEq α] (H : FreeGroup.Red (FreeGroup.reduce L₁) L₂)
Goal: FreeGroup.reduce L₁ = L₂
-- FreeAddGroup.reduce.min
@[to_additive "The second theorem that characterises the function `reduce`: the maximal reduction of
  a word only reduces to itself."]
theorem reduce.min (H : Red (reduce L₁) L₂) : reduce L₁ = L₂ 
Arguments: {α : Type u} {L₁ L₂ : List (α × Bool)} [DecidableEq α] (H : FreeAddGroup.Red (FreeAddGroup.reduce L₁) L₂)
Goal: FreeAddGroup.reduce L₁ = L₂
-- FreeGroup.reduce.idem
@[to_additive (attr := simp) "`reduce` is idempotent, i.e. the maximal reduction of the maximal
  reduction of a word is the maximal reduction of the word."]
theorem reduce.idem : reduce (reduce L) = reduce L 
Arguments: {α : Type u} {L : List (α × Bool)} [DecidableEq α]
Goal: FreeGroup.reduce (FreeGroup.reduce L) = FreeGroup.reduce L
-- FreeAddGroup.reduce.idem
@[to_additive (attr := simp) "`reduce` is idempotent, i.e. the maximal reduction of the maximal
  reduction of a word is the maximal reduction of the word."]
theorem reduce.idem : reduce (reduce L) = reduce L 
Arguments: {α : Type u} {L : List (α × Bool)} [DecidableEq α]
Goal: FreeAddGroup.reduce (FreeAddGroup.reduce L) = FreeAddGroup.reduce L
-- FreeGroup.reduce.Step.eq
@[to_additive]
theorem reduce.Step.eq (H : Red.Step L₁ L₂) : reduce L₁ = reduce L₂ 
Arguments: {α : Type u} {L₁ L₂ : List (α × Bool)} [DecidableEq α] (H : FreeGroup.Red.Step L₁ L₂)
Goal: FreeGroup.reduce L₁ = FreeGroup.reduce L₂
-- FreeAddGroup.reduce.Step.eq
@[to_additive]
theorem reduce.Step.eq (H : Red.Step L₁ L₂) : reduce L₁ = reduce L₂ 
Arguments: {α : Type u} {L₁ L₂ : List (α × Bool)} [DecidableEq α] (H : FreeAddGroup.Red.Step L₁ L₂)
Goal: FreeAddGroup.reduce L₁ = FreeAddGroup.reduce L₂
-- FreeGroup.reduce.eq_of_red
@[to_additive "If a word reduces to another word, then they have a common maximal reduction."]
theorem reduce.eq_of_red (H : Red L₁ L₂) : reduce L₁ = reduce L₂ 
Arguments: {α : Type u} {L₁ L₂ : List (α × Bool)} [DecidableEq α] (H : FreeGroup.Red L₁ L₂)
Goal: FreeGroup.reduce L₁ = FreeGroup.reduce L₂
-- FreeAddGroup.reduce.eq_of_red
@[to_additive "If a word reduces to another word, then they have a common maximal reduction."]
theorem reduce.eq_of_red (H : Red L₁ L₂) : reduce L₁ = reduce L₂ 
Arguments: {α : Type u} {L₁ L₂ : List (α × Bool)} [DecidableEq α] (H : FreeAddGroup.Red L₁ L₂)
Goal: FreeAddGroup.reduce L₁ = FreeAddGroup.reduce L₂
-- FreeAddGroup.Red.reduce_right
@[to_additive]
theorem Red.reduce_right (h : Red L₁ L₂) : Red L₁ (reduce L₂) 
Arguments: {α : Type u} {L₁ L₂ : List (α × Bool)} [DecidableEq α] (h : FreeAddGroup.Red L₁ L₂)
Goal: FreeAddGroup.Red L₁ (FreeAddGroup.reduce L₂)
-- FreeGroup.Red.reduce_right
@[to_additive]
theorem Red.reduce_right (h : Red L₁ L₂) : Red L₁ (reduce L₂) 
Arguments: {α : Type u} {L₁ L₂ : List (α × Bool)} [DecidableEq α] (h : FreeGroup.Red L₁ L₂)
Goal: FreeGroup.Red L₁ (FreeGroup.reduce L₂)
-- FreeAddGroup.Red.reduce_left
@[to_additive]
theorem Red.reduce_left (h : Red L₁ L₂) : Red L₂ (reduce L₁) 
Arguments: {α : Type u} {L₁ L₂ : List (α × Bool)} [DecidableEq α] (h : FreeAddGroup.Red L₁ L₂)
Goal: FreeAddGroup.Red L₂ (FreeAddGroup.reduce L₁)
-- FreeGroup.Red.reduce_left
@[to_additive]
theorem Red.reduce_left (h : Red L₁ L₂) : Red L₂ (reduce L₁) 
Arguments: {α : Type u} {L₁ L₂ : List (α × Bool)} [DecidableEq α] (h : FreeGroup.Red L₁ L₂)
Goal: FreeGroup.Red L₂ (FreeGroup.reduce L₁)
-- FreeGroup.reduce.sound
@[to_additive "If two words correspond to the same element in the additive free group, then they
  have a common maximal reduction. This is the proof that the function that sends an element of the
  free group to its maximal reduction is well-defined."]
theorem reduce.sound (H : mk L₁ = mk L₂) : reduce L₁ = reduce L₂ 
Arguments: {α : Type u} {L₁ L₂ : List (α × Bool)} [DecidableEq α] (H : FreeGroup.mk L₁ = FreeGroup.mk L₂)
Goal: FreeGroup.reduce L₁ = FreeGroup.reduce L₂
-- FreeAddGroup.reduce.sound
@[to_additive "If two words correspond to the same element in the additive free group, then they
  have a common maximal reduction. This is the proof that the function that sends an element of the
  free group to its maximal reduction is well-defined."]
theorem reduce.sound (H : mk L₁ = mk L₂) : reduce L₁ = reduce L₂ 
Arguments: {α : Type u} {L₁ L₂ : List (α × Bool)} [DecidableEq α] (H : FreeAddGroup.mk L₁ = FreeAddGroup.mk L₂)
Goal: FreeAddGroup.reduce L₁ = FreeAddGroup.reduce L₂
-- FreeGroup.reduce.exact
@[to_additive "If two words have a common maximal reduction, then they correspond to the same
  element in the additive free group."]
theorem reduce.exact (H : reduce L₁ = reduce L₂) : mk L₁ = mk L₂ 
Arguments: {α : Type u} {L₁ L₂ : List (α × Bool)} [DecidableEq α] (H : FreeGroup.reduce L₁ = FreeGroup.reduce L₂)
Goal: FreeGroup.mk L₁ = FreeGroup.mk L₂
-- FreeAddGroup.reduce.exact
@[to_additive "If two words have a common maximal reduction, then they correspond to the same
  element in the additive free group."]
theorem reduce.exact (H : reduce L₁ = reduce L₂) : mk L₁ = mk L₂ 
Arguments: {α : Type u} {L₁ L₂ : List (α × Bool)} [DecidableEq α] (H : FreeAddGroup.reduce L₁ = FreeAddGroup.reduce L₂)
Goal: FreeAddGroup.mk L₁ = FreeAddGroup.mk L₂
-- FreeGroup.reduce.self
@[to_additive "A word and its maximal reduction correspond to the same element of the additive free
  group."]
theorem reduce.self : mk (reduce L) = mk L 
Arguments: {α : Type u} {L : List (α × Bool)} [DecidableEq α]
Goal: FreeGroup.mk (FreeGroup.reduce L) = FreeGroup.mk L
-- FreeAddGroup.reduce.self
@[to_additive "A word and its maximal reduction correspond to the same element of the additive free
  group."]
theorem reduce.self : mk (reduce L) = mk L 
Arguments: {α : Type u} {L : List (α × Bool)} [DecidableEq α]
Goal: FreeAddGroup.mk (FreeAddGroup.reduce L) = FreeAddGroup.mk L
-- FreeAddGroup.reduce.rev
@[to_additive "If words `w₁ w₂` are such that `w₁` reduces to `w₂`, then `w₂` reduces to the maximal
  reduction of `w₁`."]
theorem reduce.rev (H : Red L₁ L₂) : Red L₂ (reduce L₁) 
Arguments: {α : Type u} {L₁ L₂ : List (α × Bool)} [DecidableEq α] (H : FreeAddGroup.Red L₁ L₂)
Goal: FreeAddGroup.Red L₂ (FreeAddGroup.reduce L₁)
-- FreeGroup.reduce.rev
@[to_additive "If words `w₁ w₂` are such that `w₁` reduces to `w₂`, then `w₂` reduces to the maximal
  reduction of `w₁`."]
theorem reduce.rev (H : Red L₁ L₂) : Red L₂ (reduce L₁) 
Arguments: {α : Type u} {L₁ L₂ : List (α × Bool)} [DecidableEq α] (H : FreeGroup.Red L₁ L₂)
Goal: FreeGroup.Red L₂ (FreeGroup.reduce L₁)
-- FreeGroup.mk_toWord
@[to_additive]
theorem mk_toWord : ∀ {x : FreeGroup α}, mk (toWord x) = x 
Arguments: {α : Type u} [DecidableEq α] {x : FreeGroup α}
Goal: FreeGroup.mk x.toWord = x
-- FreeAddGroup.mk_toWord
@[to_additive]
theorem mk_toWord : ∀ {x : FreeGroup α}, mk (toWord x) = x 
Arguments: {α : Type u} [DecidableEq α] {x : FreeAddGroup α}
Goal: FreeAddGroup.mk x.toWord = x
-- FreeGroup.toWord_injective
@[to_additive]
theorem toWord_injective : Function.Injective (toWord : FreeGroup α → List (α × Bool)) 
Arguments: {α : Type u} [DecidableEq α]
Goal: Function.Injective FreeGroup.toWord
-- FreeAddGroup.toWord_injective
@[to_additive]
theorem toWord_injective : Function.Injective (toWord : FreeGroup α → List (α × Bool)) 
Arguments: {α : Type u} [DecidableEq α]
Goal: Function.Injective FreeAddGroup.toWord
-- FreeGroup.toWord_inj
@[to_additive (attr := simp)]
theorem toWord_inj {x y : FreeGroup α} : toWord x = toWord y ↔ x = y 
Arguments: {α : Type u} [DecidableEq α] {x y : FreeGroup α}
Goal: x.toWord = y.toWord ↔ x = y
-- FreeAddGroup.toWord_inj
@[to_additive (attr := simp)]
theorem toWord_inj {x y : FreeGroup α} : toWord x = toWord y ↔ x = y 
Arguments: {α : Type u} [DecidableEq α] {x y : FreeAddGroup α}
Goal: x.toWord = y.toWord ↔ x = y
-- FreeAddGroup.toWord_mk
@[to_additive (attr := simp)]
theorem toWord_mk : (mk L₁).toWord = reduce L₁ 
Arguments: {α : Type u} {L₁ : List (α × Bool)} [DecidableEq α]
Goal: (FreeAddGroup.mk L₁).toWord = FreeAddGroup.reduce L₁
-- FreeGroup.toWord_mk
@[to_additive (attr := simp)]
theorem toWord_mk : (mk L₁).toWord = reduce L₁ 
Arguments: {α : Type u} {L₁ : List (α × Bool)} [DecidableEq α]
Goal: (FreeGroup.mk L₁).toWord = FreeGroup.reduce L₁
-- FreeAddGroup.reduce_toWord
@[to_additive (attr := simp)]
theorem reduce_toWord : ∀ x : FreeGroup α, reduce (toWord x) = toWord x 
Arguments: {α : Type u} [DecidableEq α] (x : FreeAddGroup α)
Goal: FreeAddGroup.reduce x.toWord = x.toWord
-- FreeGroup.reduce_toWord
@[to_additive (attr := simp)]
theorem reduce_toWord : ∀ x : FreeGroup α, reduce (toWord x) = toWord x 
Arguments: {α : Type u} [DecidableEq α] (x : FreeGroup α)
Goal: FreeGroup.reduce x.toWord = x.toWord
-- FreeAddGroup.toWord_zero
@[to_additive (attr := simp)]
theorem toWord_one : (1 : FreeGroup α).toWord = [] 
Arguments: {α : Type u} [DecidableEq α]
Goal: FreeAddGroup.toWord 0 = []
-- FreeGroup.toWord_one
@[to_additive (attr := simp)]
theorem toWord_one : (1 : FreeGroup α).toWord = [] 
Arguments: {α : Type u} [DecidableEq α]
Goal: FreeGroup.toWord 1 = []
-- FreeGroup.toWord_eq_nil_iff
@[to_additive (attr := simp)]
theorem toWord_eq_nil_iff {x : FreeGroup α} : x.toWord = [] ↔ x = 1 
Arguments: {α : Type u} [DecidableEq α] {x : FreeGroup α}
Goal: x.toWord = [] ↔ x = 1
-- FreeAddGroup.toWord_eq_nil_iff
@[to_additive (attr := simp)]
theorem toWord_eq_nil_iff {x : FreeGroup α} : x.toWord = [] ↔ x = 1 
Arguments: {α : Type u} [DecidableEq α] {x : FreeAddGroup α}
Goal: x.toWord = [] ↔ x = 0
-- FreeAddGroup.reduce_negRev
@[to_additive]
theorem reduce_invRev {w : List (α × Bool)} : reduce (invRev w) = invRev (reduce w) 
Arguments: {α : Type u} [DecidableEq α] {w : List (α × Bool)}
Goal: FreeAddGroup.reduce (FreeAddGroup.negRev w) = FreeAddGroup.negRev (FreeAddGroup.reduce w)
-- FreeGroup.reduce_invRev
@[to_additive]
theorem reduce_invRev {w : List (α × Bool)} : reduce (invRev w) = invRev (reduce w) 
Arguments: {α : Type u} [DecidableEq α] {w : List (α × Bool)}
Goal: FreeGroup.reduce (FreeGroup.invRev w) = FreeGroup.invRev (FreeGroup.reduce w)
-- FreeGroup.toWord_inv
@[to_additive]
theorem toWord_inv {x : FreeGroup α} : x⁻¹.toWord = invRev x.toWord 
Arguments: {α : Type u} [DecidableEq α] {x : FreeGroup α}
Goal: x⁻¹.toWord = FreeGroup.invRev x.toWord
-- FreeAddGroup.toWord_neg
@[to_additive]
theorem toWord_inv {x : FreeGroup α} : x⁻¹.toWord = invRev x.toWord 
Arguments: {α : Type u} [DecidableEq α] {x : FreeAddGroup α}
Goal: (-x).toWord = FreeAddGroup.negRev x.toWord
-- FreeGroup.Red.enum.sound
theorem Red.enum.sound (H : L₂ ∈ List.filter (Red L₁) (List.sublists L₁)) : Red L₁ L₂ 
Arguments: {α : Type u} {L₁ L₂ : List (α × Bool)} [DecidableEq α] (H : L₂ ∈ List.filter (fun b => decide (FreeGroup.Red L₁ b)) L₁.sublists)
Goal: FreeGroup.Red L₁ L₂
-- FreeGroup.Red.enum.complete
theorem Red.enum.complete (H : Red L₁ L₂) : L₂ ∈ Red.enum L₁ 
Arguments: {α : Type u} {L₁ L₂ : List (α × Bool)} [DecidableEq α] (H : FreeGroup.Red L₁ L₂)
Goal: L₂ ∈ FreeGroup.Red.enum L₁
-- FreeAddGroup.norm_neg_eq
@[to_additive (attr := simp)]
theorem norm_inv_eq {x : FreeGroup α} : norm x⁻¹ = norm x 
Arguments: {α : Type u} [DecidableEq α] {x : FreeAddGroup α}
Goal: (-x).norm = x.norm
-- FreeGroup.norm_inv_eq
@[to_additive (attr := simp)]
theorem norm_inv_eq {x : FreeGroup α} : norm x⁻¹ = norm x 
Arguments: {α : Type u} [DecidableEq α] {x : FreeGroup α}
Goal: x⁻¹.norm = x.norm
-- FreeGroup.norm_eq_zero
@[to_additive (attr := simp)]
theorem norm_eq_zero {x : FreeGroup α} : norm x = 0 ↔ x = 1 
Arguments: {α : Type u} [DecidableEq α] {x : FreeGroup α}
Goal: x.norm = 0 ↔ x = 1
-- FreeAddGroup.norm_eq_zero
@[to_additive (attr := simp)]
theorem norm_eq_zero {x : FreeGroup α} : norm x = 0 ↔ x = 1 
Arguments: {α : Type u} [DecidableEq α] {x : FreeAddGroup α}
Goal: x.norm = 0 ↔ x = 0
-- FreeAddGroup.norm_zero
@[to_additive (attr := simp)]
theorem norm_one : norm (1 : FreeGroup α) = 0 
Arguments: {α : Type u} [DecidableEq α]
Goal: FreeAddGroup.norm 0 = 0
-- FreeGroup.norm_one
@[to_additive (attr := simp)]
theorem norm_one : norm (1 : FreeGroup α) = 0 
Arguments: {α : Type u} [DecidableEq α]
Goal: FreeGroup.norm 1 = 0
-- FreeAddGroup.norm_mk_le
@[to_additive]
theorem norm_mk_le : norm (mk L₁) ≤ L₁.length 
Arguments: {α : Type u} {L₁ : List (α × Bool)} [DecidableEq α]
Goal: (FreeAddGroup.mk L₁).norm ≤ L₁.length
-- FreeGroup.norm_mk_le
@[to_additive]
theorem norm_mk_le : norm (mk L₁) ≤ L₁.length 
Arguments: {α : Type u} {L₁ : List (α × Bool)} [DecidableEq α]
Goal: (FreeGroup.mk L₁).norm ≤ L₁.length
-- FreeAddGroup.norm_add_le
@[to_additive]
theorem norm_mul_le (x y : FreeGroup α) : norm (x * y) ≤ norm x + norm y 
Arguments: {α : Type u} [DecidableEq α] (x y : FreeAddGroup α)
Goal: (x + y).norm ≤ x.norm + y.norm
-- FreeGroup.norm_mul_le
@[to_additive]
theorem norm_mul_le (x y : FreeGroup α) : norm (x * y) ≤ norm x + norm y 
Arguments: {α : Type u} [DecidableEq α] (x y : FreeGroup α)
Goal: (x * y).norm ≤ x.norm + y.norm
-- LeftOrdContinuous.id
protected theorem id : LeftOrdContinuous (id : α → α) 
Arguments: (α : Type u) [Preorder α]
Goal: LeftOrdContinuous id
-- LeftOrdContinuous.order_dual
protected theorem order_dual : LeftOrdContinuous f → RightOrdContinuous (toDual ∘ f ∘ ofDual) 
Arguments: {α : Type u} {β : Type v} [Preorder α] [Preorder β] {f : α → β}
Goal: LeftOrdContinuous f → RightOrdContinuous (⇑OrderDual.toDual ∘ f ∘ ⇑OrderDual.ofDual)
-- LeftOrdContinuous.map_isGreatest
theorem map_isGreatest (hf : LeftOrdContinuous f) {s : Set α} {x : α} (h : IsGreatest s x) :
    IsGreatest (f '' s) (f x) 
Arguments: {α : Type u} {β : Type v} [Preorder α] [Preorder β] {f : α → β} (hf : LeftOrdContinuous f) {s : Set α} {x : α} (h : IsGreatest s x)
Goal: IsGreatest (f '' s) (f x)
-- LeftOrdContinuous.mono
theorem mono (hf : LeftOrdContinuous f) : Monotone f 
Arguments: {α : Type u} {β : Type v} [Preorder α] [Preorder β] {f : α → β} (hf : LeftOrdContinuous f)
Goal: Monotone f
-- LeftOrdContinuous.comp
theorem comp (hg : LeftOrdContinuous g) (hf : LeftOrdContinuous f) : LeftOrdContinuous (g ∘ f) 
Arguments: {α : Type u} {β : Type v} {γ : Type w} [Preorder α] [Preorder β] [Preorder γ] {g : β → γ} {f : α → β} (hg : LeftOrdContinuous g) (hf : LeftOrdContinuous f)
Goal: LeftOrdContinuous (g ∘ f)
-- LeftOrdContinuous.iterate
protected theorem iterate {f : α → α} (hf : LeftOrdContinuous f) (n : ℕ) :
    LeftOrdContinuous f^[n] 
Arguments: {α : Type u} [Preorder α] {f : α → α} (hf : LeftOrdContinuous f) (n : ℕ)
Goal: LeftOrdContinuous f^[n]
-- LeftOrdContinuous.map_sup
theorem map_sup (hf : LeftOrdContinuous f) (x y : α) : f (x ⊔ y) = f x ⊔ f y 
Arguments: {α : Type u} {β : Type v} [SemilatticeSup α] [SemilatticeSup β] {f : α → β} (hf : LeftOrdContinuous f) (x y : α)
Goal: f (x ⊔ y) = f x ⊔ f y
-- LeftOrdContinuous.le_iff
theorem le_iff (hf : LeftOrdContinuous f) (h : Injective f) {x y} : f x ≤ f y ↔ x ≤ y 
Arguments: {α : Type u} {β : Type v} [SemilatticeSup α] [SemilatticeSup β] {f : α → β} (hf : LeftOrdContinuous f) (h : Function.Injective f) {x y : α}
Goal: f x ≤ f y ↔ x ≤ y
-- LeftOrdContinuous.lt_iff
theorem lt_iff (hf : LeftOrdContinuous f) (h : Injective f) {x y} : f x < f y ↔ x < y 
Arguments: {α : Type u} {β : Type v} [SemilatticeSup α] [SemilatticeSup β] {f : α → β} (hf : LeftOrdContinuous f) (h : Function.Injective f) {x y : α}
Goal: f x < f y ↔ x < y
-- LeftOrdContinuous.coe_toOrderEmbedding
@[simp]
theorem coe_toOrderEmbedding (hf : LeftOrdContinuous f) (h : Injective f) :
    ⇑(hf.toOrderEmbedding f h) = f 
Arguments: {α : Type u} {β : Type v} [SemilatticeSup α] [SemilatticeSup β] {f : α → β} (hf : LeftOrdContinuous f) (h : Function.Injective f)
Goal: ⇑(LeftOrdContinuous.toOrderEmbedding f hf h) = f
-- LeftOrdContinuous.map_sSup'
theorem map_sSup' (hf : LeftOrdContinuous f) (s : Set α) : f (sSup s) = sSup (f '' s) 
Arguments: {α : Type u} {β : Type v} [CompleteLattice α] [CompleteLattice β] {f : α → β} (hf : LeftOrdContinuous f) (s : Set α)
Goal: f (sSup s) = sSup (f '' s)
-- LeftOrdContinuous.map_sSup
theorem map_sSup (hf : LeftOrdContinuous f) (s : Set α) : f (sSup s) = ⨆ x ∈ s, f x 
Arguments: {α : Type u} {β : Type v} [CompleteLattice α] [CompleteLattice β] {f : α → β} (hf : LeftOrdContinuous f) (s : Set α)
Goal: f (sSup s) = ⨆ x ∈ s, f x
-- LeftOrdContinuous.map_iSup
theorem map_iSup (hf : LeftOrdContinuous f) (g : ι → α) : f (⨆ i, g i) = ⨆ i, f (g i) 
Arguments: {α : Type u} {β : Type v} {ι : Sort x} [CompleteLattice α] [CompleteLattice β] {f : α → β} (hf : LeftOrdContinuous f) (g : ι → α)
Goal: f (⨆ i, g i) = ⨆ i, f (g i)
-- LeftOrdContinuous.map_csSup
theorem map_csSup (hf : LeftOrdContinuous f) {s : Set α} (sne : s.Nonempty) (sbdd : BddAbove s) :
    f (sSup s) = sSup (f '' s) 
Arguments: {α : Type u} {β : Type v} [ConditionallyCompleteLattice α] [ConditionallyCompleteLattice β] {f : α → β} (hf : LeftOrdContinuous f) {s : Set α} (sne : s.Nonempty) (sbdd : BddAbove s)
Goal: f (sSup s) = sSup (f '' s)
-- LeftOrdContinuous.map_ciSup
theorem map_ciSup (hf : LeftOrdContinuous f) {g : ι → α} (hg : BddAbove (range g)) :
    f (⨆ i, g i) = ⨆ i, f (g i) 
Arguments: {α : Type u} {β : Type v} {ι : Sort x} [ConditionallyCompleteLattice α] [ConditionallyCompleteLattice β] [Nonempty ι] {f : α → β} (hf : LeftOrdContinuous f) {g : ι → α} (hg : BddAbove (Set.range g))
Goal: f (⨆ i, g i) = ⨆ i, f (g i)
-- RightOrdContinuous.id
protected theorem id : RightOrdContinuous (id : α → α) 
Arguments: (α : Type u) [Preorder α]
Goal: RightOrdContinuous id
-- RightOrdContinuous.orderDual
protected theorem orderDual : RightOrdContinuous f → LeftOrdContinuous (toDual ∘ f ∘ ofDual) 
Arguments: {α : Type u} {β : Type v} [Preorder α] [Preorder β] {f : α → β}
Goal: RightOrdContinuous f → LeftOrdContinuous (⇑OrderDual.toDual ∘ f ∘ ⇑OrderDual.ofDual)
-- RightOrdContinuous.map_isLeast
theorem map_isLeast (hf : RightOrdContinuous f) {s : Set α} {x : α} (h : IsLeast s x) :
    IsLeast (f '' s) (f x) 
Arguments: {α : Type u} {β : Type v} [Preorder α] [Preorder β] {f : α → β} (hf : RightOrdContinuous f) {s : Set α} {x : α} (h : IsLeast s x)
Goal: IsLeast (f '' s) (f x)