1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: WittVector.coeff_select
File: Mathlib/RingTheory/WittVector/InitTail.lean

tactic: dsimp [select, selectPoly]
state_before: p : ℕ
hp : Fact (Nat.Prime p)
n✝ : ℕ
R : Type u_1
inst✝ : CommRing R
P : ℕ → Prop
x : 𝕎 R
n : ℕ
⊢ (select P x).coeff n = (aeval x.coeff) (selectPoly P n)
state_after: p : ℕ
hp : Fact (Nat.Prime p)
n✝ : ℕ
R : Type u_1
inst✝ : CommRing R
P : ℕ → Prop
x : 𝕎 R
n : ℕ
⊢ (mk p fun n => if P n then x.coeff n else 0).coeff n = (aeval x.coeff) (if P n then X n else 0)

tactic: split_ifs with hi
state_before: p : ℕ
hp : Fact (Nat.Prime p)
n✝ : ℕ
R : Type u_1
inst✝ : CommRing R
P : ℕ → Prop
x : 𝕎 R
n : ℕ
⊢ (mk p fun n => if P n then x.coeff n else 0).coeff n = (aeval x.coeff) (if P n then X n else 0)
state_after: case pos
p : ℕ
hp : Fact (Nat.Prime p)
n✝ : ℕ
R : Type u_1
inst✝ : CommRing R
P : ℕ → Prop
x : 𝕎 R
n : ℕ
hi : P n
⊢ (mk p fun n => if P n then x.coeff n else 0).coeff n = (aeval x.coeff) (X n)

case neg
p : ℕ
hp : Fact (Nat.Prime p)
n✝ : ℕ
R : Type u_1
inst✝ : CommRing R
P : ℕ → Prop
x : 𝕎 R
n : ℕ
hi : ¬P n
⊢ (mk p fun n => if P n then x.coeff n else 0).coeff n = (aeval x.coeff) 0

tactic: rw [aeval_X, mk]
state_before: case pos
p : ℕ
hp : Fact (Nat.Prime p)
n✝ : ℕ
R : Type u_1
inst✝ : CommRing R
P : ℕ → Prop
x : 𝕎 R
n : ℕ
hi : P n
⊢ (mk p fun n => if P n then x.coeff n else 0).coeff n = (aeval x.coeff) (X n)
state_after: case pos
p : ℕ
hp : Fact (Nat.Prime p)
n✝ : ℕ
R : Type u_1
inst✝ : CommRing R
P : ℕ → Prop
x : 𝕎 R
n : ℕ
hi : P n
⊢ { coeff := fun n => if P n then x.coeff n else 0 }.coeff n = x.coeff n

tactic: simp only [hi]
state_before: case pos
p : ℕ
hp : Fact (Nat.Prime p)
n✝ : ℕ
R : Type u_1
inst✝ : CommRing R
P : ℕ → Prop
x : 𝕎 R
n : ℕ
hi : P n
⊢ { coeff := fun n => if P n then x.coeff n else 0 }.coeff n = x.coeff n
state_after: case pos
p : ℕ
hp : Fact (Nat.Prime p)
n✝ : ℕ
R : Type u_1
inst✝ : CommRing R
P : ℕ → Prop
x : 𝕎 R
n : ℕ
hi : P n
⊢ (if True then x.coeff n else 0) = x.coeff n

tactic: rfl
state_before: case pos
p : ℕ
hp : Fact (Nat.Prime p)
n✝ : ℕ
R : Type u_1
inst✝ : CommRing R
P : ℕ → Prop
x : 𝕎 R
n : ℕ
hi : P n
⊢ (if True then x.coeff n else 0) = x.coeff n
state_after: no goals

tactic: rw [AlgHom.map_zero, mk]
state_before: case neg
p : ℕ
hp : Fact (Nat.Prime p)
n✝ : ℕ
R : Type u_1
inst✝ : CommRing R
P : ℕ → Prop
x : 𝕎 R
n : ℕ
hi : ¬P n
⊢ (mk p fun n => if P n then x.coeff n else 0).coeff n = (aeval x.coeff) 0
state_after: case neg
p : ℕ
hp : Fact (Nat.Prime p)
n✝ : ℕ
R : Type u_1
inst✝ : CommRing R
P : ℕ → Prop
x : 𝕎 R
n : ℕ
hi : ¬P n
⊢ { coeff := fun n => if P n then x.coeff n else 0 }.coeff n = 0

