1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: IsSMulRegular.pow_iff
File: Mathlib/Algebra/Regular/SMul.lean

tactic: refine ⟨?_, pow n⟩
state_before: R : Type u_1
S : Type u_2
M : Type u_3
a b : R
s : S
inst✝¹ : Monoid R
inst✝ : MulAction R M
n : ℕ
n0 : 0 < n
⊢ IsSMulRegular M (a ^ n) ↔ IsSMulRegular M a
state_after: R : Type u_1
S : Type u_2
M : Type u_3
a b : R
s : S
inst✝¹ : Monoid R
inst✝ : MulAction R M
n : ℕ
n0 : 0 < n
⊢ IsSMulRegular M (a ^ n) → IsSMulRegular M a

tactic: rw [← Nat.succ_pred_eq_of_pos n0, pow_succ, ← smul_eq_mul]
state_before: R : Type u_1
S : Type u_2
M : Type u_3
a b : R
s : S
inst✝¹ : Monoid R
inst✝ : MulAction R M
n : ℕ
n0 : 0 < n
⊢ IsSMulRegular M (a ^ n) → IsSMulRegular M a
state_after: R : Type u_1
S : Type u_2
M : Type u_3
a b : R
s : S
inst✝¹ : Monoid R
inst✝ : MulAction R M
n : ℕ
n0 : 0 < n
⊢ IsSMulRegular M (a ^ n.pred • a) → IsSMulRegular M a

tactic: exact of_smul _
state_before: R : Type u_1
S : Type u_2
M : Type u_3
a b : R
s : S
inst✝¹ : Monoid R
inst✝ : MulAction R M
n : ℕ
n0 : 0 < n
⊢ IsSMulRegular M (a ^ n.pred • a) → IsSMulRegular M a
state_after: no goals
Theorem: MvPolynomial.vars_X
File: Mathlib/Algebra/MvPolynomial/Variables.lean

tactic: rw [X, vars_monomial (one_ne_zero' R), Finsupp.support_single_ne_zero _ (one_ne_zero' ℕ)]
state_before: R : Type u
S : Type v
σ : Type u_1
τ : Type u_2
r : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
p q : MvPolynomial σ R
inst✝ : Nontrivial R
⊢ (X n).vars = {n}
state_after: no goals
Theorem: hyperoperation_recursion
File: Mathlib/Data/Nat/Hyperoperation.lean

tactic: rw [hyperoperation]
state_before: n m k : ℕ
⊢ hyperoperation (n + 1) m (k + 1) = hyperoperation n m (hyperoperation (n + 1) m k)
state_after: no goals
Theorem: closure_prod_eq
File: Mathlib/Topology/Constructions.lean

tactic: simp_rw [mem_prod, mem_closure_iff_nhdsWithin_neBot, nhdsWithin_prod_eq, prod_neBot]
state_before: X : Type u
Y : Type v
Z : Type u_1
W : Type u_2
ε : Type u_3
ζ : Type u_4
inst✝⁵ : TopologicalSpace X
inst✝⁴ : TopologicalSpace Y
inst✝³ : TopologicalSpace Z
inst✝² : TopologicalSpace W
inst✝¹ : TopologicalSpace ε
inst✝ : TopologicalSpace ζ
s : Set X
t : Set Y
x✝ : X × Y
a : X
b : Y
⊢ (a, b) ∈ closure (s ×ˢ t) ↔ (a, b) ∈ closure s ×ˢ closure t
state_after: no goals
Theorem: Filter.lift_iInf_of_map_univ
File: Mathlib/Order/Filter/Lift.lean

tactic: cases isEmpty_or_nonempty ι
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
f✝ f₁ f₂ : Filter α
g✝ g₁ g₂ : Set α → Filter β
f : ι → Filter α
g : Set α → Filter β
hg : ∀ (s t : Set α), g (s ∩ t) = g s ⊓ g t
hg' : g univ = ⊤
⊢ (iInf f).lift g = ⨅ i, (f i).lift g
state_after: case inl
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
f✝ f₁ f₂ : Filter α
g✝ g₁ g₂ : Set α → Filter β
f : ι → Filter α
g : Set α → Filter β
hg : ∀ (s t : Set α), g (s ∩ t) = g s ⊓ g t
hg' : g univ = ⊤
h✝ : IsEmpty ι
⊢ (iInf f).lift g = ⨅ i, (f i).lift g

