1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Ideal.Factors.inertiaDeg_ne_zero
File: Mathlib/NumberTheory/RamificationInertia.lean

tactic: rw [inertiaDeg_algebraMap]
state_before: R : Type u
inst✝⁵ : CommRing R
S : Type v
inst✝⁴ : CommRing S
f : R →+* S
p : Ideal R
P✝ : Ideal S
inst✝³ : IsDedekindDomain S
inst✝² : Algebra R S
inst✝¹ : IsNoetherian R S
inst✝ : p.IsMaximal
P : { x // x ∈ (factors (map (algebraMap R S) p)).toFinset }
⊢ inertiaDeg (algebraMap R S) p ↑P ≠ 0
state_after: R : Type u
inst✝⁵ : CommRing R
S : Type v
inst✝⁴ : CommRing S
f : R →+* S
p : Ideal R
P✝ : Ideal S
inst✝³ : IsDedekindDomain S
inst✝² : Algebra R S
inst✝¹ : IsNoetherian R S
inst✝ : p.IsMaximal
P : { x // x ∈ (factors (map (algebraMap R S) p)).toFinset }
⊢ finrank (R ⧸ p) (S ⧸ ↑P) ≠ 0

tactic: exact (FiniteDimensional.finrank_pos_iff.mpr inferInstance).ne'
state_before: R : Type u
inst✝⁵ : CommRing R
S : Type v
inst✝⁴ : CommRing S
f : R →+* S
p : Ideal R
P✝ : Ideal S
inst✝³ : IsDedekindDomain S
inst✝² : Algebra R S
inst✝¹ : IsNoetherian R S
inst✝ : p.IsMaximal
P : { x // x ∈ (factors (map (algebraMap R S) p)).toFinset }
⊢ finrank (R ⧸ p) (S ⧸ ↑P) ≠ 0
state_after: no goals
Theorem: FreeGroup.Red.church_rosser
File: Mathlib/GroupTheory/FreeGroup/Basic.lean

tactic: rfl
state_before: α : Type u
L L₁ L₂ L₃ L₄ a b✝ c b : List (α × Bool)
hab hac : Step a b
⊢ ReflGen Step b b
state_after: no goals

tactic: rfl
state_before: α : Type u
L L₁ L₂ L₃ L₄ a b✝ c b : List (α × Bool)
hab hac : Step a b
⊢ ReflTransGen Step b b
state_after: no goals
Theorem: MonoidAlgebra.single_algebraMap_eq_algebraMap_mul_of
File: Mathlib/Algebra/MonoidAlgebra/Basic.lean

tactic: simp
state_before: k : Type u₁
G : Type u₂
H : Type u_1
R : Type u_2
A : Type u_3
inst✝³ : CommSemiring k
inst✝² : Semiring A
inst✝¹ : Algebra k A
inst✝ : Monoid G
a : G
b : k
⊢ single a ((algebraMap k A) b) = (algebraMap k (MonoidAlgebra A G)) b * (of A G) a
state_after: no goals
Theorem: Polynomial.support_scaleRoots_le
File: Mathlib/RingTheory/Polynomial/ScaleRoots.lean

tactic: intro
state_before: R : Type u_1
S : Type u_2
A : Type u_3
K : Type u_4
inst✝¹ : Semiring R
inst✝ : Semiring S
p : R[X]
s : R
⊢ (p.scaleRoots s).support ≤ p.support
state_after: R : Type u_1
S : Type u_2
A : Type u_3
K : Type u_4
inst✝¹ : Semiring R
inst✝ : Semiring S
p : R[X]
s : R
a✝ : ℕ
⊢ a✝ ∈ (p.scaleRoots s).support → a✝ ∈ p.support

tactic: simpa using left_ne_zero_of_mul
state_before: R : Type u_1
S : Type u_2
A : Type u_3
K : Type u_4
inst✝¹ : Semiring R
inst✝ : Semiring S
p : R[X]
s : R
a✝ : ℕ
⊢ a✝ ∈ (p.scaleRoots s).support → a✝ ∈ p.support
state_after: no goals
Theorem: Module.End.isRoot_of_hasEigenvalue
File: Mathlib/LinearAlgebra/Eigenspace/Minpoly.lean

tactic: rcases (Submodule.ne_bot_iff _).1 h with ⟨w, ⟨H, ne0⟩⟩
state_before: K : Type v
V : Type w
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End K V
μ : K
h : f.HasEigenvalue μ
⊢ (minpoly K f).IsRoot μ
state_after: case intro.intro
K : Type v
V : Type w
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End K V
μ : K
h : f.HasEigenvalue μ
w : V
H : w ∈ f.eigenspace μ
ne0 : w ≠ 0
⊢ (minpoly K f).IsRoot μ

tactic: refine Or.resolve_right (smul_eq_zero.1 ?_) ne0
state_before: case intro.intro
K : Type v
V : Type w
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End K V
μ : K
h : f.HasEigenvalue μ
w : V
H : w ∈ f.eigenspace μ
ne0 : w ≠ 0
⊢ (minpoly K f).IsRoot μ
state_after: case intro.intro
K : Type v
V : Type w
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End K V
μ : K
h : f.HasEigenvalue μ
w : V
H : w ∈ f.eigenspace μ
ne0 : w ≠ 0
⊢ eval μ (minpoly K f) • w = 0

tactic: simp [← aeval_apply_of_hasEigenvector ⟨H, ne0⟩, minpoly.aeval K f]
state_before: case intro.intro
K : Type v
V : Type w
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End K V
μ : K
h : f.HasEigenvalue μ
w : V
H : w ∈ f.eigenspace μ
ne0 : w ≠ 0
⊢ eval μ (minpoly K f) • w = 0
state_after: no goals
Theorem: NNReal.tsum_mul_right
File: Mathlib/Topology/Instances/NNReal.lean

tactic: simp only [coe_tsum, NNReal.coe_mul, tsum_mul_right]
state_before: α : Type u_1
f : α → ℝ≥0
a : ℝ≥0
⊢ ↑(∑' (x : α), f x * a) = ↑((∑' (x : α), f x) * a)
state_after: no goals
Theorem: one_add_mul_sub_le_pow
File: Mathlib/Algebra/Order/Ring/Pow.lean

tactic: have : -2 ≤ a - 1 := by
  rwa [← one_add_one_eq_two, neg_add, ← sub_eq_add_neg, sub_le_sub_iff_right]
state_before: R : Type u_1
inst✝ : LinearOrderedRing R
a : R
n✝ : ℕ
H : -1 ≤ a
n : ℕ
⊢ 1 + ↑n * (a - 1) ≤ a ^ n
state_after: R : Type u_1
inst✝ : LinearOrderedRing R
a : R
n✝ : ℕ
H : -1 ≤ a
n : ℕ
this : -2 ≤ a - 1
⊢ 1 + ↑n * (a - 1) ≤ a ^ n

tactic: simpa only [add_sub_cancel] using one_add_mul_le_pow this n
state_before: R : Type u_1
inst✝ : LinearOrderedRing R
a : R
n✝ : ℕ
H : -1 ≤ a
n : ℕ
this : -2 ≤ a - 1
⊢ 1 + ↑n * (a - 1) ≤ a ^ n
state_after: no goals

tactic: rwa [← one_add_one_eq_two, neg_add, ← sub_eq_add_neg, sub_le_sub_iff_right]
state_before: R : Type u_1
inst✝ : LinearOrderedRing R
a : R
n✝ : ℕ
H : -1 ≤ a
n : ℕ
⊢ -2 ≤ a - 1
state_after: no goals
Theorem: Finset.cast_card_erase_of_mem
File: Mathlib/Data/Finset/Card.lean

tactic: rw [card_erase_of_mem hs, Nat.cast_sub, Nat.cast_one]
state_before: α : Type u_1
β : Type u_2
R✝ : Type u_3
s✝ t : Finset α
a b : α
inst✝¹ : DecidableEq α
R : Type u_4
inst✝ : AddGroupWithOne R
s : Finset α
hs : a ∈ s
⊢ ↑(s.erase a).card = ↑s.card - 1
state_after: α : Type u_1
β : Type u_2
R✝ : Type u_3
s✝ t : Finset α
a b : α
inst✝¹ : DecidableEq α
R : Type u_4
inst✝ : AddGroupWithOne R
s : Finset α
hs : a ∈ s
⊢ 1 ≤ s.card

tactic: rw [Nat.add_one_le_iff, Finset.card_pos]
state_before: α : Type u_1
β : Type u_2
R✝ : Type u_3
s✝ t : Finset α
a b : α
inst✝¹ : DecidableEq α
R : Type u_4
inst✝ : AddGroupWithOne R
s : Finset α
hs : a ∈ s
⊢ 1 ≤ s.card
state_after: α : Type u_1
β : Type u_2
R✝ : Type u_3
s✝ t : Finset α
a b : α
inst✝¹ : DecidableEq α
R : Type u_4
inst✝ : AddGroupWithOne R
s : Finset α
hs : a ∈ s
⊢ s.Nonempty

tactic: exact ⟨a, hs⟩
state_before: α : Type u_1
β : Type u_2
R✝ : Type u_3
s✝ t : Finset α
a b : α
inst✝¹ : DecidableEq α
R : Type u_4
inst✝ : AddGroupWithOne R
s : Finset α
hs : a ∈ s
⊢ s.Nonempty
state_after: no goals
Theorem: TensorProduct.map_smul_right
File: Mathlib/LinearAlgebra/TensorProduct/Basic.lean

tactic: ext
state_before: R : Type u_1
inst✝²⁰ : CommSemiring R
R' : Type u_2
inst✝¹⁹ : Monoid R'
R'' : Type u_3
inst✝¹⁸ : Semiring R''
M : Type u_4
N : Type u_5
P : Type u_6
Q : Type u_7
S : Type u_8
T : Type u_9
inst✝¹⁷ : AddCommMonoid M
inst✝¹⁶ : AddCommMonoid N
inst✝¹⁵ : AddCommMonoid P
inst✝¹⁴ : AddCommMonoid Q
inst✝¹³ : AddCommMonoid S
inst✝¹² : AddCommMonoid T
inst✝¹¹ : Module R M
inst✝¹⁰ : Module R N
inst✝⁹ : Module R P
inst✝⁸ : Module R Q
inst✝⁷ : Module R S
inst✝⁶ : Module R T
inst✝⁵ : DistribMulAction R' M
inst✝⁴ : Module R'' M
P' : Type u_10
Q' : Type u_11
inst✝³ : AddCommMonoid P'
inst✝² : Module R P'
inst✝¹ : AddCommMonoid Q'
inst✝ : Module R Q'
r : R
f : M →ₗ[R] P
g : N →ₗ[R] Q
⊢ map f (r • g) = r • map f g
state_after: case H.h.h
R : Type u_1
inst✝²⁰ : CommSemiring R
R' : Type u_2
inst✝¹⁹ : Monoid R'
R'' : Type u_3
inst✝¹⁸ : Semiring R''
M : Type u_4
N : Type u_5
P : Type u_6
Q : Type u_7
S : Type u_8
T : Type u_9
inst✝¹⁷ : AddCommMonoid M
inst✝¹⁶ : AddCommMonoid N
inst✝¹⁵ : AddCommMonoid P
inst✝¹⁴ : AddCommMonoid Q
inst✝¹³ : AddCommMonoid S
inst✝¹² : AddCommMonoid T
inst✝¹¹ : Module R M
inst✝¹⁰ : Module R N
inst✝⁹ : Module R P
inst✝⁸ : Module R Q
inst✝⁷ : Module R S
inst✝⁶ : Module R T
inst✝⁵ : DistribMulAction R' M
inst✝⁴ : Module R'' M
P' : Type u_10
Q' : Type u_11
inst✝³ : AddCommMonoid P'
inst✝² : Module R P'
inst✝¹ : AddCommMonoid Q'
inst✝ : Module R Q'
r : R
f : M →ₗ[R] P
g : N →ₗ[R] Q
x✝¹ : M
x✝ : N
⊢ (((mk R M N).compr₂ (map f (r • g))) x✝¹) x✝ = (((mk R M N).compr₂ (r • map f g)) x✝¹) x✝

tactic: simp only [smul_tmul, compr₂_apply, mk_apply, map_tmul, smul_apply, tmul_smul]
state_before: case H.h.h
R : Type u_1
inst✝²⁰ : CommSemiring R
R' : Type u_2
inst✝¹⁹ : Monoid R'
R'' : Type u_3
inst✝¹⁸ : Semiring R''
M : Type u_4
N : Type u_5
P : Type u_6
Q : Type u_7
S : Type u_8
T : Type u_9
inst✝¹⁷ : AddCommMonoid M
inst✝¹⁶ : AddCommMonoid N
inst✝¹⁵ : AddCommMonoid P
inst✝¹⁴ : AddCommMonoid Q
inst✝¹³ : AddCommMonoid S
inst✝¹² : AddCommMonoid T
inst✝¹¹ : Module R M
inst✝¹⁰ : Module R N
inst✝⁹ : Module R P
inst✝⁸ : Module R Q
inst✝⁷ : Module R S
inst✝⁶ : Module R T
inst✝⁵ : DistribMulAction R' M
inst✝⁴ : Module R'' M
P' : Type u_10
Q' : Type u_11
inst✝³ : AddCommMonoid P'
inst✝² : Module R P'
inst✝¹ : AddCommMonoid Q'
inst✝ : Module R Q'
r : R
f : M →ₗ[R] P
g : N →ₗ[R] Q
x✝¹ : M
x✝ : N
⊢ (((mk R M N).compr₂ (map f (r • g))) x✝¹) x✝ = (((mk R M N).compr₂ (r • map f g)) x✝¹) x✝
state_after: no goals
Theorem: CategoryTheory.GradedObject.mapMap_comp
File: Mathlib/CategoryTheory/GradedObject.lean

tactic: aesop_cat
state_before: I : Type u_1
J : Type u_2
K : Type u_3
C : Type u_4
inst✝³ : Category.{u_5, u_4} C
X Y Z : GradedObject I C
φ : X ⟶ Y
e : X ≅ Y
ψ : Y ⟶ Z
p : I → J
j : J
inst✝² : X.HasMap p
inst✝¹ : Y.HasMap p
inst✝ : Z.HasMap p
⊢ mapMap (φ ≫ ψ) p = mapMap φ p ≫ mapMap ψ p
state_after: no goals
Theorem: Tuple.monotone_proj
File: Mathlib/Data/Fin/Tuple/Sort.lean

tactic: rintro ⟨⟨x, i⟩, hx⟩ ⟨⟨y, j⟩, hy⟩ (_ | h)
state_before: n : ℕ
α : Type u_1
inst✝ : LinearOrder α
f : Fin n → α
⊢ Monotone graph.proj
state_after: case mk.mk.mk.mk.left
n : ℕ
α : Type u_1
inst✝ : LinearOrder α
f : Fin n → α
x : α
i : Fin n
hx : (x, i) ∈ graph f
y : α
j : Fin n
hy : (y, j) ∈ graph f
h✝ : x < y
⊢ graph.proj ⟨(x, i), hx⟩ ≤ graph.proj ⟨(y, j), hy⟩

case mk.mk.mk.mk.right
n : ℕ
α : Type u_1
inst✝ : LinearOrder α
f : Fin n → α
x : α
i : Fin n
hx : (x, i) ∈ graph f
j : Fin n
hy : (x, j) ∈ graph f
h✝ : i ≤ j
⊢ graph.proj ⟨(x, i), hx⟩ ≤ graph.proj ⟨(x, j), hy⟩

tactic: exact le_of_lt ‹_›
state_before: case mk.mk.mk.mk.left
n : ℕ
α : Type u_1
inst✝ : LinearOrder α
f : Fin n → α
x : α
i : Fin n
hx : (x, i) ∈ graph f
y : α
j : Fin n
hy : (y, j) ∈ graph f
h✝ : x < y
⊢ graph.proj ⟨(x, i), hx⟩ ≤ graph.proj ⟨(y, j), hy⟩
state_after: no goals

tactic: simp [graph.proj]
state_before: case mk.mk.mk.mk.right
n : ℕ
α : Type u_1
inst✝ : LinearOrder α
f : Fin n → α
x : α
i : Fin n
hx : (x, i) ∈ graph f
j : Fin n
hy : (x, j) ∈ graph f
h✝ : i ≤ j
⊢ graph.proj ⟨(x, i), hx⟩ ≤ graph.proj ⟨(x, j), hy⟩
state_after: no goals
Theorem: Finset.shadow_iterate_empty
File: Mathlib/Combinatorics/SetFamily/Shadow.lean

tactic: induction' k <;> simp [*, shadow_empty]
state_before: α : Type u_1
inst✝ : DecidableEq α
𝒜 : Finset (Finset α)
s t : Finset α
a : α
k✝ r k : ℕ
⊢ ∂ ^[k] ∅ = ∅
state_after: no goals
Theorem: iteratedFDeriv_clm_apply_const_apply
File: Mathlib/Analysis/Calculus/ContDiff/Basic.lean

tactic: simp only [← iteratedFDerivWithin_univ]
state_before: 𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u✝ : Set E
f f₁ : E → F
g : F → G
x✝ x₀ : E
c✝ : F
b : E × F → G
m✝ n✝ : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
n : ℕ∞
c : E → F →L[𝕜] G
hc : ContDiff 𝕜 n c
i : ℕ
hi : ↑i ≤ n
x : E
u : F
m : Fin i → E
⊢ (iteratedFDeriv 𝕜 i (fun y => (c y) u) x) m = ((iteratedFDeriv 𝕜 i c x) m) u
state_after: 𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u✝ : Set E
f f₁ : E → F
g : F → G
x✝ x₀ : E
c✝ : F
b : E × F → G
m✝ n✝ : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
n : ℕ∞
c : E → F →L[𝕜] G
hc : ContDiff 𝕜 n c
i : ℕ
hi : ↑i ≤ n
x : E
u : F
m : Fin i → E
⊢ (iteratedFDerivWithin 𝕜 i (fun y => (c y) u) univ x) m = ((iteratedFDerivWithin 𝕜 i c univ x) m) u

tactic: exact iteratedFDerivWithin_clm_apply_const_apply uniqueDiffOn_univ hc.contDiffOn hi (mem_univ _)
state_before: 𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u✝ : Set E
f f₁ : E → F
g : F → G
x✝ x₀ : E
c✝ : F
b : E × F → G
m✝ n✝ : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
n : ℕ∞
c : E → F →L[𝕜] G
hc : ContDiff 𝕜 n c
i : ℕ
hi : ↑i ≤ n
x : E
u : F
m : Fin i → E
⊢ (iteratedFDerivWithin 𝕜 i (fun y => (c y) u) univ x) m = ((iteratedFDerivWithin 𝕜 i c univ x) m) u
state_after: no goals
Theorem: Set.Iic_union_Icc
File: Mathlib/Order/Interval/Set/Basic.lean

tactic: rcases le_or_lt c d with hcd | hcd <;> simp [hcd] at h
state_before: α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
h : min c d ≤ b
⊢ Iic b ∪ Icc c d = Iic (max b d)
state_after: case inl
α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
hcd : c ≤ d
h : c ≤ b
⊢ Iic b ∪ Icc c d = Iic (max b d)

case inr
α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
hcd : d < c
h : c ≤ b ∨ d ≤ b
⊢ Iic b ∪ Icc c d = Iic (max b d)

tactic: exact Iic_union_Icc' h
state_before: case inl
α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
hcd : c ≤ d
h : c ≤ b
⊢ Iic b ∪ Icc c d = Iic (max b d)
state_after: no goals

tactic: cases' h with h h
state_before: case inr
α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
hcd : d < c
h : c ≤ b ∨ d ≤ b
⊢ Iic b ∪ Icc c d = Iic (max b d)
state_after: case inr.inl
α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
hcd : d < c
h : c ≤ b
⊢ Iic b ∪ Icc c d = Iic (max b d)

case inr.inr
α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
hcd : d < c
h : d ≤ b
⊢ Iic b ∪ Icc c d = Iic (max b d)

tactic: have hdb : d ≤ b := hcd.le.trans h
state_before: case inr.inl
α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
hcd : d < c
h : c ≤ b
⊢ Iic b ∪ Icc c d = Iic (max b d)
state_after: case inr.inl
α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
hcd : d < c
h : c ≤ b
hdb : d ≤ b
⊢ Iic b ∪ Icc c d = Iic (max b d)

tactic: simp [*]
state_before: case inr.inl
α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
hcd : d < c
h : c ≤ b
hdb : d ≤ b
⊢ Iic b ∪ Icc c d = Iic (max b d)
state_after: no goals

tactic: simp [*]
state_before: case inr.inr
α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
hcd : d < c
h : d ≤ b
⊢ Iic b ∪ Icc c d = Iic (max b d)
state_after: no goals
Theorem: Rat.cast_fract
File: Mathlib/Data/Rat/Floor.lean

tactic: simp only [fract, cast_sub, cast_intCast, floor_cast]
state_before: α : Type u_1
inst✝¹ : LinearOrderedField α
inst✝ : FloorRing α
x : ℚ
⊢ ↑(fract x) = fract ↑x
state_after: no goals
Theorem: Finset.mem_erase_of_ne_of_mem
File: Mathlib/Data/Finset/Basic.lean

tactic: simp only [mem_erase]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s t u v : Finset α
a b : α
⊢ a ≠ b → a ∈ s → a ∈ s.erase b
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s t u v : Finset α
a b : α
⊢ a ≠ b → a ∈ s → a ≠ b ∧ a ∈ s

tactic: exact And.intro
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s t u v : Finset α
a b : α
⊢ a ≠ b → a ∈ s → a ≠ b ∧ a ∈ s
state_after: no goals
Theorem: Stream'.tail_interleave
File: Mathlib/Data/Stream/Init.lean

tactic: unfold interleave corecOn
state_before: α : Type u
β : Type v
δ : Type w
s₁ s₂ : Stream' α
⊢ (s₁ ⋈ s₂).tail = s₂ ⋈ s₁.tail
state_after: α : Type u
β : Type v
δ : Type w
s₁ s₂ : Stream' α
⊢ (corec
        (fun x =>
          match x with
          | (s₁, snd) => s₁.head)
        (fun x =>
          match x with
          | (s₁, s₂) => (s₂, s₁.tail))
        (s₁, s₂)).tail =
    corec
      (fun x =>
        match x with
        | (s₁, snd) => s₁.head)
      (fun x =>
        match x with
        | (s₁, s₂) => (s₂, s₁.tail))
      (s₂, s₁.tail)

tactic: rw [corec_eq]
state_before: α : Type u
β : Type v
δ : Type w
s₁ s₂ : Stream' α
⊢ (corec
        (fun x =>
          match x with
          | (s₁, snd) => s₁.head)
        (fun x =>
          match x with
          | (s₁, s₂) => (s₂, s₁.tail))
        (s₁, s₂)).tail =
    corec
      (fun x =>
        match x with
        | (s₁, snd) => s₁.head)
      (fun x =>
        match x with
        | (s₁, s₂) => (s₂, s₁.tail))
      (s₂, s₁.tail)
state_after: α : Type u
β : Type v
δ : Type w
s₁ s₂ : Stream' α
⊢ ((match (s₁, s₂) with
        | (s₁, snd) => s₁.head) ::
        corec
          (fun x =>
            match x with
            | (s₁, snd) => s₁.head)
          (fun x =>
            match x with
            | (s₁, s₂) => (s₂, s₁.tail))
          (match (s₁, s₂) with
          | (s₁, s₂) => (s₂, s₁.tail))).tail =
    corec
      (fun x =>
        match x with
        | (s₁, snd) => s₁.head)
      (fun x =>
        match x with
        | (s₁, s₂) => (s₂, s₁.tail))
      (s₂, s₁.tail)

tactic: rfl
state_before: α : Type u
β : Type v
δ : Type w
s₁ s₂ : Stream' α
⊢ ((match (s₁, s₂) with
        | (s₁, snd) => s₁.head) ::
        corec
          (fun x =>
            match x with
            | (s₁, snd) => s₁.head)
          (fun x =>
            match x with
            | (s₁, s₂) => (s₂, s₁.tail))
          (match (s₁, s₂) with
          | (s₁, s₂) => (s₂, s₁.tail))).tail =
    corec
      (fun x =>
        match x with
        | (s₁, snd) => s₁.head)
      (fun x =>
        match x with
        | (s₁, s₂) => (s₂, s₁.tail))
      (s₂, s₁.tail)
state_after: no goals
Theorem: Matrix.trace_kroneckerMapBilinear
File: Mathlib/Data/Matrix/Kronecker.lean

tactic: simp_rw [Matrix.trace, Matrix.diag, kroneckerMapBilinear_apply_apply, LinearMap.map_sum₂,
  map_sum, ← Finset.univ_product_univ, Finset.sum_product, kroneckerMap_apply]
state_before: R : Type u_1
α : Type u_2
α' : Type u_3
β : Type u_4
β' : Type u_5
γ : Type u_6
γ' : Type u_7
l : Type u_8
m : Type u_9
n : Type u_10
p : Type u_11
q : Type u_12
r : Type u_13
l' : Type u_14
m' : Type u_15
n' : Type u_16
p' : Type u_17
inst✝⁸ : CommSemiring R
inst✝⁷ : Fintype m
inst✝⁶ : Fintype n
inst✝⁵ : AddCommMonoid α
inst✝⁴ : AddCommMonoid β
inst✝³ : AddCommMonoid γ
inst✝² : Module R α
inst✝¹ : Module R β
inst✝ : Module R γ
f : α →ₗ[R] β →ₗ[R] γ
A : Matrix m m α
B : Matrix n n β
⊢ (((kroneckerMapBilinear f) A) B).trace = (f A.trace) B.trace
state_after: no goals
Theorem: Function.Antiperiodic.odd_nsmul_antiperiodic
File: Mathlib/Algebra/Periodic.lean

tactic: rw [add_nsmul, one_nsmul, ← add_assoc, h, h.even_nsmul_periodic]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x✝ : α
inst✝¹ : AddMonoid α
inst✝ : InvolutiveNeg β
h : Antiperiodic f c
n : ℕ
x : α
⊢ f (x + (2 * n + 1) • c) = -f x
state_after: no goals
Theorem: CategoryTheory.ShortComplex.leftRightHomologyComparison_fac
File: Mathlib/Algebra/Homology/ShortComplex/Homology.lean

tactic: simpa only [LeftHomologyData.homologyIso_leftHomologyData, Iso.symm_inv,
  RightHomologyData.homologyIso_rightHomologyData, Iso.symm_hom] using
    leftRightHomologyComparison'_fac S.leftHomologyData S.rightHomologyData
state_before: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
S S₁ S₂ S₃ S₄ : ShortComplex C
φ : S₁ ⟶ S₂
h₁ : S₁.HomologyData
h₂ : S₂.HomologyData
inst✝ : S.HasHomology
⊢ S.leftRightHomologyComparison = S.leftHomologyIso.hom ≫ S.rightHomologyIso.inv
state_after: no goals
Theorem: Finset.univ_filter_exists
File: Mathlib/Data/Fintype/Basic.lean

tactic: ext
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝³ : Fintype α
s t : Finset α
f : α → β
inst✝² : Fintype β
inst✝¹ : DecidablePred fun y => ∃ x, f x = y
inst✝ : DecidableEq β
⊢ filter (fun y => ∃ x, f x = y) univ = image f univ
state_after: case a
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝³ : Fintype α
s t : Finset α
f : α → β
inst✝² : Fintype β
inst✝¹ : DecidablePred fun y => ∃ x, f x = y
inst✝ : DecidableEq β
a✝ : β
⊢ a✝ ∈ filter (fun y => ∃ x, f x = y) univ ↔ a✝ ∈ image f univ

tactic: simp
state_before: case a
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝³ : Fintype α
s t : Finset α
f : α → β
inst✝² : Fintype β
inst✝¹ : DecidablePred fun y => ∃ x, f x = y
inst✝ : DecidableEq β
a✝ : β
⊢ a✝ ∈ filter (fun y => ∃ x, f x = y) univ ↔ a✝ ∈ image f univ
state_after: no goals
Theorem: CategoryTheory.Pretriangulated.op_distinguished
File: Mathlib/CategoryTheory/Triangulated/Opposite.lean

tactic: rw [mem_distTriang_op_iff']
state_before: C : Type u_1
inst✝⁵ : Category.{u_2, u_1} C
inst✝⁴ : HasShift C ℤ
inst✝³ : HasZeroObject C
inst✝² : Preadditive C
inst✝¹ : ∀ (n : ℤ), (shiftFunctor C n).Additive
inst✝ : Pretriangulated C
T : Triangle C
hT : T ∈ distinguishedTriangles
⊢ (triangleOpEquivalence C).functor.obj { unop := T } ∈ distinguishedTriangles
state_after: C : Type u_1
inst✝⁵ : Category.{u_2, u_1} C
inst✝⁴ : HasShift C ℤ
inst✝³ : HasZeroObject C
inst✝² : Preadditive C
inst✝¹ : ∀ (n : ℤ), (shiftFunctor C n).Additive
inst✝ : Pretriangulated C
T : Triangle C
hT : T ∈ distinguishedTriangles
⊢ ∃ T',
    ∃ (_ : T' ∈ distinguishedTriangles),
      Nonempty
        ((triangleOpEquivalence C).functor.obj { unop := T } ≅ (triangleOpEquivalence C).functor.obj { unop := T' })

tactic: exact ⟨T, hT, ⟨Iso.refl _⟩⟩
state_before: C : Type u_1
inst✝⁵ : Category.{u_2, u_1} C
inst✝⁴ : HasShift C ℤ
inst✝³ : HasZeroObject C
inst✝² : Preadditive C
inst✝¹ : ∀ (n : ℤ), (shiftFunctor C n).Additive
inst✝ : Pretriangulated C
T : Triangle C
hT : T ∈ distinguishedTriangles
⊢ ∃ T',
    ∃ (_ : T' ∈ distinguishedTriangles),
      Nonempty
        ((triangleOpEquivalence C).functor.obj { unop := T } ≅ (triangleOpEquivalence C).functor.obj { unop := T' })
state_after: no goals
Theorem: Int.addSubmonoid_closure_range_mul_self
File: Mathlib/Data/Int/Star.lean

tactic: simpa only [sq] using addSubmonoid_closure_range_pow even_two
state_before: ⊢ closure (range fun x => x * x) = nonneg ℤ
state_after: no goals
Theorem: Monoid.exp_eq_one_iff
File: Mathlib/GroupTheory/Exponent.lean

tactic: refine ⟨fun eq_one => ⟨fun a b => ?a_eq_b⟩, fun h => le_antisymm ?le ?ge⟩
state_before: G : Type u
inst✝ : Monoid G
⊢ exponent G = 1 ↔ Subsingleton G
state_after: case a_eq_b
G : Type u
inst✝ : Monoid G
eq_one : exponent G = 1
a b : G
⊢ a = b

case le
G : Type u
inst✝ : Monoid G
h : Subsingleton G
⊢ exponent G ≤ 1

case ge
G : Type u
inst✝ : Monoid G
h : Subsingleton G
⊢ 1 ≤ exponent G

tactic: rw [← pow_one a, ← pow_one b, ← eq_one, Monoid.pow_exponent_eq_one, Monoid.pow_exponent_eq_one]
state_before: case a_eq_b
G : Type u
inst✝ : Monoid G
eq_one : exponent G = 1
a b : G
⊢ a = b
state_after: no goals

tactic: apply exponent_min' _ Nat.one_pos
state_before: case le
G : Type u
inst✝ : Monoid G
h : Subsingleton G
⊢ exponent G ≤ 1
state_after: case le
G : Type u
inst✝ : Monoid G
h : Subsingleton G
⊢ ∀ (g : G), g ^ 1 = 1

tactic: simp [eq_iff_true_of_subsingleton]
state_before: case le
G : Type u
inst✝ : Monoid G
h : Subsingleton G
⊢ ∀ (g : G), g ^ 1 = 1
state_after: no goals

tactic: apply Nat.succ_le_of_lt
state_before: case ge
G : Type u
inst✝ : Monoid G
h : Subsingleton G
⊢ 1 ≤ exponent G
state_after: case ge.h
G : Type u
inst✝ : Monoid G
h : Subsingleton G
⊢ 0 < exponent G

tactic: apply exponent_pos_of_exists 1 Nat.one_pos
state_before: case ge.h
G : Type u
inst✝ : Monoid G
h : Subsingleton G
⊢ 0 < exponent G
state_after: case ge.h
G : Type u
inst✝ : Monoid G
h : Subsingleton G
⊢ ∀ (g : G), g ^ 1 = 1

tactic: simp [eq_iff_true_of_subsingleton]
state_before: case ge.h
G : Type u
inst✝ : Monoid G
h : Subsingleton G
⊢ ∀ (g : G), g ^ 1 = 1
state_after: no goals