tactic: simp only [hi]
state_before: case neg
p : ℕ
hp : Fact (Nat.Prime p)
n✝ : ℕ
R : Type u_1
inst✝ : CommRing R
P : ℕ → Prop
x : 𝕎 R
n : ℕ
hi : ¬P n
⊢ { coeff := fun n => if P n then x.coeff n else 0 }.coeff n = 0
state_after: case neg
p : ℕ
hp : Fact (Nat.Prime p)
n✝ : ℕ
R : Type u_1
inst✝ : CommRing R
P : ℕ → Prop
x : 𝕎 R
n : ℕ
hi : ¬P n
⊢ (if False then x.coeff n else 0) = 0

tactic: rfl
state_before: case neg
p : ℕ
hp : Fact (Nat.Prime p)
n✝ : ℕ
R : Type u_1
inst✝ : CommRing R
P : ℕ → Prop
x : 𝕎 R
n : ℕ
hi : ¬P n
⊢ (if False then x.coeff n else 0) = 0
state_after: no goals
Theorem: affineIndependent_iff
File: Mathlib/LinearAlgebra/AffineSpace/Independent.lean

tactic: simp [s.weightedVSub_eq_linear_combination hw]
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι✝ : Type u_4
s✝ : Finset ι✝
w✝ w₁ w₂ : ι✝ → k
p✝ : ι✝ → V
ι : Type u_5
p : ι → V
s : Finset ι
w : ι → k
hw : ∑ i ∈ s, w i = 0
⊢ ((s.weightedVSub p) w = 0 → ∀ i ∈ s, w i = 0) ↔ ∑ e ∈ s, w e • p e = 0 → ∀ e ∈ s, w e = 0
state_after: no goals
Theorem: smul_closedBall
File: Mathlib/Analysis/NormedSpace/Pointwise.lean

tactic: rcases eq_or_ne c 0 with (rfl | hc)
state_before: 𝕜 : Type u_1
E : Type u_2
inst✝² : NormedField 𝕜
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
c : 𝕜
x : E
r : ℝ
hr : 0 ≤ r
⊢ c • closedBall x r = closedBall (c • x) (‖c‖ * r)
state_after: case inl
𝕜 : Type u_1
E : Type u_2
inst✝² : NormedField 𝕜
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
x : E
r : ℝ
hr : 0 ≤ r
⊢ 0 • closedBall x r = closedBall (0 • x) (‖0‖ * r)

case inr
𝕜 : Type u_1
E : Type u_2
inst✝² : NormedField 𝕜
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
c : 𝕜
x : E
r : ℝ
hr : 0 ≤ r
hc : c ≠ 0
⊢ c • closedBall x r = closedBall (c • x) (‖c‖ * r)

tactic: simp [hr, zero_smul_set, Set.singleton_zero, nonempty_closedBall]
state_before: case inl
𝕜 : Type u_1
E : Type u_2
inst✝² : NormedField 𝕜
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
x : E
r : ℝ
hr : 0 ≤ r
⊢ 0 • closedBall x r = closedBall (0 • x) (‖0‖ * r)
state_after: no goals

tactic: exact smul_closedBall' hc x r
state_before: case inr
𝕜 : Type u_1
E : Type u_2
inst✝² : NormedField 𝕜
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
c : 𝕜
x : E
r : ℝ
hr : 0 ≤ r
hc : c ≠ 0
⊢ c • closedBall x r = closedBall (c • x) (‖c‖ * r)
state_after: no goals
Theorem: mem_span_range_iff_exists_fun
File: Mathlib/LinearAlgebra/Finsupp.lean

tactic: rw [Finsupp.equivFunOnFinite.surjective.exists]
state_before: α : Type u_1
M : Type u_2
R : Type u_3
inst✝⁶ : Fintype α
inst✝⁵ : Semiring R
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
S : Type u_4
inst✝² : Semiring S
inst✝¹ : Module S M
inst✝ : SMulCommClass R S M
v : α → M
x : M
⊢ x ∈ span R (Set.range v) ↔ ∃ c, ∑ i : α, c i • v i = x
state_after: α : Type u_1
M : Type u_2
R : Type u_3
inst✝⁶ : Fintype α
inst✝⁵ : Semiring R
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
S : Type u_4
inst✝² : Semiring S
inst✝¹ : Module S M
inst✝ : SMulCommClass R S M
v : α → M
x : M
⊢ x ∈ span R (Set.range v) ↔ ∃ x_1, ∑ i : α, Finsupp.equivFunOnFinite x_1 i • v i = x