case inr
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
f✝ f₁ f₂ : Filter α
g✝ g₁ g₂ : Set α → Filter β
f : ι → Filter α
g : Set α → Filter β
hg : ∀ (s t : Set α), g (s ∩ t) = g s ⊓ g t
hg' : g univ = ⊤
h✝ : Nonempty ι
⊢ (iInf f).lift g = ⨅ i, (f i).lift g

tactic: simp [iInf_of_empty, hg']
state_before: case inl
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
f✝ f₁ f₂ : Filter α
g✝ g₁ g₂ : Set α → Filter β
f : ι → Filter α
g : Set α → Filter β
hg : ∀ (s t : Set α), g (s ∩ t) = g s ⊓ g t
hg' : g univ = ⊤
h✝ : IsEmpty ι
⊢ (iInf f).lift g = ⨅ i, (f i).lift g
state_after: no goals

tactic: exact lift_iInf hg
state_before: case inr
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
f✝ f₁ f₂ : Filter α
g✝ g₁ g₂ : Set α → Filter β
f : ι → Filter α
g : Set α → Filter β
hg : ∀ (s t : Set α), g (s ∩ t) = g s ⊓ g t
hg' : g univ = ⊤
h✝ : Nonempty ι
⊢ (iInf f).lift g = ⨅ i, (f i).lift g
state_after: no goals
Theorem: AffineBasis.toMatrix_inv_vecMul_toMatrix
File: Mathlib/LinearAlgebra/AffineSpace/Matrix.lean

tactic: have hu := b.isUnit_toMatrix b₂
state_before: ι : Type u₁
k : Type u₂
V : Type u₃
P : Type u₄
inst✝⁵ : AddCommGroup V
inst✝⁴ : AffineSpace V P
inst✝³ : CommRing k
inst✝² : Module k V
inst✝¹ : DecidableEq ι
inst✝ : Fintype ι
b b₂ : AffineBasis ι k P
x : P
⊢ b.coords x ᵥ* (b.toMatrix ⇑b₂)⁻¹ = b₂.coords x
state_after: ι : Type u₁
k : Type u₂
V : Type u₃
P : Type u₄
inst✝⁵ : AddCommGroup V
inst✝⁴ : AffineSpace V P
inst✝³ : CommRing k
inst✝² : Module k V
inst✝¹ : DecidableEq ι
inst✝ : Fintype ι
b b₂ : AffineBasis ι k P
x : P
hu : IsUnit (b.toMatrix ⇑b₂)
⊢ b.coords x ᵥ* (b.toMatrix ⇑b₂)⁻¹ = b₂.coords x

tactic: rw [Matrix.isUnit_iff_isUnit_det] at hu
state_before: ι : Type u₁
k : Type u₂
V : Type u₃
P : Type u₄
inst✝⁵ : AddCommGroup V
inst✝⁴ : AffineSpace V P
inst✝³ : CommRing k
inst✝² : Module k V
inst✝¹ : DecidableEq ι
inst✝ : Fintype ι
b b₂ : AffineBasis ι k P
x : P
hu : IsUnit (b.toMatrix ⇑b₂)
⊢ b.coords x ᵥ* (b.toMatrix ⇑b₂)⁻¹ = b₂.coords x
state_after: ι : Type u₁
k : Type u₂
V : Type u₃
P : Type u₄
inst✝⁵ : AddCommGroup V
inst✝⁴ : AffineSpace V P
inst✝³ : CommRing k
inst✝² : Module k V
inst✝¹ : DecidableEq ι
inst✝ : Fintype ι
b b₂ : AffineBasis ι k P
x : P
hu : IsUnit (b.toMatrix ⇑b₂).det
⊢ b.coords x ᵥ* (b.toMatrix ⇑b₂)⁻¹ = b₂.coords x

tactic: rw [← b.toMatrix_vecMul_coords b₂, Matrix.vecMul_vecMul, Matrix.mul_nonsing_inv _ hu,
  Matrix.vecMul_one]
state_before: ι : Type u₁
k : Type u₂
V : Type u₃
P : Type u₄
inst✝⁵ : AddCommGroup V
inst✝⁴ : AffineSpace V P
inst✝³ : CommRing k
inst✝² : Module k V
inst✝¹ : DecidableEq ι
inst✝ : Fintype ι
b b₂ : AffineBasis ι k P
x : P
hu : IsUnit (b.toMatrix ⇑b₂).det
⊢ b.coords x ᵥ* (b.toMatrix ⇑b₂)⁻¹ = b₂.coords x
state_after: no goals
Theorem: SemiconjBy.mul_left
File: Mathlib/Algebra/Group/Semiconj/Defs.lean

tactic: unfold SemiconjBy
state_before: S : Type u_1
M : Type u_2
G : Type u_3
inst✝ : Semigroup S
a b x y z x' y' : S
ha : SemiconjBy a y z
hb : SemiconjBy b x y
⊢ SemiconjBy (a * b) x z
state_after: S : Type u_1
M : Type u_2
G : Type u_3
inst✝ : Semigroup S
a b x y z x' y' : S
ha : SemiconjBy a y z
hb : SemiconjBy b x y
⊢ a * b * x = z * (a * b)

tactic: rw [mul_assoc, hb.eq, ← mul_assoc, ha.eq, mul_assoc]
state_before: S : Type u_1
M : Type u_2
G : Type u_3
inst✝ : Semigroup S
a b x y z x' y' : S
ha : SemiconjBy a y z
hb : SemiconjBy b x y
⊢ a * b * x = z * (a * b)
state_after: no goals
Theorem: Set.Icc_diff_Ioo_same
File: Mathlib/Order/Interval/Set/Basic.lean

tactic: rw [← Icc_diff_both, diff_diff_cancel_left]
state_before: α : Type u_1
β : Type u_2
inst✝ : PartialOrder α
a b c : α
h : a ≤ b
⊢ Icc a b \ Ioo a b = {a, b}
state_after: α : Type u_1
β : Type u_2
inst✝ : PartialOrder α
a b c : α
h : a ≤ b
⊢ {a, b} ⊆ Icc a b

tactic: simp [insert_subset_iff, h]
state_before: α : Type u_1
β : Type u_2
inst✝ : PartialOrder α
a b c : α
h : a ≤ b
⊢ {a, b} ⊆ Icc a b
state_after: no goals
Theorem: Real.sqrtTwoAddSeries_succ
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

tactic: rw [sqrtTwoAddSeries, sqrtTwoAddSeries_succ _ _, sqrtTwoAddSeries]
state_before: x✝ x : ℝ
n : ℕ
⊢ x.sqrtTwoAddSeries (n + 1 + 1) = (√(2 + x)).sqrtTwoAddSeries (n + 1)
state_after: no goals
Theorem: MeasureTheory.Measure.restrict_apply_eq_zero'
File: Mathlib/MeasureTheory/Measure/Restrict.lean

tactic: rw [restrict_apply' hs]
state_before: R : Type u_1
α : Type u_2
β : Type u_3
δ : Type u_4
γ : Type u_5
ι : Type u_6
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
hs : MeasurableSet s
⊢ (μ.restrict s) t = 0 ↔ μ (t ∩ s) = 0
state_after: no goals
Theorem: top_bihimp
File: Mathlib/Order/SymmDiff.lean

tactic: rw [bihimp_comm, bihimp_top]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝ : GeneralizedHeytingAlgebra α
a b c d : α
⊢ ⊤ ⇔ a = a
state_after: no goals
Theorem: LieSubmodule.top_lie_le_iff_le_normalizer
File: Mathlib/Algebra/Lie/Normalizer.lean

tactic: rw [lie_le_iff]
state_before: R : Type u_1
L : Type u_2
M : Type u_3
M' : Type u_4
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
N N₁ N₂ N' : LieSubmodule R L M
⊢ ⁅⊤, N⁆ ≤ N' ↔ N ≤ N'.normalizer
state_after: R : Type u_1
L : Type u_2
M : Type u_3
M' : Type u_4
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
N N₁ N₂ N' : LieSubmodule R L M
⊢ (∀ x ∈ ⊤, ∀ m ∈ N, ⁅x, m⁆ ∈ N') ↔ N ≤ N'.normalizer

tactic: tauto
state_before: R : Type u_1
L : Type u_2
M : Type u_3
M' : Type u_4
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
N N₁ N₂ N' : LieSubmodule R L M
⊢ (∀ x ∈ ⊤, ∀ m ∈ N, ⁅x, m⁆ ∈ N') ↔ N ≤ N'.normalizer
state_after: no goals
Theorem: cfcₙ_apply_of_not_predicate
File: Mathlib/Topology/ContinuousFunction/NonUnitalFunctionalCalculus.lean

tactic: rw [cfcₙ_def, dif_neg (not_and_of_not_left _ ha)]
state_before: R : Type u_1
A : Type u_2
p : A → Prop
inst✝¹² : CommSemiring R
inst✝¹¹ : Nontrivial R
inst✝¹⁰ : StarRing R
inst✝⁹ : MetricSpace R
inst✝⁸ : TopologicalSemiring R
inst✝⁷ : ContinuousStar R
inst✝⁶ : NonUnitalRing A
inst✝⁵ : StarRing A
inst✝⁴ : TopologicalSpace A
inst✝³ : Module R A
inst✝² : IsScalarTower R A A
inst✝¹ : SMulCommClass R A A
inst✝ : NonUnitalContinuousFunctionalCalculus R p
f✝ g : R → R
a✝ : A
hf : autoParam (ContinuousOn f✝ (σₙ R a✝)) _auto✝
hf0 : autoParam (f✝ 0 = 0) _auto✝
hg : autoParam (ContinuousOn g (σₙ R a✝)) _auto✝
hg0 : autoParam (g 0 = 0) _auto✝
ha✝ : autoParam (p a✝) _auto✝
f : R → R
a : A
ha : ¬p a
⊢ cfcₙ f a = 0
state_after: no goals
Theorem: Multiset.mem_antidiagonal
File: Mathlib/Data/Multiset/Antidiagonal.lean

tactic: dsimp only [quot_mk_to_coe, antidiagonal_coe]
state_before: α : Type u_1
β : Type u_2
s : Multiset α
x : Multiset α × Multiset α
l : List α
⊢ x ∈ antidiagonal ⟦l⟧ ↔ x.1 + x.2 = ⟦l⟧
state_after: α : Type u_1
β : Type u_2
s : Multiset α
x : Multiset α × Multiset α
l : List α
⊢ x ∈ ↑(powersetAux l).revzip ↔ x.1 + x.2 = ↑l

tactic: refine ⟨fun h => revzip_powersetAux h, fun h ↦ ?_⟩
state_before: α : Type u_1
β : Type u_2
s : Multiset α
x : Multiset α × Multiset α
l : List α
⊢ x ∈ ↑(powersetAux l).revzip ↔ x.1 + x.2 = ↑l
state_after: α : Type u_1
β : Type u_2
s : Multiset α
x : Multiset α × Multiset α
l : List α
h : x.1 + x.2 = ↑l
⊢ x ∈ ↑(powersetAux l).revzip

tactic: haveI := Classical.decEq α
state_before: α : Type u_1
β : Type u_2
s : Multiset α
x : Multiset α × Multiset α
l : List α
h : x.1 + x.2 = ↑l
⊢ x ∈ ↑(powersetAux l).revzip
state_after: α : Type u_1
β : Type u_2
s : Multiset α
x : Multiset α × Multiset α
l : List α
h : x.1 + x.2 = ↑l
this : DecidableEq α
⊢ x ∈ ↑(powersetAux l).revzip

tactic: simp only [revzip_powersetAux_lemma l revzip_powersetAux, h.symm, ge_iff_le, mem_coe,
  List.mem_map, mem_powersetAux]
state_before: α : Type u_1
β : Type u_2
s : Multiset α
x : Multiset α × Multiset α
l : List α
h : x.1 + x.2 = ↑l
this : DecidableEq α
⊢ x ∈ ↑(powersetAux l).revzip
state_after: α : Type u_1
β : Type u_2
s : Multiset α
x : Multiset α × Multiset α
l : List α
h : x.1 + x.2 = ↑l
this : DecidableEq α
⊢ ∃ a ≤ x.1 + x.2, (a, x.1 + x.2 - a) = x

tactic: cases' x with x₁ x₂
state_before: α : Type u_1
β : Type u_2
s : Multiset α
x : Multiset α × Multiset α
l : List α
h : x.1 + x.2 = ↑l
this : DecidableEq α
⊢ ∃ a ≤ x.1 + x.2, (a, x.1 + x.2 - a) = x
state_after: case mk
α : Type u_1
β : Type u_2
s : Multiset α
l : List α
this : DecidableEq α
x₁ x₂ : Multiset α
h : (x₁, x₂).1 + (x₁, x₂).2 = ↑l
⊢ ∃ a ≤ (x₁, x₂).1 + (x₁, x₂).2, (a, (x₁, x₂).1 + (x₁, x₂).2 - a) = (x₁, x₂)

tactic: exact ⟨x₁, le_add_right _ _, by rw [add_tsub_cancel_left x₁ x₂]⟩
state_before: case mk
α : Type u_1
β : Type u_2
s : Multiset α
l : List α
this : DecidableEq α
x₁ x₂ : Multiset α
h : (x₁, x₂).1 + (x₁, x₂).2 = ↑l
⊢ ∃ a ≤ (x₁, x₂).1 + (x₁, x₂).2, (a, (x₁, x₂).1 + (x₁, x₂).2 - a) = (x₁, x₂)
state_after: no goals

tactic: rw [add_tsub_cancel_left x₁ x₂]
state_before: α : Type u_1
β : Type u_2
s : Multiset α
l : List α
this : DecidableEq α
x₁ x₂ : Multiset α
h : (x₁, x₂).1 + (x₁, x₂).2 = ↑l
⊢ (x₁, (x₁, x₂).1 + (x₁, x₂).2 - x₁) = (x₁, x₂)
state_after: no goals
Theorem: MeasurableSet.subtype_image
File: Mathlib/MeasureTheory/MeasurableSpace/Basic.lean

tactic: rintro ⟨u, hu, rfl⟩
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort uι
s✝ t✝ u : Set α
m : MeasurableSpace α
mβ : MeasurableSpace β
s : Set α
t : Set ↑s
hs : MeasurableSet s
⊢ MeasurableSet t → MeasurableSet (Subtype.val '' t)
state_after: case intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort uι
s✝ t u✝ : Set α
m : MeasurableSpace α
mβ : MeasurableSpace β
s : Set α
hs : MeasurableSet s
u : Set α
hu : MeasurableSet u
⊢ MeasurableSet (Subtype.val '' (Subtype.val ⁻¹' u))

tactic: rw [Subtype.image_preimage_coe]
state_before: case intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort uι
s✝ t u✝ : Set α
m : MeasurableSpace α
mβ : MeasurableSpace β
s : Set α
hs : MeasurableSet s
u : Set α
hu : MeasurableSet u
⊢ MeasurableSet (Subtype.val '' (Subtype.val ⁻¹' u))
state_after: case intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort uι
s✝ t u✝ : Set α
m : MeasurableSpace α
mβ : MeasurableSpace β
s : Set α
hs : MeasurableSet s
u : Set α
hu : MeasurableSet u
⊢ MeasurableSet (s ∩ u)

tactic: exact hs.inter hu
state_before: case intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort uι
s✝ t u✝ : Set α
m : MeasurableSpace α
mβ : MeasurableSpace β
s : Set α
hs : MeasurableSet s
u : Set α
hu : MeasurableSet u
⊢ MeasurableSet (s ∩ u)
state_after: no goals
Theorem: CategoryTheory.Abelian.imageIsoImage_hom_comp_image_ι
File: Mathlib/CategoryTheory/Abelian/Basic.lean

tactic: simp only [IsImage.isoExt_hom, IsImage.lift_ι, imageStrongEpiMonoFactorisation_m]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : Abelian C
X Y : C
f : X ⟶ Y
⊢ (imageIsoImage f).hom ≫ Limits.image.ι f = kernel.ι (cokernel.π f)
state_after: no goals
Theorem: mul_dvd_mul_iff_right
File: Mathlib/Algebra/GroupWithZero/Divisibility.lean

tactic: rw [mul_right_comm, mul_left_inj' hc]
state_before: α : Type u_1
inst✝ : CancelCommMonoidWithZero α
a b c : α
hc : c ≠ 0
d : α
⊢ b * c = a * c * d ↔ b = a * d
state_after: no goals
Theorem: Set.encard_le_encard_of_injOn
File: Mathlib/Data/Set/Card.lean

tactic: rw [← f_inj.encard_image]
state_before: α : Type u_1
β : Type u_2
s✝ t✝ s : Set α
t : Set β
f : α → β
hf : MapsTo f s t
f_inj : InjOn f s
⊢ s.encard ≤ t.encard
state_after: α : Type u_1
β : Type u_2
s✝ t✝ s : Set α
t : Set β
f : α → β
hf : MapsTo f s t
f_inj : InjOn f s
⊢ (f '' s).encard ≤ t.encard

tactic: apply encard_le_card
state_before: α : Type u_1
β : Type u_2
s✝ t✝ s : Set α
t : Set β
f : α → β
hf : MapsTo f s t
f_inj : InjOn f s
⊢ (f '' s).encard ≤ t.encard
state_after: case h
α : Type u_1
β : Type u_2
s✝ t✝ s : Set α
t : Set β
f : α → β
hf : MapsTo f s t
f_inj : InjOn f s
⊢ f '' s ⊆ t

tactic: rintro _ ⟨x, hx, rfl⟩
state_before: case h
α : Type u_1
β : Type u_2
s✝ t✝ s : Set α
t : Set β
f : α → β
hf : MapsTo f s t
f_inj : InjOn f s
⊢ f '' s ⊆ t
state_after: case h.intro.intro
α : Type u_1
β : Type u_2
s✝ t✝ s : Set α
t : Set β
f : α → β
hf : MapsTo f s t
f_inj : InjOn f s
x : α
hx : x ∈ s
⊢ f x ∈ t

tactic: exact hf hx
state_before: case h.intro.intro
α : Type u_1
β : Type u_2
s✝ t✝ s : Set α
t : Set β
f : α → β
hf : MapsTo f s t
f_inj : InjOn f s
x : α
hx : x ∈ s
⊢ f x ∈ t
state_after: no goals
Theorem: CommMonoid.primaryComponent.exists_orderOf_eq_prime_pow
File: Mathlib/GroupTheory/Torsion.lean

tactic: simpa [primaryComponent] using g.property
state_before: G : Type u_1
H : Type u_2
inst✝ : CommMonoid G
p : ℕ
hp : Fact (Nat.Prime p)
g : ↥(primaryComponent G p)
⊢ ∃ n, orderOf g = p ^ n
state_after: no goals
Theorem: descPochhammer_eq_ascPochhammer
File: Mathlib/RingTheory/Polynomial/Pochhammer.lean

tactic: induction n with
| zero => rw [descPochhammer_zero, ascPochhammer_zero, one_comp]
| succ n ih =>
  rw [Nat.cast_succ, sub_add, add_sub_cancel_right, descPochhammer_succ_right,
    ascPochhammer_succ_left, ih, X_mul, mul_X_comp, comp_assoc, add_comp, X_comp, one_comp]
state_before: R : Type u
inst✝ : Ring R
n : ℕ
⊢ descPochhammer ℤ n = (ascPochhammer ℤ n).comp (X - ↑n + 1)
state_after: no goals

tactic: rw [descPochhammer_zero, ascPochhammer_zero, one_comp]
state_before: case zero
R : Type u
inst✝ : Ring R
⊢ descPochhammer ℤ 0 = (ascPochhammer ℤ 0).comp (X - ↑0 + 1)
state_after: no goals

tactic: rw [Nat.cast_succ, sub_add, add_sub_cancel_right, descPochhammer_succ_right,
  ascPochhammer_succ_left, ih, X_mul, mul_X_comp, comp_assoc, add_comp, X_comp, one_comp]
state_before: case succ
R : Type u
inst✝ : Ring R
n : ℕ
ih : descPochhammer ℤ n = (ascPochhammer ℤ n).comp (X - ↑n + 1)
⊢ descPochhammer ℤ (n + 1) = (ascPochhammer ℤ (n + 1)).comp (X - ↑(n + 1) + 1)
state_after: no goals
Theorem: CliffordAlgebra.contractLeftAux_contractLeftAux
File: Mathlib/LinearAlgebra/CliffordAlgebra/Contraction.lean

tactic: simp only [contractLeftAux_apply_apply]
state_before: R : Type u1
inst✝² : CommRing R
M : Type u2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
d d' : Module.Dual R M
v : M
x fx : CliffordAlgebra Q
⊢ ((contractLeftAux Q d) v) ((ι Q) v * x, ((contractLeftAux Q d) v) (x, fx)) = Q v • fx
state_after: R : Type u1
inst✝² : CommRing R
M : Type u2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
d d' : Module.Dual R M
v : M
x fx : CliffordAlgebra Q
⊢ d v • ((ι Q) v * x) - (ι Q) v * (d v • x - (ι Q) v * fx) = Q v • fx

tactic: rw [mul_sub, ← mul_assoc, ι_sq_scalar, ← Algebra.smul_def, ← sub_add, mul_smul_comm, sub_self,
  zero_add]
state_before: R : Type u1
inst✝² : CommRing R
M : Type u2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
d d' : Module.Dual R M
v : M
x fx : CliffordAlgebra Q
⊢ d v • ((ι Q) v * x) - (ι Q) v * (d v • x - (ι Q) v * fx) = Q v • fx
state_after: no goals
Theorem: IsCorner.image
File: Mathlib/Combinatorics/Additive/Corner/Defs.lean

tactic: obtain ⟨hx₁y₁, hx₁y₂, hx₂y₁, hxy⟩ := hA
state_before: G : Type u_1
H : Type u_2
inst✝¹ : AddCommMonoid G
inst✝ : AddCommMonoid H
A B : Set (G × G)
s : Set G
t : Set H
f : G → H
a b c x₁ y₁ x₂ y₂ : G
hf : IsAddFreimanHom 2 s t f
hAs : A ⊆ s ×ˢ s
hA : IsCorner A x₁ y₁ x₂ y₂
⊢ IsCorner (Prod.map f f '' A) (f x₁) (f y₁) (f x₂) (f y₂)
state_after: case mk
G : Type u_1
H : Type u_2
inst✝¹ : AddCommMonoid G
inst✝ : AddCommMonoid H
A B : Set (G × G)
s : Set G
t : Set H
f : G → H
a b c x₁ y₁ x₂ y₂ : G
hf : IsAddFreimanHom 2 s t f
hAs : A ⊆ s ×ˢ s
hx₁y₁ : (x₁, y₁) ∈ A
hx₁y₂ : (x₁, y₂) ∈ A
hx₂y₁ : (x₂, y₁) ∈ A
hxy : x₁ + y₂ = x₂ + y₁
⊢ IsCorner (Prod.map f f '' A) (f x₁) (f y₁) (f x₂) (f y₂)

tactic: exact ⟨mem_image_of_mem _ hx₁y₁, mem_image_of_mem _ hx₁y₂, mem_image_of_mem _ hx₂y₁,
  hf.add_eq_add (hAs hx₁y₁).1 (hAs hx₁y₂).2 (hAs hx₂y₁).1 (hAs hx₁y₁).2 hxy⟩
state_before: case mk
G : Type u_1
H : Type u_2
inst✝¹ : AddCommMonoid G
inst✝ : AddCommMonoid H
A B : Set (G × G)
s : Set G
t : Set H
f : G → H
a b c x₁ y₁ x₂ y₂ : G
hf : IsAddFreimanHom 2 s t f
hAs : A ⊆ s ×ˢ s
hx₁y₁ : (x₁, y₁) ∈ A
hx₁y₂ : (x₁, y₂) ∈ A
hx₂y₁ : (x₂, y₁) ∈ A
hxy : x₁ + y₂ = x₂ + y₁
⊢ IsCorner (Prod.map f f '' A) (f x₁) (f y₁) (f x₂) (f y₂)
state_after: no goals
Theorem: Polynomial.coeff_neg
File: Mathlib/Algebra/Polynomial/Basic.lean

tactic: rcases p with ⟨⟩
state_before: R : Type u
a b : R
m n✝ : ℕ
inst✝ : Ring R
p : R[X]
n : ℕ
⊢ (-p).coeff n = -p.coeff n
state_after: case ofFinsupp
R : Type u
a b : R
m n✝ : ℕ
inst✝ : Ring R
n : ℕ
toFinsupp✝ : R[ℕ]
⊢ (-{ toFinsupp := toFinsupp✝ }).coeff n = -{ toFinsupp := toFinsupp✝ }.coeff n

tactic: rw [← ofFinsupp_neg, coeff, coeff]
state_before: case ofFinsupp
R : Type u
a b : R
m n✝ : ℕ
inst✝ : Ring R
n : ℕ
toFinsupp✝ : R[ℕ]
⊢ (-{ toFinsupp := toFinsupp✝ }).coeff n = -{ toFinsupp := toFinsupp✝ }.coeff n
state_after: case ofFinsupp
R : Type u
a b : R
m n✝ : ℕ
inst✝ : Ring R
n : ℕ
toFinsupp✝ : R[ℕ]
⊢ (match (motive := R[X] → ℕ → R) { toFinsupp := -toFinsupp✝ } with
      | { toFinsupp := p } => ⇑p)
      n =
    -(match (motive := R[X] → ℕ → R) { toFinsupp := toFinsupp✝ } with
        | { toFinsupp := p } => ⇑p)
        n

tactic: apply Finsupp.neg_apply
state_before: case ofFinsupp
R : Type u
a b : R
m n✝ : ℕ
inst✝ : Ring R
n : ℕ
toFinsupp✝ : R[ℕ]
⊢ (match (motive := R[X] → ℕ → R) { toFinsupp := -toFinsupp✝ } with
      | { toFinsupp := p } => ⇑p)
      n =
    -(match (motive := R[X] → ℕ → R) { toFinsupp := toFinsupp✝ } with
        | { toFinsupp := p } => ⇑p)
        n
state_after: no goals
Theorem: vadd_vsub_assoc
File: Mathlib/Algebra/AddTorsor.lean

tactic: apply vadd_right_cancel p₂
state_before: G : Type u_1
P : Type u_2
inst✝ : AddGroup G
T : AddTorsor G P
g : G
p₁ p₂ : P
⊢ g +ᵥ p₁ -ᵥ p₂ = g + (p₁ -ᵥ p₂)
state_after: G : Type u_1
P : Type u_2
inst✝ : AddGroup G
T : AddTorsor G P
g : G
p₁ p₂ : P
⊢ g +ᵥ p₁ -ᵥ p₂ +ᵥ p₂ = g + (p₁ -ᵥ p₂) +ᵥ p₂

tactic: rw [vsub_vadd, add_vadd, vsub_vadd]
state_before: G : Type u_1
P : Type u_2
inst✝ : AddGroup G
T : AddTorsor G P
g : G
p₁ p₂ : P
⊢ g +ᵥ p₁ -ᵥ p₂ +ᵥ p₂ = g + (p₁ -ᵥ p₂) +ᵥ p₂
state_after: no goals
Theorem: Finset.memberSubfamily_memberSubfamily
File: Mathlib/Combinatorics/SetFamily/Compression/Down.lean

tactic: ext
state_before: α : Type u_1
inst✝ : DecidableEq α
𝒜 ℬ : Finset (Finset α)
s : Finset α
a : α
⊢ memberSubfamily a (memberSubfamily a 𝒜) = ∅
state_after: case a
α : Type u_1
inst✝ : DecidableEq α
𝒜 ℬ : Finset (Finset α)
s : Finset α
a : α
a✝ : Finset α
⊢ a✝ ∈ memberSubfamily a (memberSubfamily a 𝒜) ↔ a✝ ∈ ∅

tactic: simp
state_before: case a
α : Type u_1
inst✝ : DecidableEq α
𝒜 ℬ : Finset (Finset α)
s : Finset α
a : α
a✝ : Finset α
⊢ a✝ ∈ memberSubfamily a (memberSubfamily a 𝒜) ↔ a✝ ∈ ∅
state_after: no goals
Theorem: List.rotate'_zero
File: Mathlib/Data/List/Rotate.lean

tactic: cases l <;> rfl
state_before: α : Type u
l : List α
⊢ l.rotate' 0 = l
state_after: no goals
Theorem: MeasureTheory.measure_map_restrict_apply
File: Mathlib/MeasureTheory/Group/FundamentalDomain.lean

tactic: rw [map_apply (f := π) (fun V hV ↦ measurableSet_quotient.mp hV) meas_U,
  Measure.restrict_apply (t := (Quotient.mk α_mod_G ⁻¹' U)) (measurableSet_quotient.mp meas_U)]
state_before: G : Type u_1
H : Type u_2
α : Type u_3
β : Type u_4
E : Type u_5
inst✝² : Group G
inst✝¹ : MulAction G α
inst✝ : MeasurableSpace α
μ : Measure α
s : Set α
U : Set (Quotient α_mod_G)
meas_U : MeasurableSet U
⊢ (Measure.map (Quotient.mk α_mod_G) (μ.restrict s)) U = μ (Quotient.mk α_mod_G ⁻¹' U ∩ s)
state_after: no goals
Theorem: jacobiTheta_eq_tsum_nat
File: Mathlib/NumberTheory/ModularForms/JacobiTheta/OneVariable.lean

tactic: rw [(hasSum_nat_jacobiTheta hτ).tsum_eq, mul_div_cancel₀ _ (two_ne_zero' ℂ), ← add_sub_assoc,
  add_sub_cancel_left]
state_before: τ : ℂ
hτ : 0 < τ.im
⊢ jacobiTheta τ = 1 + 2 * ∑' (n : ℕ), cexp (↑π * I * (↑n + 1) ^ 2 * τ)
state_after: no goals
Theorem: mul_right_iterate_apply_one
File: Mathlib/Algebra/GroupPower/IterateHom.lean

tactic: simp [mul_right_iterate]
state_before: M : Type u_1
N : Type u_2
G : Type u_3
H : Type u_4
inst✝ : Monoid G
a : G
n : ℕ
⊢ (fun x => x * a)^[n] 1 = a ^ n
state_after: no goals
Theorem: Polynomial.leadingCoeff_of_injective
File: Mathlib/Algebra/Polynomial/Monic.lean

tactic: delta leadingCoeff
state_before: R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝¹ : Semiring R
inst✝ : Semiring S
f : R →+* S
hf : Injective ⇑f
p : R[X]
⊢ (map f p).leadingCoeff = f p.leadingCoeff
state_after: R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝¹ : Semiring R
inst✝ : Semiring S
f : R →+* S
hf : Injective ⇑f
p : R[X]
⊢ (map f p).coeff (map f p).natDegree = f (p.coeff p.natDegree)

tactic: rw [coeff_map f, natDegree_map_eq_of_injective hf p]
state_before: R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝¹ : Semiring R
inst✝ : Semiring S
f : R →+* S
hf : Injective ⇑f
p : R[X]
⊢ (map f p).coeff (map f p).natDegree = f (p.coeff p.natDegree)
state_after: no goals