1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: powersEquivPowers_apply
File: Mathlib/GroupTheory/OrderOfElement.lean

tactic: rw [powersEquivPowers, Equiv.trans_apply, Equiv.trans_apply, finEquivPowers_symm_apply, ←
  Equiv.eq_symm_apply, finEquivPowers_symm_apply]
state_before: G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝¹ : LeftCancelMonoid G
inst✝ : Finite G
x y : G
n✝ : ℕ
h : orderOf x = orderOf y
n : ℕ
⊢ (powersEquivPowers h) ⟨x ^ n, ⋯⟩ = ⟨y ^ n, ⋯⟩
state_after: G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝¹ : LeftCancelMonoid G
inst✝ : Finite G
x y : G
n✝ : ℕ
h : orderOf x = orderOf y
n : ℕ
⊢ (finCongr h) ⟨n % orderOf x, ⋯⟩ = ⟨n % orderOf y, ⋯⟩

tactic: simp [h]
state_before: G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝¹ : LeftCancelMonoid G
inst✝ : Finite G
x y : G
n✝ : ℕ
h : orderOf x = orderOf y
n : ℕ
⊢ (finCongr h) ⟨n % orderOf x, ⋯⟩ = ⟨n % orderOf y, ⋯⟩
state_after: no goals
Theorem: QuadraticForm.polar_add_left_iff
File: Mathlib/LinearAlgebra/QuadraticForm/Basic.lean