tactic: simp only [Finsupp.mem_span_range_iff_exists_finsupp, Finsupp.equivFunOnFinite_apply]
state_before: α : Type u_1
M : Type u_2
R : Type u_3
inst✝⁶ : Fintype α
inst✝⁵ : Semiring R
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
S : Type u_4
inst✝² : Semiring S
inst✝¹ : Module S M
inst✝ : SMulCommClass R S M
v : α → M
x : M
⊢ x ∈ span R (Set.range v) ↔ ∃ x_1, ∑ i : α, Finsupp.equivFunOnFinite x_1 i • v i = x
state_after: α : Type u_1
M : Type u_2
R : Type u_3
inst✝⁶ : Fintype α
inst✝⁵ : Semiring R
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
S : Type u_4
inst✝² : Semiring S
inst✝¹ : Module S M
inst✝ : SMulCommClass R S M
v : α → M
x : M
⊢ (∃ c, (c.sum fun i a => a • v i) = x) ↔ ∃ x_1, ∑ x : α, x_1 x • v x = x

tactic: exact exists_congr fun c => Eq.congr_left <| Finsupp.sum_fintype _ _ fun i => zero_smul _ _
state_before: α : Type u_1
M : Type u_2
R : Type u_3
inst✝⁶ : Fintype α
inst✝⁵ : Semiring R
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
S : Type u_4
inst✝² : Semiring S
inst✝¹ : Module S M
inst✝ : SMulCommClass R S M
v : α → M
x : M
⊢ (∃ c, (c.sum fun i a => a • v i) = x) ↔ ∃ x_1, ∑ x : α, x_1 x • v x = x
state_after: no goals
Theorem: IsAntichain.max_maximals
File: Mathlib/Order/Minimal.lean

tactic: refine h.antisymm fun a ha => ?_
state_before: α : Type u_1
β : Type u_2
r r₁ r₂ : α → α → Prop
s t : Set α
a b : α
ht : IsAntichain r t
h : maximals r s ⊆ t
hs : ∀ ⦃a : α⦄, a ∈ t → ∃ b ∈ maximals r s, r b a
⊢ maximals r s = t
state_after: α : Type u_1
β : Type u_2
r r₁ r₂ : α → α → Prop
s t : Set α
a✝ b : α
ht : IsAntichain r t
h : maximals r s ⊆ t
hs : ∀ ⦃a : α⦄, a ∈ t → ∃ b ∈ maximals r s, r b a
a : α
ha : a ∈ t
⊢ a ∈ maximals r s

tactic: obtain ⟨b, hb, hr⟩ := hs ha
state_before: α : Type u_1
β : Type u_2
r r₁ r₂ : α → α → Prop
s t : Set α
a✝ b : α
ht : IsAntichain r t
h : maximals r s ⊆ t
hs : ∀ ⦃a : α⦄, a ∈ t → ∃ b ∈ maximals r s, r b a
a : α
ha : a ∈ t
⊢ a ∈ maximals r s
state_after: case intro.intro
α : Type u_1
β : Type u_2
r r₁ r₂ : α → α → Prop
s t : Set α
a✝ b✝ : α
ht : IsAntichain r t
h : maximals r s ⊆ t
hs : ∀ ⦃a : α⦄, a ∈ t → ∃ b ∈ maximals r s, r b a
a : α
ha : a ∈ t
b : α
hb : b ∈ maximals r s
hr : r b a
⊢ a ∈ maximals r s

tactic: rwa [of_not_not fun hab => ht (h hb) ha (Ne.symm hab) hr]
state_before: case intro.intro
α : Type u_1
β : Type u_2
r r₁ r₂ : α → α → Prop
s t : Set α
a✝ b✝ : α
ht : IsAntichain r t
h : maximals r s ⊆ t
hs : ∀ ⦃a : α⦄, a ∈ t → ∃ b ∈ maximals r s, r b a
a : α
ha : a ∈ t
b : α
hb : b ∈ maximals r s
hr : r b a
⊢ a ∈ maximals r s
state_after: no goals
Theorem: AdicCompletion.val_smul_eq_evalₐ_smul
File: Mathlib/RingTheory/AdicCompletion/Algebra.lean

tactic: apply induction_on I R r (fun r ↦ ?_)
state_before: R : Type u_1
inst✝² : CommRing R
I : Ideal R
M : Type u_2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
n : ℕ
r : AdicCompletion I R
x : M ⧸ I ^ n • ⊤
⊢ ↑r n • x = (evalₐ I n) r • x
state_after: R : Type u_1
inst✝² : CommRing R
I : Ideal R
M : Type u_2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
n : ℕ
r✝ : AdicCompletion I R
x : M ⧸ I ^ n • ⊤
r : AdicCauchySequence I R
⊢ ↑((mk I R) r) n • x = (evalₐ I n) ((mk I R) r) • x

