1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: jacobiTheta₂'_conj
File: Mathlib/NumberTheory/ModularForms/JacobiTheta/TwoVariable.lean

tactic: rw [← neg_inj, ← jacobiTheta₂'_neg_left, jacobiTheta₂', jacobiTheta₂', conj_tsum, ← tsum_neg]
state_before: z τ : ℂ
⊢ (starRingEnd ℂ) (jacobiTheta₂' z τ) = jacobiTheta₂' ((starRingEnd ℂ) z) (-(starRingEnd ℂ) τ)
state_after: z τ : ℂ
⊢ ∑' (b : ℤ), -(starRingEnd ℂ) (jacobiTheta₂'_term b z τ) =
    ∑' (n : ℤ), jacobiTheta₂'_term n (-(starRingEnd ℂ) z) (-(starRingEnd ℂ) τ)

tactic: congr 1 with n
state_before: z τ : ℂ
⊢ ∑' (b : ℤ), -(starRingEnd ℂ) (jacobiTheta₂'_term b z τ) =
    ∑' (n : ℤ), jacobiTheta₂'_term n (-(starRingEnd ℂ) z) (-(starRingEnd ℂ) τ)
state_after: case e_f.h
z τ : ℂ
n : ℤ
⊢ -(starRingEnd ℂ) (jacobiTheta₂'_term n z τ) = jacobiTheta₂'_term n (-(starRingEnd ℂ) z) (-(starRingEnd ℂ) τ)

tactic: simp_rw [jacobiTheta₂'_term, jacobiTheta₂_term, map_mul, ← Complex.exp_conj, map_add, map_mul,
  ← ofReal_intCast,← ofReal_ofNat, map_pow, conj_ofReal, conj_I]
state_before: case e_f.h
z τ : ℂ
n : ℤ
⊢ -(starRingEnd ℂ) (jacobiTheta₂'_term n z τ) = jacobiTheta₂'_term n (-(starRingEnd ℂ) z) (-(starRingEnd ℂ) τ)
state_after: case e_f.h
z τ : ℂ
n : ℤ
⊢ -(↑2 * ↑π * -I * ↑↑n * cexp (↑2 * ↑π * -I * ↑↑n * (starRingEnd ℂ) z + ↑π * -I * ↑↑n ^ 2 * (starRingEnd ℂ) τ)) =
    ↑2 * ↑π * I * ↑↑n * cexp (↑2 * ↑π * I * ↑↑n * -(starRingEnd ℂ) z + ↑π * I * ↑↑n ^ 2 * -(starRingEnd ℂ) τ)

tactic: ring_nf
state_before: case e_f.h
z τ : ℂ
n : ℤ
⊢ -(↑2 * ↑π * -I * ↑↑n * cexp (↑2 * ↑π * -I * ↑↑n * (starRingEnd ℂ) z + ↑π * -I * ↑↑n ^ 2 * (starRingEnd ℂ) τ)) =
    ↑2 * ↑π * I * ↑↑n * cexp (↑2 * ↑π * I * ↑↑n * -(starRingEnd ℂ) z + ↑π * I * ↑↑n ^ 2 * -(starRingEnd ℂ) τ)
state_after: no goals
Theorem: Finset.map_subtype_embedding_Ioo
File: Mathlib/Order/Interval/Finset/Defs.lean

tactic: rw [subtype_Ioo_eq]
state_before: α : Type u_1
β : Type u_2
inst✝² : Preorder α
p : α → Prop
inst✝¹ : DecidablePred p
inst✝ : LocallyFiniteOrder α
a b : Subtype p
hp : ∀ ⦃a b x : α⦄, a ≤ x → x ≤ b → p a → p b → p x
⊢ map (Embedding.subtype p) (Ioo a b) = Ioo ↑a ↑b
state_after: α : Type u_1
β : Type u_2
inst✝² : Preorder α
p : α → Prop
inst✝¹ : DecidablePred p
inst✝ : LocallyFiniteOrder α
a b : Subtype p
hp : ∀ ⦃a b x : α⦄, a ≤ x → x ≤ b → p a → p b → p x
⊢ map (Embedding.subtype p) (Finset.subtype p (Ioo ↑a ↑b)) = Ioo ↑a ↑b

tactic: refine Finset.subtype_map_of_mem fun x hx => ?_
state_before: α : Type u_1
β : Type u_2
inst✝² : Preorder α
p : α → Prop
inst✝¹ : DecidablePred p
inst✝ : LocallyFiniteOrder α
a b : Subtype p
hp : ∀ ⦃a b x : α⦄, a ≤ x → x ≤ b → p a → p b → p x
⊢ map (Embedding.subtype p) (Finset.subtype p (Ioo ↑a ↑b)) = Ioo ↑a ↑b
state_after: α : Type u_1
β : Type u_2
inst✝² : Preorder α
p : α → Prop
inst✝¹ : DecidablePred p
inst✝ : LocallyFiniteOrder α
a b : Subtype p
hp : ∀ ⦃a b x : α⦄, a ≤ x → x ≤ b → p a → p b → p x
x : α
hx : x ∈ Ioo ↑a ↑b
⊢ p x

tactic: rw [mem_Ioo] at hx
state_before: α : Type u_1
β : Type u_2
inst✝² : Preorder α
p : α → Prop
inst✝¹ : DecidablePred p
inst✝ : LocallyFiniteOrder α
a b : Subtype p
hp : ∀ ⦃a b x : α⦄, a ≤ x → x ≤ b → p a → p b → p x
x : α
hx : x ∈ Ioo ↑a ↑b
⊢ p x
state_after: α : Type u_1
β : Type u_2
inst✝² : Preorder α
p : α → Prop
inst✝¹ : DecidablePred p
inst✝ : LocallyFiniteOrder α
a b : Subtype p
hp : ∀ ⦃a b x : α⦄, a ≤ x → x ≤ b → p a → p b → p x
x : α
hx : ↑a < x ∧ x < ↑b
⊢ p x

tactic: exact hp hx.1.le hx.2.le a.prop b.prop
state_before: α : Type u_1
β : Type u_2
inst✝² : Preorder α
p : α → Prop
inst✝¹ : DecidablePred p
inst✝ : LocallyFiniteOrder α
a b : Subtype p
hp : ∀ ⦃a b x : α⦄, a ≤ x → x ≤ b → p a → p b → p x
x : α
hx : ↑a < x ∧ x < ↑b
⊢ p x
state_after: no goals
Theorem: Finsupp.single_eq_of_ne
File: Mathlib/Data/Finsupp/Defs.lean

tactic: classical exact Pi.single_eq_of_ne' h _
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝ : Zero M
a a' : α
b : M
h : a ≠ a'
⊢ (single a b) a' = 0
state_after: no goals

tactic: exact Pi.single_eq_of_ne' h _
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝ : Zero M
a a' : α
b : M
h : a ≠ a'
⊢ (single a b) a' = 0
state_after: no goals
Theorem: affineIndependent_iff_not_collinear_of_ne
File: Mathlib/LinearAlgebra/AffineSpace/FiniteDimensional.lean

tactic: have hu : (Finset.univ : Finset (Fin 3)) = {i₁, i₂, i₃} := by
  fin_cases i₁ <;> fin_cases i₂ <;> fin_cases i₃
    <;> simp (config := {decide := true}) only at h₁₂ h₁₃ h₂₃ ⊢
state_before: k : Type u_1
V : Type u_2
P : Type u_3
ι : Type u_4
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
p : Fin 3 → P
i₁ i₂ i₃ : Fin 3
h₁₂ : i₁ ≠ i₂
h₁₃ : i₁ ≠ i₃
h₂₃ : i₂ ≠ i₃
⊢ AffineIndependent k p ↔ ¬Collinear k {p i₁, p i₂, p i₃}
state_after: k : Type u_1
V : Type u_2
P : Type u_3
ι : Type u_4
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
p : Fin 3 → P
i₁ i₂ i₃ : Fin 3
h₁₂ : i₁ ≠ i₂
h₁₃ : i₁ ≠ i₃
h₂₃ : i₂ ≠ i₃
hu : Finset.univ = {i₁, i₂, i₃}
⊢ AffineIndependent k p ↔ ¬Collinear k {p i₁, p i₂, p i₃}

tactic: rw [affineIndependent_iff_not_collinear, ← Set.image_univ, ← Finset.coe_univ, hu,
  Finset.coe_insert, Finset.coe_insert, Finset.coe_singleton, Set.image_insert_eq, Set.image_pair]
state_before: k : Type u_1
V : Type u_2
P : Type u_3
ι : Type u_4
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
p : Fin 3 → P
i₁ i₂ i₃ : Fin 3
h₁₂ : i₁ ≠ i₂
h₁₃ : i₁ ≠ i₃
h₂₃ : i₂ ≠ i₃
hu : Finset.univ = {i₁, i₂, i₃}
⊢ AffineIndependent k p ↔ ¬Collinear k {p i₁, p i₂, p i₃}
state_after: no goals

tactic: fin_cases i₁ <;> fin_cases i₂ <;> fin_cases i₃
  <;> simp (config := {decide := true}) only at h₁₂ h₁₃ h₂₃ ⊢
state_before: k : Type u_1
V : Type u_2
P : Type u_3
ι : Type u_4
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
p : Fin 3 → P
i₁ i₂ i₃ : Fin 3
h₁₂ : i₁ ≠ i₂
h₁₃ : i₁ ≠ i₃
h₂₃ : i₂ ≠ i₃
⊢ Finset.univ = {i₁, i₂, i₃}
state_after: no goals
Theorem: Int.gcd_zero_left
File: Mathlib/Data/Int/GCD.lean

tactic: simp [gcd]
state_before: i : ℤ
⊢ gcd 0 i = i.natAbs
state_after: no goals
Theorem: MeasureTheory.Measure.map_fst_prod
File: Mathlib/MeasureTheory/Constructions/Prod/Basic.lean

tactic: ext s hs
state_before: α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
E : Type u_6
inst✝⁶ : MeasurableSpace α
inst✝⁵ : MeasurableSpace α'
inst✝⁴ : MeasurableSpace β
inst✝³ : MeasurableSpace β'
inst✝² : MeasurableSpace γ
μ μ' : Measure α
ν ν' : Measure β
τ : Measure γ
inst✝¹ : NormedAddCommGroup E
inst✝ : SFinite ν
⊢ map Prod.fst (μ.prod ν) = ν univ • μ
state_after: case h
α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
E : Type u_6
inst✝⁶ : MeasurableSpace α
inst✝⁵ : MeasurableSpace α'
inst✝⁴ : MeasurableSpace β
inst✝³ : MeasurableSpace β'
inst✝² : MeasurableSpace γ
μ μ' : Measure α
ν ν' : Measure β
τ : Measure γ
inst✝¹ : NormedAddCommGroup E
inst✝ : SFinite ν
s : Set α
hs : MeasurableSet s
⊢ (map Prod.fst (μ.prod ν)) s = (ν univ • μ) s

tactic: simp [Measure.map_apply measurable_fst hs, ← prod_univ, mul_comm]
state_before: case h
α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
E : Type u_6
inst✝⁶ : MeasurableSpace α
inst✝⁵ : MeasurableSpace α'
inst✝⁴ : MeasurableSpace β
inst✝³ : MeasurableSpace β'
inst✝² : MeasurableSpace γ
μ μ' : Measure α
ν ν' : Measure β
τ : Measure γ
inst✝¹ : NormedAddCommGroup E
inst✝ : SFinite ν
s : Set α
hs : MeasurableSet s
⊢ (map Prod.fst (μ.prod ν)) s = (ν univ • μ) s
state_after: no goals
Theorem: Finset.range_add_eq_union
File: Mathlib/Order/Interval/Finset/Nat.lean

tactic: rw [Finset.range_eq_Ico, map_eq_image]
state_before: a b c : ℕ
⊢ range (a + b) = range a ∪ map (addLeftEmbedding a) (range b)
state_after: a b c : ℕ
⊢ Ico 0 (a + b) = Ico 0 a ∪ image (⇑(addLeftEmbedding a)) (Ico 0 b)

tactic: convert (Ico_union_Ico_eq_Ico a.zero_le (a.le_add_right b)).symm
state_before: a b c : ℕ
⊢ Ico 0 (a + b) = Ico 0 a ∪ image (⇑(addLeftEmbedding a)) (Ico 0 b)
state_after: case h.e'_3.h.e'_4
a b c : ℕ
⊢ image (⇑(addLeftEmbedding a)) (Ico 0 b) = Ico a (a + b)

tactic: ext x
state_before: case h.e'_3.h.e'_4
a b c : ℕ
⊢ image (⇑(addLeftEmbedding a)) (Ico 0 b) = Ico a (a + b)
state_after: case h.e'_3.h.e'_4.a
a b c x : ℕ
⊢ x ∈ image (⇑(addLeftEmbedding a)) (Ico 0 b) ↔ x ∈ Ico a (a + b)

tactic: simp only [Ico_zero_eq_range, mem_image, mem_range, addLeftEmbedding_apply, mem_Ico]
state_before: case h.e'_3.h.e'_4.a
a b c x : ℕ
⊢ x ∈ image (⇑(addLeftEmbedding a)) (Ico 0 b) ↔ x ∈ Ico a (a + b)
state_after: case h.e'_3.h.e'_4.a
a b c x : ℕ
⊢ (∃ a_1 < b, a + a_1 = x) ↔ a ≤ x ∧ x < a + b

tactic: constructor
state_before: case h.e'_3.h.e'_4.a
a b c x : ℕ
⊢ (∃ a_1 < b, a + a_1 = x) ↔ a ≤ x ∧ x < a + b
state_after: case h.e'_3.h.e'_4.a.mp
a b c x : ℕ
⊢ (∃ a_1 < b, a + a_1 = x) → a ≤ x ∧ x < a + b

case h.e'_3.h.e'_4.a.mpr
a b c x : ℕ
⊢ a ≤ x ∧ x < a + b → ∃ a_2 < b, a + a_2 = x

tactic: aesop
state_before: case h.e'_3.h.e'_4.a.mp
a b c x : ℕ
⊢ (∃ a_1 < b, a + a_1 = x) → a ≤ x ∧ x < a + b
state_after: no goals

tactic: rintro h
state_before: case h.e'_3.h.e'_4.a.mpr
a b c x : ℕ
⊢ a ≤ x ∧ x < a + b → ∃ a_2 < b, a + a_2 = x
state_after: case h.e'_3.h.e'_4.a.mpr
a b c x : ℕ
h : a ≤ x ∧ x < a + b
⊢ ∃ a_1 < b, a + a_1 = x

tactic: exact ⟨x - a, by omega⟩
state_before: case h.e'_3.h.e'_4.a.mpr
a b c x : ℕ
h : a ≤ x ∧ x < a + b
⊢ ∃ a_1 < b, a + a_1 = x
state_after: no goals

tactic: omega
state_before: a b c x : ℕ
h : a ≤ x ∧ x < a + b
⊢ x - a < b ∧ a + (x - a) = x
state_after: no goals
Theorem: add_tsub_add_le_tsub_left
File: Mathlib/Algebra/Order/Sub/Defs.lean

tactic: rw [tsub_le_iff_left, add_assoc]
state_before: α : Type u_1
β : Type u_2
inst✝⁴ : Preorder α
inst✝³ : AddCommSemigroup α
inst✝² : Sub α
inst✝¹ : OrderedSub α
a b c d : α
inst✝ : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
⊢ a + b - (a + c) ≤ b - c
state_after: α : Type u_1
β : Type u_2
inst✝⁴ : Preorder α
inst✝³ : AddCommSemigroup α
inst✝² : Sub α
inst✝¹ : OrderedSub α
a b c d : α
inst✝ : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
⊢ a + b ≤ a + (c + (b - c))

tactic: exact add_le_add_left le_add_tsub _
state_before: α : Type u_1
β : Type u_2
inst✝⁴ : Preorder α
inst✝³ : AddCommSemigroup α
inst✝² : Sub α
inst✝¹ : OrderedSub α
a b c d : α
inst✝ : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
⊢ a + b ≤ a + (c + (b - c))
state_after: no goals
Theorem: CategoryTheory.Bifunctor.diagonal
File: Mathlib/CategoryTheory/Products/Bifunctor.lean

tactic: rw [← Functor.map_comp, prod_comp, Category.id_comp, Category.comp_id]
state_before: C : Type u₁
D : Type u₂
E : Type u₃
inst✝² : Category.{v₁, u₁} C
inst✝¹ : Category.{v₂, u₂} D
inst✝ : Category.{v₃, u₃} E
F : C × D ⥤ E
X X' : C
f : X ⟶ X'
Y Y' : D
g : Y ⟶ Y'
⊢ F.map (𝟙 X, g) ≫ F.map (f, 𝟙 Y') = F.map (f, g)
state_after: no goals
Theorem: MvPolynomial.comap_id
File: Mathlib/Algebra/MvPolynomial/Comap.lean

tactic: funext x
state_before: σ : Type u_1
τ : Type u_2
υ : Type u_3
R : Type u_4
inst✝ : CommSemiring R
⊢ comap (AlgHom.id R (MvPolynomial σ R)) = id
state_after: case h
σ : Type u_1
τ : Type u_2
υ : Type u_3
R : Type u_4
inst✝ : CommSemiring R
x : σ → R
⊢ comap (AlgHom.id R (MvPolynomial σ R)) x = id x

tactic: exact comap_id_apply x
state_before: case h
σ : Type u_1
τ : Type u_2
υ : Type u_3
R : Type u_4
inst✝ : CommSemiring R
x : σ → R
⊢ comap (AlgHom.id R (MvPolynomial σ R)) x = id x
state_after: no goals
Theorem: CategoryTheory.Monad.MonadicityInternal.comparisonAdjunction_counit_app
File: Mathlib/CategoryTheory/Monad/Monadicity.lean

tactic: apply coequalizer.hom_ext
state_before: C : Type u₁
D : Type u₂
inst✝² : Category.{v₁, u₁} C
inst✝¹ : Category.{v₁, u₂} D
G : D ⥤ C
F : C ⥤ D
adj : F ⊣ G
inst✝ : ∀ (A : adj.toMonad.Algebra), HasCoequalizer (F.map A.a) (adj.counit.app (F.obj A.A))
B : D
⊢ (comparisonAdjunction adj).counit.app B =
    colimit.desc (parallelPair (F.map (G.map (adj.counit.app B))) (adj.counit.app (F.obj (G.obj B))))
      (counitCofork adj B)
state_after: case h
C : Type u₁
D : Type u₂
inst✝² : Category.{v₁, u₁} C
inst✝¹ : Category.{v₁, u₂} D
G : D ⥤ C
F : C ⥤ D
adj : F ⊣ G
inst✝ : ∀ (A : adj.toMonad.Algebra), HasCoequalizer (F.map A.a) (adj.counit.app (F.obj A.A))
B : D
⊢ coequalizer.π (F.map ((comparison adj).obj B).a) (adj.counit.app (F.obj ((comparison adj).obj B).A)) ≫
      (comparisonAdjunction adj).counit.app B =
    coequalizer.π (F.map ((comparison adj).obj B).a) (adj.counit.app (F.obj ((comparison adj).obj B).A)) ≫
      colimit.desc (parallelPair (F.map (G.map (adj.counit.app B))) (adj.counit.app (F.obj (G.obj B))))
        (counitCofork adj B)

tactic: change
  coequalizer.π _ _ ≫ coequalizer.desc ((adj.homEquiv _ B).symm (𝟙 _)) _ =
    coequalizer.π _ _ ≫ coequalizer.desc _ _
state_before: case h
C : Type u₁
D : Type u₂
inst✝² : Category.{v₁, u₁} C
inst✝¹ : Category.{v₁, u₂} D
G : D ⥤ C
F : C ⥤ D
adj : F ⊣ G
inst✝ : ∀ (A : adj.toMonad.Algebra), HasCoequalizer (F.map A.a) (adj.counit.app (F.obj A.A))
B : D
⊢ coequalizer.π (F.map ((comparison adj).obj B).a) (adj.counit.app (F.obj ((comparison adj).obj B).A)) ≫
      (comparisonAdjunction adj).counit.app B =
    coequalizer.π (F.map ((comparison adj).obj B).a) (adj.counit.app (F.obj ((comparison adj).obj B).A)) ≫
      colimit.desc (parallelPair (F.map (G.map (adj.counit.app B))) (adj.counit.app (F.obj (G.obj B))))
        (counitCofork adj B)
state_after: case h
C : Type u₁
D : Type u₂
inst✝² : Category.{v₁, u₁} C
inst✝¹ : Category.{v₁, u₂} D
G : D ⥤ C
F : C ⥤ D
adj : F ⊣ G
inst✝ : ∀ (A : adj.toMonad.Algebra), HasCoequalizer (F.map A.a) (adj.counit.app (F.obj A.A))
B : D
⊢ coequalizer.π (F.map ((comparison adj).obj B).a) (adj.counit.app (F.obj ((comparison adj).obj B).A)) ≫
      coequalizer.desc ((adj.homEquiv (G.obj B) B).symm (𝟙 (G.obj B))) ⋯ =
    coequalizer.π (F.map ((comparison adj).obj B).a) (adj.counit.app (F.obj ((comparison adj).obj B).A)) ≫
      coequalizer.desc (adj.counit.app B) ⋯

tactic: simp
state_before: case h
C : Type u₁
D : Type u₂
inst✝² : Category.{v₁, u₁} C
inst✝¹ : Category.{v₁, u₂} D
G : D ⥤ C
F : C ⥤ D
adj : F ⊣ G
inst✝ : ∀ (A : adj.toMonad.Algebra), HasCoequalizer (F.map A.a) (adj.counit.app (F.obj A.A))
B : D
⊢ coequalizer.π (F.map ((comparison adj).obj B).a) (adj.counit.app (F.obj ((comparison adj).obj B).A)) ≫
      coequalizer.desc ((adj.homEquiv (G.obj B) B).symm (𝟙 (G.obj B))) ⋯ =
    coequalizer.π (F.map ((comparison adj).obj B).a) (adj.counit.app (F.obj ((comparison adj).obj B).A)) ≫
      coequalizer.desc (adj.counit.app B) ⋯
state_after: no goals
Theorem: Monoid.CoprodI.Word.mem_of_mem_equivPair_tail
File: Mathlib/GroupTheory/CoprodI.lean

tactic: rw [mem_equivPair_tail_iff]
state_before: ι : Type u_1
M : ι → Type u_2
inst✝³ : (i : ι) → Monoid (M i)
N : Type u_3
inst✝² : Monoid N
inst✝¹ : (i : ι) → DecidableEq (M i)
inst✝ : DecidableEq ι
i j : ι
w : Word M
m : M i
⊢ ⟨i, m⟩ ∈ ((equivPair j) w).tail.toList → ⟨i, m⟩ ∈ w.toList
state_after: ι : Type u_1
M : ι → Type u_2
inst✝³ : (i : ι) → Monoid (M i)
N : Type u_3
inst✝² : Monoid N
inst✝¹ : (i : ι) → DecidableEq (M i)
inst✝ : DecidableEq ι
i j : ι
w : Word M
m : M i
⊢ (⟨i, m⟩ ∈ w.toList.tail ∨ i ≠ j ∧ ∃ (h : w.toList ≠ []), w.toList.head h = ⟨i, m⟩) → ⟨i, m⟩ ∈ w.toList

tactic: rintro (h | h)
state_before: ι : Type u_1
M : ι → Type u_2
inst✝³ : (i : ι) → Monoid (M i)
N : Type u_3
inst✝² : Monoid N
inst✝¹ : (i : ι) → DecidableEq (M i)
inst✝ : DecidableEq ι
i j : ι
w : Word M
m : M i
⊢ (⟨i, m⟩ ∈ w.toList.tail ∨ i ≠ j ∧ ∃ (h : w.toList ≠ []), w.toList.head h = ⟨i, m⟩) → ⟨i, m⟩ ∈ w.toList
state_after: case inl
ι : Type u_1
M : ι → Type u_2
inst✝³ : (i : ι) → Monoid (M i)
N : Type u_3
inst✝² : Monoid N
inst✝¹ : (i : ι) → DecidableEq (M i)
inst✝ : DecidableEq ι
i j : ι
w : Word M
m : M i
h : ⟨i, m⟩ ∈ w.toList.tail
⊢ ⟨i, m⟩ ∈ w.toList

case inr
ι : Type u_1
M : ι → Type u_2
inst✝³ : (i : ι) → Monoid (M i)
N : Type u_3
inst✝² : Monoid N
inst✝¹ : (i : ι) → DecidableEq (M i)
inst✝ : DecidableEq ι
i j : ι
w : Word M
m : M i
h : i ≠ j ∧ ∃ (h : w.toList ≠ []), w.toList.head h = ⟨i, m⟩
⊢ ⟨i, m⟩ ∈ w.toList

tactic: exact List.mem_of_mem_tail h
state_before: case inl
ι : Type u_1
M : ι → Type u_2
inst✝³ : (i : ι) → Monoid (M i)
N : Type u_3
inst✝² : Monoid N
inst✝¹ : (i : ι) → DecidableEq (M i)
inst✝ : DecidableEq ι
i j : ι
w : Word M
m : M i
h : ⟨i, m⟩ ∈ w.toList.tail
⊢ ⟨i, m⟩ ∈ w.toList
state_after: no goals

tactic: revert h
state_before: case inr
ι : Type u_1
M : ι → Type u_2
inst✝³ : (i : ι) → Monoid (M i)
N : Type u_3
inst✝² : Monoid N
inst✝¹ : (i : ι) → DecidableEq (M i)
inst✝ : DecidableEq ι
i j : ι
w : Word M
m : M i
h : i ≠ j ∧ ∃ (h : w.toList ≠ []), w.toList.head h = ⟨i, m⟩
⊢ ⟨i, m⟩ ∈ w.toList
state_after: case inr
ι : Type u_1
M : ι → Type u_2
inst✝³ : (i : ι) → Monoid (M i)
N : Type u_3
inst✝² : Monoid N
inst✝¹ : (i : ι) → DecidableEq (M i)
inst✝ : DecidableEq ι
i j : ι
w : Word M
m : M i
⊢ (i ≠ j ∧ ∃ (h : w.toList ≠ []), w.toList.head h = ⟨i, m⟩) → ⟨i, m⟩ ∈ w.toList

tactic: cases w.toList <;> simp (config := {contextual := true})
state_before: case inr
ι : Type u_1
M : ι → Type u_2
inst✝³ : (i : ι) → Monoid (M i)
N : Type u_3
inst✝² : Monoid N
inst✝¹ : (i : ι) → DecidableEq (M i)
inst✝ : DecidableEq ι
i j : ι
w : Word M
m : M i
⊢ (i ≠ j ∧ ∃ (h : w.toList ≠ []), w.toList.head h = ⟨i, m⟩) → ⟨i, m⟩ ∈ w.toList
state_after: no goals
Theorem: IsMetricSeparated.disjoint
File: Mathlib/Topology/MetricSpace/MetricSeparated.lean

tactic: simpa using hr x hx1 x hx2
state_before: X : Type u_1
inst✝ : EMetricSpace X
s t : Set X
x✝ y : X
h : IsMetricSeparated s t
r : ENNReal
r0 : r ≠ 0
hr : ∀ x ∈ s, ∀ y ∈ t, r ≤ edist x y
x : X
hx1 : x ∈ s
hx2 : x ∈ t
⊢ r = 0
state_after: no goals
Theorem: BooleanRing.inf_sup_self
File: Mathlib/Algebra/Ring/BooleanRing.lean

tactic: rw [mul_add, mul_add, mul_self, ← mul_assoc, mul_self, add_assoc, add_self, add_zero]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : BooleanRing α
inst✝¹ : BooleanRing β
inst✝ : BooleanRing γ
a b : α
⊢ a * (a + b + a * b) = a
state_after: no goals
Theorem: AlgebraicGeometry.Scheme.inv_app
File: Mathlib/AlgebraicGeometry/Scheme.lean

tactic: rw [IsIso.hom_inv_id]
state_before: X Y : Scheme
f : X ⟶ Y
inst✝ : IsIso f
U : Opens ↑↑X.toPresheafedSpace
⊢ (f ≫ inv f) ⁻¹ᵁ U = U
state_after: X Y : Scheme
f : X ⟶ Y
inst✝ : IsIso f
U : Opens ↑↑X.toPresheafedSpace
⊢ 𝟙 X ⁻¹ᵁ U = U

tactic: rfl
state_before: X Y : Scheme
f : X ⟶ Y
inst✝ : IsIso f
U : Opens ↑↑X.toPresheafedSpace
⊢ 𝟙 X ⁻¹ᵁ U = U
state_after: no goals

tactic: rw [IsIso.eq_comp_inv, ← Scheme.comp_app, Scheme.congr_app (IsIso.hom_inv_id f),
  Scheme.id_app, Category.id_comp]
state_before: X Y : Scheme
f : X ⟶ Y
inst✝ : IsIso f
U : Opens ↑↑X.toPresheafedSpace
⊢ Hom.app (inv f) U = X.presheaf.map (eqToHom ⋯).op ≫ inv (Hom.app f (inv f ⁻¹ᵁ U))
state_after: no goals
Theorem: Finset.sup_eq_top_iff
File: Mathlib/Data/Finset/Lattice.lean

tactic: simp only [← top_le_iff]
state_before: F : Type u_1
α✝ : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝⁴ : LinearOrder α✝
inst✝³ : OrderBot α✝
s✝ : Finset ι
f✝ : ι → α✝
a : α✝
α : Type u_7
inst✝² : LinearOrder α
inst✝¹ : BoundedOrder α
inst✝ : Nontrivial α
s : Finset ι
f : ι → α
⊢ s.sup f = ⊤ ↔ ∃ b ∈ s, f b = ⊤
state_after: F : Type u_1
α✝ : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝⁴ : LinearOrder α✝
inst✝³ : OrderBot α✝
s✝ : Finset ι
f✝ : ι → α✝
a : α✝
α : Type u_7
inst✝² : LinearOrder α
inst✝¹ : BoundedOrder α
inst✝ : Nontrivial α
s : Finset ι
f : ι → α
⊢ ⊤ ≤ s.sup f ↔ ∃ b ∈ s, ⊤ ≤ f b

tactic: exact Finset.le_sup_iff bot_lt_top
state_before: F : Type u_1
α✝ : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝⁴ : LinearOrder α✝
inst✝³ : OrderBot α✝
s✝ : Finset ι
f✝ : ι → α✝
a : α✝
α : Type u_7
inst✝² : LinearOrder α
inst✝¹ : BoundedOrder α
inst✝ : Nontrivial α
s : Finset ι
f : ι → α
⊢ ⊤ ≤ s.sup f ↔ ∃ b ∈ s, ⊤ ≤ f b
state_after: no goals
Theorem: NNReal.norm_eq
File: Mathlib/Analysis/Normed/Field/Basic.lean

tactic: rw [Real.norm_eq_abs, x.abs_eq]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
x : ℝ≥0
⊢ ‖↑x‖ = ↑x
state_after: no goals
Theorem: CategoryTheory.isIso_right_of_isIso_biprod_map
File: Mathlib/CategoryTheory/Limits/Shapes/Biproducts.lean

tactic: rw [← biprod.braiding_map_braiding]
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
inst✝¹ : HasBinaryBiproducts C
W X Y Z : C
f : W ⟶ Y
g : X ⟶ Z
inst✝ : IsIso (biprod.map f g)
⊢ IsIso (biprod.map g f)
state_after: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
inst✝¹ : HasBinaryBiproducts C
W X Y Z : C
f : W ⟶ Y
g : X ⟶ Z
inst✝ : IsIso (biprod.map f g)
⊢ IsIso ((biprod.braiding X W).hom ≫ biprod.map f g ≫ (biprod.braiding Y Z).hom)

tactic: infer_instance
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
inst✝¹ : HasBinaryBiproducts C
W X Y Z : C
f : W ⟶ Y
g : X ⟶ Z
inst✝ : IsIso (biprod.map f g)
⊢ IsIso ((biprod.braiding X W).hom ≫ biprod.map f g ≫ (biprod.braiding Y Z).hom)
state_after: no goals
Theorem: Multiset.toFinset_subset
File: Mathlib/Data/Finset/Basic.lean

tactic: simp only [Finset.subset_iff, Multiset.subset_iff, Multiset.mem_toFinset]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s t : Multiset α
⊢ s.toFinset ⊆ t.toFinset ↔ s ⊆ t
state_after: no goals
Theorem: Set.powerset_singleton
File: Mathlib/Data/Set/Basic.lean

tactic: ext y
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s s₁ s₂ t t₁ t₂ u : Set α
x : α
⊢ 𝒫{x} = {∅, {x}}
state_after: case h
α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s s₁ s₂ t t₁ t₂ u : Set α
x : α
y : Set α
⊢ y ∈ 𝒫{x} ↔ y ∈ {∅, {x}}

tactic: rw [mem_powerset_iff, subset_singleton_iff_eq, mem_insert_iff, mem_singleton_iff]
state_before: case h
α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s s₁ s₂ t t₁ t₂ u : Set α
x : α
y : Set α
⊢ y ∈ 𝒫{x} ↔ y ∈ {∅, {x}}
state_after: no goals