tactic: simp only [← add_assoc]
state_before: S : Type u_1
T : Type u_2
R : Type u_3
M : Type u_4
N : Type u_5
inst✝¹ : CommRing R
inst✝ : AddCommGroup M
f : M → R
x x' y : M
⊢ polar f (x + x') y = polar f x y + polar f x' y ↔
    f (x + x' + y) + (f x + f x' + f y) = f (x + x') + f (x' + y) + f (y + x)
state_after: S : Type u_1
T : Type u_2
R : Type u_3
M : Type u_4
N : Type u_5
inst✝¹ : CommRing R
inst✝ : AddCommGroup M
f : M → R
x x' y : M
⊢ polar f (x + x') y = polar f x y + polar f x' y ↔
    f (x + x' + y) + f x + f x' + f y = f (x + x') + f (x' + y) + f (y + x)

tactic: simp only [polar, sub_eq_iff_eq_add, eq_sub_iff_add_eq, sub_add_eq_add_sub, add_sub]
state_before: S : Type u_1
T : Type u_2
R : Type u_3
M : Type u_4
N : Type u_5
inst✝¹ : CommRing R
inst✝ : AddCommGroup M
f : M → R
x x' y : M
⊢ polar f (x + x') y = polar f x y + polar f x' y ↔
    f (x + x' + y) + f x + f x' + f y = f (x + x') + f (x' + y) + f (y + x)
state_after: S : Type u_1
T : Type u_2
R : Type u_3
M : Type u_4
N : Type u_5
inst✝¹ : CommRing R
inst✝ : AddCommGroup M
f : M → R
x x' y : M
⊢ f (x + x' + y) + f y + f x' + f y + f x = f (x + y) + f (x' + y) + f y + f (x + x') ↔
    f (x + x' + y) + f x + f x' + f y = f (x + x') + f (x' + y) + f (y + x)

tactic: simp only [add_right_comm _ (f y) _, add_right_comm _ (f x') (f x)]
state_before: S : Type u_1
T : Type u_2
R : Type u_3
M : Type u_4
N : Type u_5
inst✝¹ : CommRing R
inst✝ : AddCommGroup M
f : M → R
x x' y : M
⊢ f (x + x' + y) + f y + f x' + f y + f x = f (x + y) + f (x' + y) + f y + f (x + x') ↔
    f (x + x' + y) + f x + f x' + f y = f (x + x') + f (x' + y) + f (y + x)
state_after: S : Type u_1
T : Type u_2
R : Type u_3
M : Type u_4
N : Type u_5
inst✝¹ : CommRing R
inst✝ : AddCommGroup M
f : M → R
x x' y : M
⊢ f (x + x' + y) + f x + f x' + f y + f y = f (x + y) + f (x' + y) + f (x + x') + f y ↔
    f (x + x' + y) + f x + f x' + f y = f (x + x') + f (x' + y) + f (y + x)

tactic: rw [add_comm y x, add_right_comm _ _ (f (x + y)), add_comm _ (f (x + y)),
  add_right_comm (f (x + y)), add_left_inj]
state_before: S : Type u_1
T : Type u_2
R : Type u_3
M : Type u_4
N : Type u_5
inst✝¹ : CommRing R
inst✝ : AddCommGroup M
f : M → R
x x' y : M
⊢ f (x + x' + y) + f x + f x' + f y + f y = f (x + y) + f (x' + y) + f (x + x') + f y ↔
    f (x + x' + y) + f x + f x' + f y = f (x + x') + f (x' + y) + f (y + x)
state_after: no goals
Theorem: AdjoinRoot.eval₂_root
File: Mathlib/RingTheory/AdjoinRoot.lean

tactic: rw [← algebraMap_eq, ← aeval_def, aeval_eq, mk_self]
state_before: R : Type u
S : Type v
K : Type w
inst✝ : CommRing R
f✝ f : R[X]
⊢ eval₂ (of f) (root f) f = 0
state_after: no goals
Theorem: conj_pow
File: Mathlib/Algebra/Group/Conj.lean

tactic: induction' i with i hi
state_before: α : Type u
β : Type v
inst✝ : Group α
i : ℕ
a b : α
⊢ (a * b * a⁻¹) ^ i = a * b ^ i * a⁻¹
state_after: case zero
α : Type u
β : Type v
inst✝ : Group α
a b : α
⊢ (a * b * a⁻¹) ^ 0 = a * b ^ 0 * a⁻¹

case succ
α : Type u
β : Type v
inst✝ : Group α
a b : α
i : ℕ
hi : (a * b * a⁻¹) ^ i = a * b ^ i * a⁻¹
⊢ (a * b * a⁻¹) ^ (i + 1) = a * b ^ (i + 1) * a⁻¹

tactic: simp
state_before: case zero
α : Type u
β : Type v
inst✝ : Group α
a b : α
⊢ (a * b * a⁻¹) ^ 0 = a * b ^ 0 * a⁻¹
state_after: no goals

tactic: simp [pow_succ, hi]
state_before: case succ
α : Type u
β : Type v
inst✝ : Group α
a b : α
i : ℕ
hi : (a * b * a⁻¹) ^ i = a * b ^ i * a⁻¹
⊢ (a * b * a⁻¹) ^ (i + 1) = a * b ^ (i + 1) * a⁻¹
state_after: no goals
Theorem: Int.Ico_filter_modEq_card
File: Mathlib/Data/Int/CardIntervalMod.lean

tactic: simp [Ico_filter_modEq_eq, Ico_filter_dvd_eq, toNat_eq_max, hr]
state_before: a b r : ℤ
hr : 0 < r
v : ℤ
⊢ ↑(filter (fun x => x ≡ v [ZMOD r]) (Ico a b)).card = max (⌈(↑b - ↑v) / ↑r⌉ - ⌈(↑a - ↑v) / ↑r⌉) 0
state_after: no goals
Theorem: HomologicalComplex.cyclesIsoSc'_hom_iCycles
File: Mathlib/Algebra/Homology/ShortComplex/HomologicalComplex.lean

tactic: dsimp [cyclesIsoSc']
state_before: C : Type u_1
inst✝³ : Category.{u_3, u_1} C
inst✝² : HasZeroMorphisms C
ι : Type u_2
c : ComplexShape ι
K : HomologicalComplex C c
i j k : ι
hi : c.prev j = i
hk : c.next j = k
inst✝¹ : K.HasHomology j
inst✝ : (K.sc' i j k).HasHomology
⊢ (K.cyclesIsoSc' i j k hi hk).hom ≫ (K.sc' i j k).iCycles = K.iCycles j
state_after: C : Type u_1
inst✝³ : Category.{u_3, u_1} C
inst✝² : HasZeroMorphisms C
ι : Type u_2
c : ComplexShape ι
K : HomologicalComplex C c
i j k : ι
hi : c.prev j = i
hk : c.next j = k
inst✝¹ : K.HasHomology j
inst✝ : (K.sc' i j k).HasHomology
⊢ ShortComplex.cyclesMap ((natIsoSc' C c i j k hi hk).hom.app K) ≫ (K.sc' i j k).iCycles = K.iCycles j

tactic: simp only [ShortComplex.cyclesMap_i, shortComplexFunctor_obj_X₂, shortComplexFunctor'_obj_X₂,
  natIsoSc'_hom_app_τ₂, comp_id]
state_before: C : Type u_1
inst✝³ : Category.{u_3, u_1} C
inst✝² : HasZeroMorphisms C
ι : Type u_2
c : ComplexShape ι
K : HomologicalComplex C c
i j k : ι
hi : c.prev j = i
hk : c.next j = k
inst✝¹ : K.HasHomology j
inst✝ : (K.sc' i j k).HasHomology
⊢ ShortComplex.cyclesMap ((natIsoSc' C c i j k hi hk).hom.app K) ≫ (K.sc' i j k).iCycles = K.iCycles j
state_after: C : Type u_1
inst✝³ : Category.{u_3, u_1} C
inst✝² : HasZeroMorphisms C
ι : Type u_2
c : ComplexShape ι
K : HomologicalComplex C c
i j k : ι
hi : c.prev j = i
hk : c.next j = k
inst✝¹ : K.HasHomology j
inst✝ : (K.sc' i j k).HasHomology
⊢ (K.sc j).iCycles = K.iCycles j

tactic: rfl
state_before: C : Type u_1
inst✝³ : Category.{u_3, u_1} C
inst✝² : HasZeroMorphisms C
ι : Type u_2
c : ComplexShape ι
K : HomologicalComplex C c
i j k : ι
hi : c.prev j = i
hk : c.next j = k
inst✝¹ : K.HasHomology j
inst✝ : (K.sc' i j k).HasHomology
⊢ (K.sc j).iCycles = K.iCycles j
state_after: no goals
Theorem: Stream'.Seq.mem_append_left
File: Mathlib/Data/Seq/Seq.lean

tactic: apply mem_rec_on h
state_before: α : Type u
β : Type v
γ : Type w
s₁ s₂ : Seq α
a : α
h : a ∈ s₁
⊢ a ∈ s₁.append s₂
state_after: α : Type u
β : Type v
γ : Type w
s₁ s₂ : Seq α
a : α
h : a ∈ s₁
⊢ ∀ (b : α) (s' : Seq α), a = b ∨ a ∈ s'.append s₂ → a ∈ (cons b s').append s₂

tactic: intros
state_before: α : Type u
β : Type v
γ : Type w
s₁ s₂ : Seq α
a : α
h : a ∈ s₁
⊢ ∀ (b : α) (s' : Seq α), a = b ∨ a ∈ s'.append s₂ → a ∈ (cons b s').append s₂
state_after: α : Type u
β : Type v
γ : Type w
s₁ s₂ : Seq α
a : α
h : a ∈ s₁
b✝ : α
s'✝ : Seq α
a✝ : a = b✝ ∨ a ∈ s'✝.append s₂
⊢ a ∈ (cons b✝ s'✝).append s₂

tactic: simp [*]
state_before: α : Type u
β : Type v
γ : Type w
s₁ s₂ : Seq α
a : α
h : a ∈ s₁
b✝ : α
s'✝ : Seq α
a✝ : a = b✝ ∨ a ∈ s'✝.append s₂
⊢ a ∈ (cons b✝ s'✝).append s₂
state_after: no goals
Theorem: Interval.disjoint_coe
File: Mathlib/Order/Interval/Basic.lean

tactic: classical
  rw [disjoint_iff_inf_le, disjoint_iff_inf_le, ← coe_subset_coe, coe_inf]
  rfl
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
κ : ι → Sort u_6
inst✝ : Lattice α
s t : Interval α
⊢ Disjoint ↑s ↑t ↔ Disjoint s t
state_after: no goals

tactic: rw [disjoint_iff_inf_le, disjoint_iff_inf_le, ← coe_subset_coe, coe_inf]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
κ : ι → Sort u_6
inst✝ : Lattice α
s t : Interval α
⊢ Disjoint ↑s ↑t ↔ Disjoint s t
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
κ : ι → Sort u_6
inst✝ : Lattice α
s t : Interval α
⊢ ↑s ⊓ ↑t ≤ ⊥ ↔ ↑s ∩ ↑t ⊆ ↑⊥

tactic: rfl
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
κ : ι → Sort u_6
inst✝ : Lattice α
s t : Interval α
⊢ ↑s ⊓ ↑t ≤ ⊥ ↔ ↑s ∩ ↑t ⊆ ↑⊥
state_after: no goals
Theorem: isOfFinOrder_inv_iff
File: Mathlib/GroupTheory/OrderOfElement.lean

tactic: simp [isOfFinOrder_iff_pow_eq_one]
state_before: G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝ : Group G
x✝ y : G
i : ℤ
x : G
⊢ IsOfFinOrder x⁻¹ ↔ IsOfFinOrder x
state_after: no goals
Theorem: Subsemiring.centralizer_centralizer_centralizer
File: Mathlib/Algebra/Ring/Subsemiring/Basic.lean

tactic: apply SetLike.coe_injective
state_before: R✝ : Type u
S : Type v
T : Type w
inst✝³ : NonAssocSemiring R✝
M : Submonoid R✝
inst✝² : NonAssocSemiring S
inst✝¹ : NonAssocSemiring T
R : Type u_1
inst✝ : Semiring R
s : Set R
⊢ centralizer s.centralizer.centralizer = centralizer s
state_after: case a
R✝ : Type u
S : Type v
T : Type w
inst✝³ : NonAssocSemiring R✝
M : Submonoid R✝
inst✝² : NonAssocSemiring S
inst✝¹ : NonAssocSemiring T
R : Type u_1
inst✝ : Semiring R
s : Set R
⊢ ↑(centralizer s.centralizer.centralizer) = ↑(centralizer s)

tactic: simp only [coe_centralizer, Set.centralizer_centralizer_centralizer]
state_before: case a
R✝ : Type u
S : Type v
T : Type w
inst✝³ : NonAssocSemiring R✝
M : Submonoid R✝
inst✝² : NonAssocSemiring S
inst✝¹ : NonAssocSemiring T
R : Type u_1
inst✝ : Semiring R
s : Set R
⊢ ↑(centralizer s.centralizer.centralizer) = ↑(centralizer s)
state_after: no goals
Theorem: MeasureTheory.hasFiniteIntegral_iff_ofReal
File: Mathlib/MeasureTheory/Function/L1Space.lean

tactic: rw [HasFiniteIntegral, lintegral_nnnorm_eq_of_ae_nonneg h]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → ℝ
h : 0 ≤ᶠ[ae μ] f
⊢ HasFiniteIntegral f μ ↔ ∫⁻ (a : α), ENNReal.ofReal (f a) ∂μ < ⊤
state_after: no goals
Theorem: groupCohomology.Hilbert90.aux_ne_zero
File: Mathlib/RepresentationTheory/GroupCohomology/Hilbert90.lean

tactic: ext
state_before: K : Type u_1
L : Type u_2
inst✝³ : Field K
inst✝² : Field L
inst✝¹ : Algebra K L
inst✝ : FiniteDimensional K L
f : (L ≃ₐ[K] L) → Lˣ
x y : L ≃ₐ[K] L
h : (fun f => ↑f) x = (fun f => ↑f) y
⊢ x = y
state_after: case h
K : Type u_1
L : Type u_2
inst✝³ : Field K
inst✝² : Field L
inst✝¹ : Algebra K L
inst✝ : FiniteDimensional K L
f : (L ≃ₐ[K] L) → Lˣ
x y : L ≃ₐ[K] L
h : (fun f => ↑f) x = (fun f => ↑f) y
a✝ : L
⊢ x a✝ = y a✝

tactic: exact DFunLike.ext_iff.1 h _
state_before: case h
K : Type u_1
L : Type u_2
inst✝³ : Field K
inst✝² : Field L
inst✝¹ : Algebra K L
inst✝ : FiniteDimensional K L
f : (L ≃ₐ[K] L) → Lˣ
x y : L ≃ₐ[K] L
h : (fun f => ↑f) x = (fun f => ↑f) y
a✝ : L
⊢ x a✝ = y a✝
state_after: no goals
Theorem: CategoryTheory.LaxMonoidalFunctor.associativity_inv
File: Mathlib/CategoryTheory/Monoidal/Functor.lean

tactic: rw [Iso.eq_inv_comp, ← F.associativity_assoc, ← F.toFunctor.map_comp, Iso.hom_inv_id,
  F.toFunctor.map_id, comp_id]
state_before: C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
X Y Z : C
⊢ F.obj X ◁ F.μ Y Z ≫ F.μ X (Y ⊗ Z) ≫ F.map (α_ X Y Z).inv =
    (α_ (F.obj X) (F.obj Y) (F.obj Z)).inv ≫ F.μ X Y ▷ F.obj Z ≫ F.μ (X ⊗ Y) Z
state_after: no goals
Theorem: CategoryTheory.IsVanKampenColimit.whiskerEquivalence_iff
File: Mathlib/CategoryTheory/Limits/VanKampen.lean

tactic: simp
state_before: J : Type v'
inst✝⁴ : Category.{u', v'} J
C : Type u
inst✝³ : Category.{v, u} C
K✝ : Type u_1
inst✝² : Category.{?u.150726, u_1} K✝
D : Type u_2
inst✝¹ : Category.{?u.150733, u_2} D
K : Type u_3
inst✝ : Category.{u_4, u_3} K
e : J ≌ K
F : K ⥤ C
c : Cocone F
hc : IsVanKampenColimit (Cocone.whisker e.functor c)
⊢ ∀ (j : K),
    ((Cocones.precompose (e.invFunIdAssoc F).inv).obj
                (Cocone.whisker e.symm.functor (Cocone.whisker e.functor c))).ι.app
          j ≫
        (Iso.refl
            ((Cocones.precompose (e.invFunIdAssoc F).inv).obj
                (Cocone.whisker e.symm.functor (Cocone.whisker e.functor c))).pt).hom =
      c.ι.app j
state_after: no goals
Theorem: CategoryTheory.Adjunction.unit_leftAdjointUniq_hom_app
File: Mathlib/CategoryTheory/Adjunction/Unique.lean

tactic: rw [← unit_leftAdjointUniq_hom adj1 adj2]
state_before: C : Type u_1
D : Type u_2
inst✝¹ : Category.{u_3, u_1} C
inst✝ : Category.{u_4, u_2} D
F F' : C ⥤ D
G : D ⥤ C
adj1 : F ⊣ G
adj2 : F' ⊣ G
x : C
⊢ adj1.unit.app x ≫ G.map ((adj1.leftAdjointUniq adj2).hom.app x) = adj2.unit.app x
state_after: C : Type u_1
D : Type u_2
inst✝¹ : Category.{u_3, u_1} C
inst✝ : Category.{u_4, u_2} D
F F' : C ⥤ D
G : D ⥤ C
adj1 : F ⊣ G
adj2 : F' ⊣ G
x : C
⊢ adj1.unit.app x ≫ G.map ((adj1.leftAdjointUniq adj2).hom.app x) =
    (adj1.unit ≫ whiskerRight (adj1.leftAdjointUniq adj2).hom G).app x

tactic: rfl
state_before: C : Type u_1
D : Type u_2
inst✝¹ : Category.{u_3, u_1} C
inst✝ : Category.{u_4, u_2} D
F F' : C ⥤ D
G : D ⥤ C
adj1 : F ⊣ G
adj2 : F' ⊣ G
x : C
⊢ adj1.unit.app x ≫ G.map ((adj1.leftAdjointUniq adj2).hom.app x) =
    (adj1.unit ≫ whiskerRight (adj1.leftAdjointUniq adj2).hom G).app x
state_after: no goals
Theorem: MvPolynomial.monomial_single_add
File: Mathlib/Algebra/MvPolynomial/Basic.lean

tactic: rw [X_pow_eq_monomial, monomial_mul, one_mul]
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S₁
p q : MvPolynomial σ R
⊢ (monomial (Finsupp.single n e + s)) a = X n ^ e * (monomial s) a
state_after: no goals
Theorem: Finsupp.toMultiset_map
File: Mathlib/Data/Finsupp/Multiset.lean

tactic: refine f.induction ?_ ?_
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
f : α →₀ ℕ
g : α → β
⊢ Multiset.map g (toMultiset f) = toMultiset (mapDomain g f)
state_after: case refine_1
α : Type u_1
β : Type u_2
ι : Type u_3
f : α →₀ ℕ
g : α → β
⊢ Multiset.map g (toMultiset 0) = toMultiset (mapDomain g 0)

case refine_2
α : Type u_1
β : Type u_2
ι : Type u_3
f : α →₀ ℕ
g : α → β
⊢ ∀ (a : α) (b : ℕ) (f : α →₀ ℕ),
    a ∉ f.support →
      b ≠ 0 →
        Multiset.map g (toMultiset f) = toMultiset (mapDomain g f) →
          Multiset.map g (toMultiset (single a b + f)) = toMultiset (mapDomain g (single a b + f))

tactic: rw [toMultiset_zero, Multiset.map_zero, mapDomain_zero, toMultiset_zero]
state_before: case refine_1
α : Type u_1
β : Type u_2
ι : Type u_3
f : α →₀ ℕ
g : α → β
⊢ Multiset.map g (toMultiset 0) = toMultiset (mapDomain g 0)
state_after: no goals

tactic: intro a n f _ _ ih
state_before: case refine_2
α : Type u_1
β : Type u_2
ι : Type u_3
f : α →₀ ℕ
g : α → β
⊢ ∀ (a : α) (b : ℕ) (f : α →₀ ℕ),
    a ∉ f.support →
      b ≠ 0 →
        Multiset.map g (toMultiset f) = toMultiset (mapDomain g f) →
          Multiset.map g (toMultiset (single a b + f)) = toMultiset (mapDomain g (single a b + f))
state_after: case refine_2
α : Type u_1
β : Type u_2
ι : Type u_3
f✝ : α →₀ ℕ
g : α → β
a : α
n : ℕ
f : α →₀ ℕ
a✝¹ : a ∉ f.support
a✝ : n ≠ 0
ih : Multiset.map g (toMultiset f) = toMultiset (mapDomain g f)
⊢ Multiset.map g (toMultiset (single a n + f)) = toMultiset (mapDomain g (single a n + f))

tactic: rw [toMultiset_add, Multiset.map_add, ih, mapDomain_add, mapDomain_single,
  toMultiset_single, toMultiset_add, toMultiset_single, ← Multiset.coe_mapAddMonoidHom,
  (Multiset.mapAddMonoidHom g).map_nsmul]
state_before: case refine_2
α : Type u_1
β : Type u_2
ι : Type u_3
f✝ : α →₀ ℕ
g : α → β
a : α
n : ℕ
f : α →₀ ℕ
a✝¹ : a ∉ f.support
a✝ : n ≠ 0
ih : Multiset.map g (toMultiset f) = toMultiset (mapDomain g f)
⊢ Multiset.map g (toMultiset (single a n + f)) = toMultiset (mapDomain g (single a n + f))
state_after: case refine_2
α : Type u_1
β : Type u_2
ι : Type u_3
f✝ : α →₀ ℕ
g : α → β
a : α
n : ℕ
f : α →₀ ℕ
a✝¹ : a ∉ f.support
a✝ : n ≠ 0
ih : Multiset.map g (toMultiset f) = toMultiset (mapDomain g f)
⊢ n • (Multiset.mapAddMonoidHom g) {a} + toMultiset (mapDomain g f) = n • {g a} + toMultiset (mapDomain g f)

tactic: rfl
state_before: case refine_2
α : Type u_1
β : Type u_2
ι : Type u_3
f✝ : α →₀ ℕ
g : α → β
a : α
n : ℕ
f : α →₀ ℕ
a✝¹ : a ∉ f.support
a✝ : n ≠ 0
ih : Multiset.map g (toMultiset f) = toMultiset (mapDomain g f)
⊢ n • (Multiset.mapAddMonoidHom g) {a} + toMultiset (mapDomain g f) = n • {g a} + toMultiset (mapDomain g f)
state_after: no goals
Theorem: Fin.castPred_succAbove_castPred
File: Mathlib/Data/Fin/Basic.lean

tactic: simp_rw [← castSucc_inj (b := (a.succAbove b).castPred hk), ← castSucc_succAbove_castSucc,
  castSucc_castPred]
state_before: n m : ℕ
p : Fin (n + 1)
i j : Fin n
a : Fin (n + 2)
b : Fin (n + 1)
ha : a ≠ last (n + 1)
hb : b ≠ last n
hk : optParam (a.succAbove b ≠ last (n + 1)) ⋯
⊢ (a.castPred ha).succAbove (b.castPred hb) = (a.succAbove b).castPred hk
state_after: no goals
Theorem: Computation.exists_of_mem_map
File: Mathlib/Data/Seq/Computation.lean

tactic: rw [← bind_pure] at h
state_before: α : Type u
β : Type v
γ : Type w
f : α → β
b : β
s : Computation α
h : b ∈ map f s
⊢ ∃ a, a ∈ s ∧ f a = b
state_after: α : Type u
β : Type v
γ : Type w
f : α → β
b : β
s : Computation α
h : b ∈ s.bind (pure ∘ f)
⊢ ∃ a, a ∈ s ∧ f a = b

tactic: let ⟨a, as, fb⟩ := exists_of_mem_bind h
state_before: α : Type u
β : Type v
γ : Type w
f : α → β
b : β
s : Computation α
h : b ∈ s.bind (pure ∘ f)
⊢ ∃ a, a ∈ s ∧ f a = b
state_after: α : Type u
β : Type v
γ : Type w
f : α → β
b : β
s : Computation α
h : b ∈ s.bind (pure ∘ f)
a : α
as : a ∈ s
fb : b ∈ (pure ∘ f) a
⊢ ∃ a, a ∈ s ∧ f a = b

tactic: exact ⟨a, as, mem_unique (ret_mem _) fb⟩
state_before: α : Type u
β : Type v
γ : Type w
f : α → β
b : β
s : Computation α
h : b ∈ s.bind (pure ∘ f)
a : α
as : a ∈ s
fb : b ∈ (pure ∘ f) a
⊢ ∃ a, a ∈ s ∧ f a = b
state_after: no goals
Theorem: Subgroup.closure_inv
File: Mathlib/Algebra/Group/Subgroup/Pointwise.lean

tactic: simp only [← toSubmonoid_eq, closure_toSubmonoid, inv_inv, union_comm]
state_before: α : Type u_1
G : Type u_2
A : Type u_3
S : Type u_4
inst✝¹ : Group G
inst✝ : AddGroup A
s✝ s : Set G
⊢ closure s⁻¹ = closure s
state_after: no goals
Theorem: ZMod.castHom_bijective
File: Mathlib/Data/ZMod/Basic.lean

tactic: haveI : NeZero n :=
  ⟨by
    intro hn
    rw [hn] at h
    exact (Fintype.card_eq_zero_iff.mp h).elim' 0⟩
state_before: n : ℕ
R : Type u_1
inst✝² : Ring R
inst✝¹ : CharP R n
inst✝ : Fintype R
h : Fintype.card R = n
⊢ Bijective ⇑(castHom ⋯ R)
state_after: n : ℕ
R : Type u_1
inst✝² : Ring R
inst✝¹ : CharP R n
inst✝ : Fintype R
h : Fintype.card R = n
this : NeZero n
⊢ Bijective ⇑(castHom ⋯ R)

tactic: rw [Fintype.bijective_iff_injective_and_card, ZMod.card, h, eq_self_iff_true, and_true_iff]
state_before: n : ℕ
R : Type u_1
inst✝² : Ring R
inst✝¹ : CharP R n
inst✝ : Fintype R
h : Fintype.card R = n
this : NeZero n
⊢ Bijective ⇑(castHom ⋯ R)
state_after: n : ℕ
R : Type u_1
inst✝² : Ring R
inst✝¹ : CharP R n
inst✝ : Fintype R
h : Fintype.card R = n
this : NeZero n
⊢ Injective ⇑(castHom ⋯ R)

tactic: apply ZMod.castHom_injective
state_before: n : ℕ
R : Type u_1
inst✝² : Ring R
inst✝¹ : CharP R n
inst✝ : Fintype R
h : Fintype.card R = n
this : NeZero n
⊢ Injective ⇑(castHom ⋯ R)
state_after: no goals

tactic: intro hn
state_before: n : ℕ
R : Type u_1
inst✝² : Ring R
inst✝¹ : CharP R n
inst✝ : Fintype R
h : Fintype.card R = n
⊢ n ≠ 0
state_after: n : ℕ
R : Type u_1
inst✝² : Ring R
inst✝¹ : CharP R n
inst✝ : Fintype R
h : Fintype.card R = n
hn : n = 0
⊢ False

tactic: rw [hn] at h
state_before: n : ℕ
R : Type u_1
inst✝² : Ring R
inst✝¹ : CharP R n
inst✝ : Fintype R
h : Fintype.card R = n
hn : n = 0
⊢ False
state_after: n : ℕ
R : Type u_1
inst✝² : Ring R
inst✝¹ : CharP R n
inst✝ : Fintype R
h : Fintype.card R = 0
hn : n = 0
⊢ False

tactic: exact (Fintype.card_eq_zero_iff.mp h).elim' 0
state_before: n : ℕ
R : Type u_1
inst✝² : Ring R
inst✝¹ : CharP R n
inst✝ : Fintype R
h : Fintype.card R = 0
hn : n = 0
⊢ False
state_after: no goals
Theorem: Ordinal.mul_eq_zero'
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: simp_rw [← type_prod_lex, type_eq_zero_iff_isEmpty]
state_before: α✝ : Type u_1
β✝ : Type u_2
γ : Type u_3
r : α✝ → α✝ → Prop
s : β✝ → β✝ → Prop
t : γ → γ → Prop
a b : Ordinal.{u_4}
α : Type u_4
x✝³ : α → α → Prop
x✝² : IsWellOrder α x✝³
β : Type u_4
x✝¹ : β → β → Prop
x✝ : IsWellOrder β x✝¹
⊢ type x✝³ * type x✝¹ = 0 ↔ type x✝³ = 0 ∨ type x✝¹ = 0
state_after: α✝ : Type u_1
β✝ : Type u_2
γ : Type u_3
r : α✝ → α✝ → Prop
s : β✝ → β✝ → Prop
t : γ → γ → Prop
a b : Ordinal.{u_4}
α : Type u_4
x✝³ : α → α → Prop
x✝² : IsWellOrder α x✝³
β : Type u_4
x✝¹ : β → β → Prop
x✝ : IsWellOrder β x✝¹
⊢ IsEmpty (β × α) ↔ IsEmpty α ∨ IsEmpty β

tactic: rw [or_comm]
state_before: α✝ : Type u_1
β✝ : Type u_2
γ : Type u_3
r : α✝ → α✝ → Prop
s : β✝ → β✝ → Prop
t : γ → γ → Prop
a b : Ordinal.{u_4}
α : Type u_4
x✝³ : α → α → Prop
x✝² : IsWellOrder α x✝³
β : Type u_4
x✝¹ : β → β → Prop
x✝ : IsWellOrder β x✝¹
⊢ IsEmpty (β × α) ↔ IsEmpty α ∨ IsEmpty β
state_after: α✝ : Type u_1
β✝ : Type u_2
γ : Type u_3
r : α✝ → α✝ → Prop
s : β✝ → β✝ → Prop
t : γ → γ → Prop
a b : Ordinal.{u_4}
α : Type u_4
x✝³ : α → α → Prop
x✝² : IsWellOrder α x✝³
β : Type u_4
x✝¹ : β → β → Prop
x✝ : IsWellOrder β x✝¹
⊢ IsEmpty (β × α) ↔ IsEmpty β ∨ IsEmpty α

tactic: exact isEmpty_prod
state_before: α✝ : Type u_1
β✝ : Type u_2
γ : Type u_3
r : α✝ → α✝ → Prop
s : β✝ → β✝ → Prop
t : γ → γ → Prop
a b : Ordinal.{u_4}
α : Type u_4
x✝³ : α → α → Prop
x✝² : IsWellOrder α x✝³
β : Type u_4
x✝¹ : β → β → Prop
x✝ : IsWellOrder β x✝¹
⊢ IsEmpty (β × α) ↔ IsEmpty β ∨ IsEmpty α
state_after: no goals
Theorem: MeasureTheory.Measure.toSphere_apply'
File: Mathlib/MeasureTheory/Constructions/HaarToSphere.lean

tactic: rw [toSphere, smul_apply, fst_apply hs, restrict_apply (measurable_fst hs),
  ((MeasurableEmbedding.subtype_coe (measurableSet_singleton _).compl).comp
    (Homeomorph.measurableEmbedding _)).comap_apply,
  image_comp, Homeomorph.image_symm, univ_prod, ← Set.prod_eq, nsmul_eq_mul, toSphere_apply_aux]
state_before: E : Type u_1
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : FiniteDimensional ℝ E
inst✝¹ : MeasurableSpace E
inst✝ : BorelSpace E
μ : Measure E
s : Set ↑(sphere 0 1)
hs : MeasurableSet s
⊢ μ.toSphere s = ↑(dim E) * μ (Ioo 0 1 • Subtype.val '' s)
state_after: no goals
Theorem: Prod.isCompl_iff
File: Mathlib/Order/Disjoint.lean

tactic: simp_rw [isCompl_iff, Prod.disjoint_iff, Prod.codisjoint_iff, and_and_and_comm]
state_before: α : Type u_1
β : Type u_2
inst✝³ : PartialOrder α
inst✝² : PartialOrder β
inst✝¹ : BoundedOrder α
inst✝ : BoundedOrder β
x y : α × β
⊢ IsCompl x y ↔ IsCompl x.1 y.1 ∧ IsCompl x.2 y.2
state_after: no goals
Theorem: tendsto_atBot_ciSup
File: Mathlib/Topology/Order/MonotoneConvergence.lean

tactic: convert tendsto_atTop_ciSup h_anti.dual hbdd.dual using 1
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
inst✝³ : Preorder ι
inst✝² : TopologicalSpace α
inst✝¹ : ConditionallyCompleteLattice α
inst✝ : SupConvergenceClass α
f : ι → α
a : α
h_anti : Antitone f
hbdd : BddAbove (range f)
⊢ Tendsto f atBot (𝓝 (⨆ i, f i))
state_after: no goals
Theorem: catalan_zero
File: Mathlib/Combinatorics/Enumerative/Catalan.lean

tactic: rw [catalan]
state_before: ⊢ catalan 0 = 1
state_after: no goals