tactic: exact Quotient.inductionOn' x (fun x ↦ rfl)
state_before: R : Type u_1
inst✝² : CommRing R
I : Ideal R
M : Type u_2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
n : ℕ
r✝ : AdicCompletion I R
x : M ⧸ I ^ n • ⊤
r : AdicCauchySequence I R
⊢ ↑((mk I R) r) n • x = (evalₐ I n) ((mk I R) r) • x
state_after: no goals
Theorem: CategoryTheory.PreGaloisCategory.mkSelfProdFib_map_π
File: Mathlib/CategoryTheory/Galois/Decomposition.lean

tactic: rw [← congrFun (piComparison_comp_π F _ t), FintypeCat.comp_apply,
  ← PreservesProduct.iso_hom]
state_before: C : Type u₁
inst✝² : Category.{u₂, u₁} C
inst✝¹ : GaloisCategory C
F : C ⥤ FintypeCat
inst✝ : FiberFunctor F
X : C
t : ↑(F.obj X)
⊢ F.map (Pi.π (fun x => X) t) (CategoryTheory.PreGaloisCategory.mkSelfProdFib F X) = t
state_after: C : Type u₁
inst✝² : Category.{u₂, u₁} C
inst✝¹ : GaloisCategory C
F : C ⥤ FintypeCat
inst✝ : FiberFunctor F
X : C
t : ↑(F.obj X)
⊢ Pi.π (fun b => F.obj X) t
      ((PreservesProduct.iso F fun x => X).hom (CategoryTheory.PreGaloisCategory.mkSelfProdFib F X)) =
    t

tactic: simp only [mkSelfProdFib, FintypeCat.inv_hom_id_apply]
state_before: C : Type u₁
inst✝² : Category.{u₂, u₁} C
inst✝¹ : GaloisCategory C
F : C ⥤ FintypeCat
inst✝ : FiberFunctor F
X : C
t : ↑(F.obj X)
⊢ Pi.π (fun b => F.obj X) t
      ((PreservesProduct.iso F fun x => X).hom (CategoryTheory.PreGaloisCategory.mkSelfProdFib F X)) =
    t
state_after: C : Type u₁
inst✝² : Category.{u₂, u₁} C
inst✝¹ : GaloisCategory C
F : C ⥤ FintypeCat
inst✝ : FiberFunctor F
X : C
t : ↑(F.obj X)
⊢ Pi.π (fun b => F.obj X) t ((Concrete.productEquiv fun x => F.obj X).symm id) = t

tactic: exact Concrete.productEquiv_symm_apply_π.{w, w, w+1} (fun _ : F.obj X ↦ F.obj X) id t
state_before: C : Type u₁
inst✝² : Category.{u₂, u₁} C
inst✝¹ : GaloisCategory C
F : C ⥤ FintypeCat
inst✝ : FiberFunctor F
X : C
t : ↑(F.obj X)
⊢ Pi.π (fun b => F.obj X) t ((Concrete.productEquiv fun x => F.obj X).symm id) = t
state_after: no goals
Theorem: Matroid.Basis.basis_sUnion
File: Mathlib/Data/Matroid/Basic.lean

tactic: rw [sUnion_eq_iUnion]
state_before: α : Type u_1
M : Matroid α
I : Set α
Xs : Set (Set α)
hne : Xs.Nonempty
h : ∀ X ∈ Xs, M.Basis I X
⊢ M.Basis I (⋃₀ Xs)
state_after: α : Type u_1
M : Matroid α
I : Set α
Xs : Set (Set α)
hne : Xs.Nonempty
h : ∀ X ∈ Xs, M.Basis I X
⊢ M.Basis I (⋃ i, ↑i)

tactic: have := Iff.mpr nonempty_coe_sort hne
state_before: α : Type u_1
M : Matroid α
I : Set α
Xs : Set (Set α)
hne : Xs.Nonempty
h : ∀ X ∈ Xs, M.Basis I X
⊢ M.Basis I (⋃ i, ↑i)
state_after: α : Type u_1
M : Matroid α
I : Set α
Xs : Set (Set α)
hne : Xs.Nonempty
h : ∀ X ∈ Xs, M.Basis I X
this : Nonempty ↑Xs
⊢ M.Basis I (⋃ i, ↑i)

tactic: exact Basis.basis_iUnion _ fun X ↦ (h X X.prop)
state_before: α : Type u_1
M : Matroid α
I : Set α
Xs : Set (Set α)
hne : Xs.Nonempty
h : ∀ X ∈ Xs, M.Basis I X
this : Nonempty ↑Xs
⊢ M.Basis I (⋃ i, ↑i)
state_after: no goals
Theorem: nhdsWithin_insert
File: Mathlib/Topology/ContinuousOn.lean

tactic: rw [← singleton_union, nhdsWithin_union, nhdsWithin_singleton]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : TopologicalSpace α
a : α
s : Set α
⊢ 𝓝[insert a s] a = pure a ⊔ 𝓝[s] a
state_after: no goals
Theorem: HurwitzZeta.expZeta_zero
File: Mathlib/NumberTheory/LSeries/RiemannZeta.lean

tactic: ext1 s
state_before: ⊢ expZeta 0 = riemannZeta
state_after: case h
s : ℂ
⊢ expZeta 0 s = riemannZeta s

tactic: rw [expZeta, cosZeta_zero, add_right_eq_self, mul_eq_zero, eq_false_intro I_ne_zero, false_or,
  ← eq_neg_self_iff, ← sinZeta_neg, neg_zero]
state_before: case h
s : ℂ
⊢ expZeta 0 s = riemannZeta s
state_after: no goals
Theorem: Finpartition.card_parts_le_card
File: Mathlib/Order/Partition/Finpartition.lean

tactic: rw [← card_bot s]
state_before: α : Type u_1
inst✝ : DecidableEq α
s t u : Finset α
P : Finpartition s
a : α
⊢ P.parts.card ≤ s.card
state_after: α : Type u_1
inst✝ : DecidableEq α
s t u : Finset α
P : Finpartition s
a : α
⊢ P.parts.card ≤ ⊥.parts.card

tactic: exact card_mono bot_le
state_before: α : Type u_1
inst✝ : DecidableEq α
s t u : Finset α
P : Finpartition s
a : α
⊢ P.parts.card ≤ ⊥.parts.card
state_after: no goals
Theorem: dense_closure
File: Mathlib/Topology/Basic.lean

tactic: rw [Dense, Dense, closure_closure]
state_before: X : Type u
Y : Type v
ι : Sort w
α : Type u_1
β : Type u_2
x : X
s s₁ s₂ t : Set X
p p₁ p₂ : X → Prop
inst✝ : TopologicalSpace X
⊢ Dense (closure s) ↔ Dense s
state_after: no goals
Theorem: Embedding.of_comp_iff
File: Mathlib/Topology/Maps.lean

tactic: simp_rw [embedding_iff, hg.toInducing.of_comp_iff, hg.inj.of_comp_iff f]
state_before: X : Type u_1
Y : Type u_2
Z : Type u_3
ι : Type u_4
f : X → Y
g : Y → Z
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : TopologicalSpace Z
hg : _root_.Embedding g
⊢ _root_.Embedding (g ∘ f) ↔ _root_.Embedding f
state_after: no goals
Theorem: Function.mulSupport_along_fiber_subset
File: Mathlib/Algebra/Group/Support.lean

tactic: simpa using hx
state_before: α : Type u_1
β : Type u_2
A : Type u_3
B : Type u_4
M : Type u_5
N : Type u_6
P : Type u_7
G : Type u_8
inst✝² : One M
inst✝¹ : One N
inst✝ : One P
f : α × β → M
a : α
x : β
hx : x ∈ mulSupport fun b => f (a, b)
⊢ (a, x) ∈ mulSupport f ∧ (a, x).2 = x
state_after: no goals
Theorem: Int.cast_mul
File: Mathlib/Algebra/Ring/Int.lean

tactic: obtain ⟨m, rfl | rfl⟩ := Int.eq_nat_or_neg m
state_before: α : Type u_1
inst✝ : NonAssocRing α
m : ℤ
⊢ ∀ (n : ℤ), ↑(m * n) = ↑m * ↑n
state_after: case intro.inl
α : Type u_1
inst✝ : NonAssocRing α
m : ℕ
⊢ ∀ (n : ℤ), ↑(↑m * n) = ↑↑m * ↑n

case intro.inr
α : Type u_1
inst✝ : NonAssocRing α
m : ℕ
⊢ ∀ (n : ℤ), ↑(-↑m * n) = ↑(-↑m) * ↑n

tactic: induction m with
| zero => simp
| succ m ih => simp_all [add_mul]
state_before: case intro.inl
α : Type u_1
inst✝ : NonAssocRing α
m : ℕ
⊢ ∀ (n : ℤ), ↑(↑m * n) = ↑↑m * ↑n
state_after: no goals

tactic: simp
state_before: case intro.inl.zero
α : Type u_1
inst✝ : NonAssocRing α
⊢ ∀ (n : ℤ), ↑(↑0 * n) = ↑↑0 * ↑n
state_after: no goals

tactic: simp_all [add_mul]
state_before: case intro.inl.succ
α : Type u_1
inst✝ : NonAssocRing α
m : ℕ
ih : ∀ (n : ℤ), ↑(↑m * n) = ↑↑m * ↑n
⊢ ∀ (n : ℤ), ↑(↑(m + 1) * n) = ↑↑(m + 1) * ↑n
state_after: no goals

tactic: induction m with
| zero => simp
| succ m ih => simp_all [add_mul]
state_before: case intro.inr
α : Type u_1
inst✝ : NonAssocRing α
m : ℕ
⊢ ∀ (n : ℤ), ↑(-↑m * n) = ↑(-↑m) * ↑n
state_after: no goals

tactic: simp
state_before: case intro.inr.zero
α : Type u_1
inst✝ : NonAssocRing α
⊢ ∀ (n : ℤ), ↑(-↑0 * n) = ↑(-↑0) * ↑n
state_after: no goals

tactic: simp_all [add_mul]
state_before: case intro.inr.succ
α : Type u_1
inst✝ : NonAssocRing α
m : ℕ
ih : ∀ (n : ℤ), ↑(-↑m * n) = ↑(-↑m) * ↑n
⊢ ∀ (n : ℤ), ↑(-↑(m + 1) * n) = ↑(-↑(m + 1)) * ↑n
state_after: no goals
Theorem: QuotientGroup.mk'_eq_mk'
File: Mathlib/GroupTheory/QuotientGroup.lean

tactic: simp only [← _root_.eq_inv_mul_iff_mul_eq, exists_prop, exists_eq_right]
state_before: G : Type u
inst✝² : Group G
N : Subgroup G
nN : N.Normal
H : Type v
inst✝¹ : Group H
M : Type x
inst✝ : Monoid M
x y : G
⊢ x⁻¹ * y ∈ N ↔ ∃ z ∈ N, x * z = y
state_after: no goals
Theorem: Function.minimalPeriod_eq_zero_iff_nmem_periodicPts
File: Mathlib/Dynamics/PeriodicPts.lean

tactic: rw [← minimalPeriod_pos_iff_mem_periodicPts, not_lt, nonpos_iff_eq_zero]
state_before: α : Type u_1
β : Type u_2
f fa : α → α
fb : β → β
x y : α
m n : ℕ
⊢ minimalPeriod f x = 0 ↔ x ∉ periodicPts f
state_after: no goals
Theorem: genericPoint_specializes
File: Mathlib/Topology/Sober.lean

tactic: simp
state_before: α : Type u_1
β : Type u_2
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : QuasiSober α
inst✝ : IrreducibleSpace α
x : α
⊢ x ∈ closure univ
state_after: no goals
Theorem: Fin.last_sub
File: Mathlib/Data/Fin/Basic.lean

tactic: rw [coe_sub_iff_le.2 i.le_last, val_last, val_rev, Nat.succ_sub_succ_eq_sub]
state_before: n m : ℕ
i : Fin (n + 1)
⊢ ↑(last n - i) = ↑i.rev
state_after: no goals
Theorem: iterateFrobenius_one_apply
File: Mathlib/Algebra/CharP/ExpChar.lean

tactic: rw [iterateFrobenius_def, pow_one]
state_before: R : Type u
inst✝³ : CommSemiring R
S : Type u_1
inst✝² : CommSemiring S
f : R →* S
g : R →+* S
p m n : ℕ
inst✝¹ : ExpChar R p
inst✝ : ExpChar S p
x y : R
⊢ (iterateFrobenius R p 1) x = x ^ p
state_after: no goals
Theorem: ProbabilityTheory.mgf_const'
File: Mathlib/Probability/Moments.lean

tactic: simp only [mgf, integral_const, smul_eq_mul]
state_before: Ω : Type u_1
ι : Type u_2
m : MeasurableSpace Ω
X : Ω → ℝ
p : ℕ
μ : Measure Ω
t c : ℝ
⊢ mgf (fun x => c) μ t = (μ Set.univ).toReal * rexp (t * c)
state_after: no goals
Theorem: iSup_range
File: Mathlib/Order/CompleteLattice.lean

tactic: rw [← iSup_subtype'', iSup_range']
state_before: α : Type u_1
β : Type u_2
β₂ : Type u_3
γ : Type u_4
ι : Sort u_5
ι' : Sort u_6
κ : ι → Sort u_7
κ' : ι' → Sort u_8
inst✝ : CompleteLattice α
f✝ g✝ s t : ι → α
a b : α
g : β → α
f : ι → β
⊢ ⨆ b ∈ range f, g b = ⨆ i, g (f i)
state_after: no goals
Theorem: String.atEnd_of_valid
File: .lake/packages/batteries/Batteries/Data/String/Lemmas.lean

tactic: rw [atEnd_iff]
state_before: cs cs' : List Char
⊢ { data := cs ++ cs' }.atEnd { byteIdx := utf8Len cs } = true ↔ cs' = []
state_after: cs cs' : List Char
⊢ { data := cs ++ cs' }.endPos ≤ { byteIdx := utf8Len cs } ↔ cs' = []

tactic: cases cs' <;> simp [Nat.lt_add_of_pos_right add_csize_pos]
state_before: cs cs' : List Char
⊢ { data := cs ++ cs' }.endPos ≤ { byteIdx := utf8Len cs } ↔ cs' = []
state_after: no goals
Theorem: IsLocalization.mk'_add_eq_iff_add_mul_eq_mul
File: Mathlib/RingTheory/Localization/Basic.lean

tactic: rw [← mk'_spec S x y, ← IsUnit.mul_left_inj (IsLocalization.map_units S y), right_distrib]
state_before: R : Type u_1
inst✝⁴ : CommSemiring R
M : Submonoid R
S : Type u_2
inst✝³ : CommSemiring S
inst✝² : Algebra R S
P : Type u_3
inst✝¹ : CommSemiring P
inst✝ : IsLocalization M S
x : R
y : ↥M
z₁ z₂ : S
⊢ mk' S x y + z₁ = z₂ ↔ (algebraMap R S) x + z₁ * (algebraMap R S) ↑y = z₂ * (algebraMap R S) ↑y
state_after: no goals
Theorem: Polynomial.toLaurent_X
File: Mathlib/Algebra/Polynomial/Laurent.lean

tactic: have : (Polynomial.X : R[X]) = monomial 1 1 := by simp [← C_mul_X_pow_eq_monomial]
state_before: R : Type u_1
inst✝ : Semiring R
⊢ toLaurent X = T 1
state_after: R : Type u_1
inst✝ : Semiring R
this : X = (monomial 1) 1
⊢ toLaurent X = T 1

tactic: simp [this, Polynomial.toLaurent_C_mul_T]
state_before: R : Type u_1
inst✝ : Semiring R
this : X = (monomial 1) 1
⊢ toLaurent X = T 1
state_after: no goals

tactic: simp [← C_mul_X_pow_eq_monomial]
state_before: R : Type u_1
inst✝ : Semiring R
⊢ X = (monomial 1) 1
state_after: no goals
Theorem: ENNReal.coe_div
File: Mathlib/Data/ENNReal/Inv.lean

tactic: rw [div_eq_mul_inv, div_eq_mul_inv, coe_mul, coe_inv hr]
state_before: a b c d : ℝ≥0∞
r p q : ℝ≥0
hr : r ≠ 0
⊢ ↑(p / r) = ↑p / ↑r
state_after: no goals
Theorem: isCyclic_of_orderOf_eq_card
File: Mathlib/GroupTheory/SpecificGroups/Cyclic.lean

tactic: classical
  use x
  simp_rw [← SetLike.mem_coe, ← Set.eq_univ_iff_forall]
  rw [← Fintype.card_congr (Equiv.Set.univ α), ← Fintype.card_zpowers] at hx
  exact Set.eq_of_subset_of_card_le (Set.subset_univ _) (ge_of_eq hx)
state_before: α : Type u
a : α
inst✝¹ : Group α
inst✝ : Fintype α
x : α
hx : orderOf x = Fintype.card α
⊢ IsCyclic α
state_after: no goals

tactic: use x
state_before: α : Type u
a : α
inst✝¹ : Group α
inst✝ : Fintype α
x : α
hx : orderOf x = Fintype.card α
⊢ IsCyclic α
state_after: case h
α : Type u
a : α
inst✝¹ : Group α
inst✝ : Fintype α
x : α
hx : orderOf x = Fintype.card α
⊢ ∀ (x_1 : α), x_1 ∈ zpowers x

tactic: simp_rw [← SetLike.mem_coe, ← Set.eq_univ_iff_forall]
state_before: case h
α : Type u
a : α
inst✝¹ : Group α
inst✝ : Fintype α
x : α
hx : orderOf x = Fintype.card α
⊢ ∀ (x_1 : α), x_1 ∈ zpowers x
state_after: case h
α : Type u
a : α
inst✝¹ : Group α
inst✝ : Fintype α
x : α
hx : orderOf x = Fintype.card α
⊢ ↑(zpowers x) = Set.univ

tactic: rw [← Fintype.card_congr (Equiv.Set.univ α), ← Fintype.card_zpowers] at hx
state_before: case h
α : Type u
a : α
inst✝¹ : Group α
inst✝ : Fintype α
x : α
hx : orderOf x = Fintype.card α
⊢ ↑(zpowers x) = Set.univ
state_after: case h
α : Type u
a : α
inst✝¹ : Group α
inst✝ : Fintype α
x : α
hx : Fintype.card ↥(zpowers x) = Fintype.card ↑Set.univ
⊢ ↑(zpowers x) = Set.univ

tactic: exact Set.eq_of_subset_of_card_le (Set.subset_univ _) (ge_of_eq hx)
state_before: case h
α : Type u
a : α
inst✝¹ : Group α
inst✝ : Fintype α
x : α
hx : Fintype.card ↥(zpowers x) = Fintype.card ↑Set.univ
⊢ ↑(zpowers x) = Set.univ
state_after: no goals
Theorem: symmDiff_comm
File: Mathlib/Order/SymmDiff.lean

tactic: simp only [symmDiff, sup_comm]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝ : GeneralizedCoheytingAlgebra α
a b c d : α
⊢ a ∆ b = b ∆ a
state_after: no goals
Theorem: MeasureTheory.ProbabilityMeasure.map_fst_prod
File: Mathlib/MeasureTheory/Measure/FiniteMeasureProd.lean

tactic: apply Subtype.ext
state_before: α : Type u_1
inst✝¹ : MeasurableSpace α
β : Type u_2
inst✝ : MeasurableSpace β
μ : ProbabilityMeasure α
ν : ProbabilityMeasure β
⊢ (μ.prod ν).map ⋯ = μ
state_after: case a
α : Type u_1
inst✝¹ : MeasurableSpace α
β : Type u_2
inst✝ : MeasurableSpace β
μ : ProbabilityMeasure α
ν : ProbabilityMeasure β
⊢ ↑((μ.prod ν).map ⋯) = ↑μ

tactic: simp only [val_eq_to_measure, toMeasure_map, toMeasure_prod, Measure.map_fst_prod,
           measure_univ, one_smul]
state_before: case a
α : Type u_1
inst✝¹ : MeasurableSpace α
β : Type u_2
inst✝ : MeasurableSpace β
μ : ProbabilityMeasure α
ν : ProbabilityMeasure β
⊢ ↑((μ.prod ν).map ⋯) = ↑μ
state_after: no goals
Theorem: Real.cobounded_eq
File: Mathlib/Topology/Instances/Real.lean

tactic: simp only [← comap_dist_right_atTop (0 : ℝ), Real.dist_eq, sub_zero, comap_abs_atTop]
state_before: α : Type u
β : Type v
γ : Type w
⊢ cobounded ℝ = atBot ⊔ atTop
state_after: no goals
Theorem: SimpleGraph.chromaticNumber_pathGraph
File: Mathlib/Combinatorics/SimpleGraph/ConcreteColorings.lean

tactic: have hc := (pathGraph.bicoloring n).colorable
state_before: n : ℕ
h : 2 ≤ n
⊢ (pathGraph n).chromaticNumber = 2
state_after: n : ℕ
h : 2 ≤ n
hc : (pathGraph n).Colorable (Fintype.card Bool)
⊢ (pathGraph n).chromaticNumber = 2

tactic: apply le_antisymm
state_before: n : ℕ
h : 2 ≤ n
hc : (pathGraph n).Colorable (Fintype.card Bool)
⊢ (pathGraph n).chromaticNumber = 2
state_after: case a
n : ℕ
h : 2 ≤ n
hc : (pathGraph n).Colorable (Fintype.card Bool)
⊢ (pathGraph n).chromaticNumber ≤ 2

case a
n : ℕ
h : 2 ≤ n
hc : (pathGraph n).Colorable (Fintype.card Bool)
⊢ 2 ≤ (pathGraph n).chromaticNumber

tactic: exact hc.chromaticNumber_le
state_before: case a
n : ℕ
h : 2 ≤ n
hc : (pathGraph n).Colorable (Fintype.card Bool)
⊢ (pathGraph n).chromaticNumber ≤ 2
state_after: no goals

tactic: simpa only [pathGraph_two_eq_top, chromaticNumber_top] using
  chromaticNumber_mono_of_embedding (pathGraph_two_embedding n h)
state_before: case a
n : ℕ
h : 2 ≤ n
hc : (pathGraph n).Colorable (Fintype.card Bool)
⊢ 2 ≤ (pathGraph n).chromaticNumber
state_after: no goals
Theorem: Ordnode.all_node3L
File: Mathlib/Data/Ordmap/Ordset.lean

tactic: simp [node3L, all_node', and_assoc]
state_before: α : Type u_1
P : α → Prop
l : Ordnode α
x : α
m : Ordnode α
y : α
r : Ordnode α
⊢ All P (l.node3L x m y r) ↔ All P l ∧ P x ∧ All P m ∧ P y ∧ All P r
state_after: no goals