1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Option.get_map
File: Mathlib/Data/Option/Basic.lean

tactic: rwa [← isSome_map]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
f : α → β
o : Option α
h : (Option.map f o).isSome = true
⊢ o.isSome = true
state_after: no goals

tactic: cases o <;> [simp at h; rfl]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
f : α → β
o : Option α
h : (Option.map f o).isSome = true
⊢ (Option.map f o).get h = f (o.get ⋯)
state_after: no goals
Theorem: AddConstMapClass.map_int_add
File: Mathlib/Algebra/AddConstMap/Basic.lean

tactic: simp
state_before: F : Type u_1
G : Type u_2
H : Type u_3
inst✝³ : FunLike F G H
a : G
b : H
inst✝² : AddCommGroupWithOne G
inst✝¹ : AddGroupWithOne H
inst✝ : AddConstMapClass F G H 1 1
f : F
n : ℤ
x : G
⊢ f (↑n + x) = f x + ↑n
state_after: no goals
Theorem: Zsqrtd.smul_val
File: Mathlib/NumberTheory/Zsqrtd/Basic.lean

tactic: ext <;> simp
state_before: d n x y : ℤ
⊢ ↑n * { re := x, im := y } = { re := n * x, im := n * y }
state_after: no goals
Theorem: MonoidAlgebra.support_gen_of_gen'
File: Mathlib/RingTheory/FiniteType.lean

tactic: suffices (of R M '' ⋃ f ∈ S, (f.support : Set M)) = ⋃ f ∈ S, of R M '' (f.support : Set M) by
  rw [this]
  exact support_gen_of_gen hS
state_before: R : Type u_1
M : Type u_2
inst✝¹ : CommSemiring R
inst✝ : Monoid M
S : Set (MonoidAlgebra R M)
hS : adjoin R S = ⊤
⊢ adjoin R (⇑(of R M) '' ⋃ f ∈ S, ↑f.support) = ⊤
state_after: R : Type u_1
M : Type u_2
inst✝¹ : CommSemiring R
inst✝ : Monoid M
S : Set (MonoidAlgebra R M)
hS : adjoin R S = ⊤
⊢ ⇑(of R M) '' ⋃ f ∈ S, ↑f.support = ⋃ f ∈ S, ⇑(of R M) '' ↑f.support

tactic: simp only [Set.image_iUnion]
state_before: R : Type u_1
M : Type u_2
inst✝¹ : CommSemiring R
inst✝ : Monoid M
S : Set (MonoidAlgebra R M)
hS : adjoin R S = ⊤
⊢ ⇑(of R M) '' ⋃ f ∈ S, ↑f.support = ⋃ f ∈ S, ⇑(of R M) '' ↑f.support
state_after: no goals

tactic: rw [this]
state_before: R : Type u_1
M : Type u_2
inst✝¹ : CommSemiring R
inst✝ : Monoid M
S : Set (MonoidAlgebra R M)
hS : adjoin R S = ⊤
this : ⇑(of R M) '' ⋃ f ∈ S, ↑f.support = ⋃ f ∈ S, ⇑(of R M) '' ↑f.support
⊢ adjoin R (⇑(of R M) '' ⋃ f ∈ S, ↑f.support) = ⊤
state_after: R : Type u_1
M : Type u_2
inst✝¹ : CommSemiring R
inst✝ : Monoid M
S : Set (MonoidAlgebra R M)
hS : adjoin R S = ⊤
this : ⇑(of R M) '' ⋃ f ∈ S, ↑f.support = ⋃ f ∈ S, ⇑(of R M) '' ↑f.support
⊢ adjoin R (⋃ f ∈ S, ⇑(of R M) '' ↑f.support) = ⊤

tactic: exact support_gen_of_gen hS
state_before: R : Type u_1
M : Type u_2
inst✝¹ : CommSemiring R
inst✝ : Monoid M
S : Set (MonoidAlgebra R M)
hS : adjoin R S = ⊤
this : ⇑(of R M) '' ⋃ f ∈ S, ↑f.support = ⋃ f ∈ S, ⇑(of R M) '' ↑f.support
⊢ adjoin R (⋃ f ∈ S, ⇑(of R M) '' ↑f.support) = ⊤
state_after: no goals
Theorem: Equiv.Perm.subtypeCongr.left_apply
File: Mathlib/Logic/Equiv/Basic.lean

tactic: simp [Perm.subtypeCongr.apply, h]
state_before: ε : Type u_1
p : ε → Prop
inst✝ : DecidablePred p
ep ep' : Perm { a // p a }
en en' : Perm { a // ¬p a }
a : ε
h : p a
⊢ (ep.subtypeCongr en) a = ↑(ep ⟨a, h⟩)
state_after: no goals
Theorem: Multiset.prod_map_one
File: Mathlib/Algebra/BigOperators/Group/Multiset.lean

tactic: rw [map_const', prod_replicate, one_pow]
state_before: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝¹ : CommMonoid α
inst✝ : CommMonoid β
s t : Multiset α
a : α
m : Multiset ι
f g : ι → α
⊢ (map (fun x => 1) m).prod = 1
state_after: no goals
Theorem: Polynomial.eraseLead_C_mul_X
File: Mathlib/Algebra/Polynomial/EraseLead.lean

tactic: simpa using eraseLead_C_mul_X_pow _ 1
state_before: R : Type u_1
inst✝ : Semiring R
f : R[X]
r : R
⊢ (C r * X).eraseLead = 0
state_after: no goals
Theorem: Mathlib.Tactic.Ring.add_pf_add_gt
File: Mathlib/Tactic/Ring/Basic.lean

tactic: subst_vars
state_before: u : Lean.Level
R : Type u_1
α : Q(Type u)
sα : Q(CommSemiring «$α»)
inst✝ : CommSemiring R
a b₂ c b₁ : R
x✝ : a + b₂ = c
⊢ a + (b₁ + b₂) = b₁ + c
state_after: u : Lean.Level
R : Type u_1
α : Q(Type u)
sα : Q(CommSemiring «$α»)
inst✝ : CommSemiring R
a b₂ b₁ : R
⊢ a + (b₁ + b₂) = b₁ + (a + b₂)

tactic: simp [add_left_comm]
state_before: u : Lean.Level
R : Type u_1
α : Q(Type u)
sα : Q(CommSemiring «$α»)
inst✝ : CommSemiring R
a b₂ b₁ : R
⊢ a + (b₁ + b₂) = b₁ + (a + b₂)
state_after: no goals
Theorem: RCLike.I_mul_re
File: Mathlib/Analysis/RCLike/Basic.lean

tactic: simp only [I_re, zero_sub, I_im', zero_mul, mul_re]
state_before: K : Type u_1
E : Type u_2
inst✝ : RCLike K
z : K
⊢ re (I * z) = -im z
state_after: no goals
Theorem: CategoryTheory.Limits.le_kernelSubobject
File: Mathlib/CategoryTheory/Subobject/Limits.lean

tactic: simp
state_before: C : Type u
inst✝² : Category.{v, u} C
X Y Z : C
inst✝¹ : HasZeroMorphisms C
f : X ⟶ Y
inst✝ : HasKernel f
A : Subobject X
h : A.arrow ≫ f = 0
⊢ kernel.lift f A.arrow h ≫ kernel.ι f = A.arrow
state_after: no goals
Theorem: Representation.linHom.mem_invariants_iff_comm
File: Mathlib/RepresentationTheory/Invariants.lean

tactic: dsimp
state_before: k : Type u
inst✝ : CommRing k
G : Grp
X Y : Rep k ↑G
f : ↑X.V →ₗ[k] ↑Y.V
g : ↑G
⊢ ((X.ρ.linHom Y.ρ) g) f = f ↔ f ∘ₗ X.ρ g = Y.ρ g ∘ₗ f
state_after: k : Type u
inst✝ : CommRing k
G : Grp
X Y : Rep k ↑G
f : ↑X.V →ₗ[k] ↑Y.V
g : ↑G
⊢ Y.ρ g ∘ₗ f ∘ₗ X.ρ g⁻¹ = f ↔ f ∘ₗ X.ρ g = Y.ρ g ∘ₗ f

tactic: erw [← ρAut_apply_inv]
state_before: k : Type u
inst✝ : CommRing k
G : Grp
X Y : Rep k ↑G
f : ↑X.V →ₗ[k] ↑Y.V
g : ↑G
⊢ Y.ρ g ∘ₗ f ∘ₗ X.ρ g⁻¹ = f ↔ f ∘ₗ X.ρ g = Y.ρ g ∘ₗ f
state_after: k : Type u
inst✝ : CommRing k
G : Grp
X Y : Rep k ↑G
f : ↑X.V →ₗ[k] ↑Y.V
g : ↑G
⊢ Y.ρ g ∘ₗ f ∘ₗ ((ρAut X) g).inv = f ↔ f ∘ₗ X.ρ g = Y.ρ g ∘ₗ f

tactic: rw [← LinearMap.comp_assoc, ← ModuleCat.comp_def, ← ModuleCat.comp_def, Iso.inv_comp_eq,
  ρAut_apply_hom]
state_before: k : Type u
inst✝ : CommRing k
G : Grp
X Y : Rep k ↑G
f : ↑X.V →ₗ[k] ↑Y.V
g : ↑G
⊢ Y.ρ g ∘ₗ f ∘ₗ ((ρAut X) g).inv = f ↔ f ∘ₗ X.ρ g = Y.ρ g ∘ₗ f
state_after: k : Type u
inst✝ : CommRing k
G : Grp
X Y : Rep k ↑G
f : ↑X.V →ₗ[k] ↑Y.V
g : ↑G
⊢ f ≫ Y.ρ g = X.ρ g ≫ f ↔ f ∘ₗ X.ρ g = f ≫ Y.ρ g

tactic: exact comm
state_before: k : Type u
inst✝ : CommRing k
G : Grp
X Y : Rep k ↑G
f : ↑X.V →ₗ[k] ↑Y.V
g : ↑G
⊢ f ≫ Y.ρ g = X.ρ g ≫ f ↔ f ∘ₗ X.ρ g = f ≫ Y.ρ g
state_after: no goals
Theorem: Real.arsinh_neg
File: Mathlib/Analysis/SpecialFunctions/Arsinh.lean

tactic: rw [← exp_eq_exp, exp_arsinh, exp_neg, exp_arsinh]
state_before: x✝ y x : ℝ
⊢ arsinh (-x) = -arsinh x
state_after: x✝ y x : ℝ
⊢ -x + √(1 + (-x) ^ 2) = (x + √(1 + x ^ 2))⁻¹

tactic: apply eq_inv_of_mul_eq_one_left
state_before: x✝ y x : ℝ
⊢ -x + √(1 + (-x) ^ 2) = (x + √(1 + x ^ 2))⁻¹
state_after: case h
x✝ y x : ℝ
⊢ (-x + √(1 + (-x) ^ 2)) * (x + √(1 + x ^ 2)) = 1

tactic: rw [neg_sq, neg_add_eq_sub, add_comm x, mul_comm, ← sq_sub_sq, sq_sqrt, add_sub_cancel_right]
state_before: case h
x✝ y x : ℝ
⊢ (-x + √(1 + (-x) ^ 2)) * (x + √(1 + x ^ 2)) = 1
state_after: case h
x✝ y x : ℝ
⊢ 0 ≤ 1 + x ^ 2

tactic: exact add_nonneg zero_le_one (sq_nonneg _)
state_before: case h
x✝ y x : ℝ
⊢ 0 ≤ 1 + x ^ 2
state_after: no goals
Theorem: Filter.mem_prod_principal
File: Mathlib/Order/Filter/Prod.lean

tactic: rw [← @exists_mem_subset_iff _ f, mem_prod_iff]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
s✝ : Set α
t : Set β
f : Filter α
g : Filter β
s : Set (α × β)
⊢ s ∈ f ×ˢ 𝓟 t ↔ {a | ∀ b ∈ t, (a, b) ∈ s} ∈ f
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
s✝ : Set α
t : Set β
f : Filter α
g : Filter β
s : Set (α × β)
⊢ (∃ t₁ ∈ f, ∃ t₂ ∈ 𝓟 t, t₁ ×ˢ t₂ ⊆ s) ↔ ∃ t_1 ∈ f, t_1 ⊆ {a | ∀ b ∈ t, (a, b) ∈ s}

tactic: refine exists_congr fun u => Iff.rfl.and ⟨?_, fun h => ⟨t, mem_principal_self t, ?_⟩⟩
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
s✝ : Set α
t : Set β
f : Filter α
g : Filter β
s : Set (α × β)
⊢ (∃ t₁ ∈ f, ∃ t₂ ∈ 𝓟 t, t₁ ×ˢ t₂ ⊆ s) ↔ ∃ t_1 ∈ f, t_1 ⊆ {a | ∀ b ∈ t, (a, b) ∈ s}
state_after: case refine_1
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
s✝ : Set α
t : Set β
f : Filter α
g : Filter β
s : Set (α × β)
u : Set α
⊢ (∃ t₂ ∈ 𝓟 t, u ×ˢ t₂ ⊆ s) → u ⊆ {a | ∀ b ∈ t, (a, b) ∈ s}

case refine_2
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
s✝ : Set α
t : Set β
f : Filter α
g : Filter β
s : Set (α × β)
u : Set α
h : u ⊆ {a | ∀ b ∈ t, (a, b) ∈ s}
⊢ u ×ˢ t ⊆ s

tactic: rintro ⟨v, v_in, hv⟩ a a_in b b_in
state_before: case refine_1
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
s✝ : Set α
t : Set β
f : Filter α
g : Filter β
s : Set (α × β)
u : Set α
⊢ (∃ t₂ ∈ 𝓟 t, u ×ˢ t₂ ⊆ s) → u ⊆ {a | ∀ b ∈ t, (a, b) ∈ s}
state_after: case refine_1.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
s✝ : Set α
t : Set β
f : Filter α
g : Filter β
s : Set (α × β)
u : Set α
v : Set β
v_in : v ∈ 𝓟 t
hv : u ×ˢ v ⊆ s
a : α
a_in : a ∈ u
b : β
b_in : b ∈ t
⊢ (a, b) ∈ s

tactic: exact hv (mk_mem_prod a_in <| v_in b_in)
state_before: case refine_1.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
s✝ : Set α
t : Set β
f : Filter α
g : Filter β
s : Set (α × β)
u : Set α
v : Set β
v_in : v ∈ 𝓟 t
hv : u ×ˢ v ⊆ s
a : α
a_in : a ∈ u
b : β
b_in : b ∈ t
⊢ (a, b) ∈ s
state_after: no goals

tactic: rintro ⟨x, y⟩ ⟨hx, hy⟩
state_before: case refine_2
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
s✝ : Set α
t : Set β
f : Filter α
g : Filter β
s : Set (α × β)
u : Set α
h : u ⊆ {a | ∀ b ∈ t, (a, b) ∈ s}
⊢ u ×ˢ t ⊆ s
state_after: case refine_2.mk.intro
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
s✝ : Set α
t : Set β
f : Filter α
g : Filter β
s : Set (α × β)
u : Set α
h : u ⊆ {a | ∀ b ∈ t, (a, b) ∈ s}
x : α
y : β
hx : (x, y).1 ∈ u
hy : (x, y).2 ∈ t
⊢ (x, y) ∈ s

tactic: exact h hx y hy
state_before: case refine_2.mk.intro
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
s✝ : Set α
t : Set β
f : Filter α
g : Filter β
s : Set (α × β)
u : Set α
h : u ⊆ {a | ∀ b ∈ t, (a, b) ∈ s}
x : α
y : β
hx : (x, y).1 ∈ u
hy : (x, y).2 ∈ t
⊢ (x, y) ∈ s
state_after: no goals
Theorem: Algebra.discr_localizationLocalization
File: Mathlib/RingTheory/Localization/NormTrace.lean

tactic: rw [Algebra.discr_def, Algebra.discr_def, RingHom.map_det,
  Algebra.traceMatrix_localizationLocalization]
state_before: R : Type u_1
S : Type u_2
inst✝²¹ : CommRing R
inst✝²⁰ : CommRing S
inst✝¹⁹ : Algebra R S
Rₘ : Type u_3
Sₘ✝ : Type u_4
inst✝¹⁸ : CommRing Rₘ
inst✝¹⁷ : Algebra R Rₘ
inst✝¹⁶ : CommRing Sₘ✝
inst✝¹⁵ : Algebra S Sₘ✝
M : Submonoid R
inst✝¹⁴ : IsLocalization M Rₘ
inst✝¹³ : IsLocalization (algebraMapSubmonoid S M) Sₘ✝
inst✝¹² : Algebra Rₘ Sₘ✝
inst✝¹¹ : Algebra R Sₘ✝
inst✝¹⁰ : IsScalarTower R Rₘ Sₘ✝
inst✝⁹ : IsScalarTower R S Sₘ✝
Sₘ : Type u_5
inst✝⁸ : CommRing Sₘ
inst✝⁷ : Algebra S Sₘ
inst✝⁶ : Algebra Rₘ Sₘ
inst✝⁵ : Algebra R Sₘ
inst✝⁴ : IsScalarTower R Rₘ Sₘ
inst✝³ : IsScalarTower R S Sₘ
inst✝² : IsLocalization (algebraMapSubmonoid S M) Sₘ
ι : Type u_6
inst✝¹ : Fintype ι
inst✝ : DecidableEq ι
b : Basis ι R S
⊢ discr Rₘ ⇑(Basis.localizationLocalization Rₘ M Sₘ b) = (algebraMap R Rₘ) (discr R ⇑b)
state_after: no goals
Theorem: ProbabilityTheory.kernel.rnDeriv_eq_top_iff
File: Mathlib/Probability/Kernel/RadonNikodym.lean

tactic: simp only [rnDeriv, ENNReal.div_eq_top, ne_eq, ENNReal.ofReal_eq_zero, not_le,
  tsub_le_iff_right, zero_add, ENNReal.ofReal_ne_top, not_false_eq_true, and_true, or_false,
  mutuallySingularSet, mem_setOf_eq, and_iff_right_iff_imp]
state_before: α : Type u_1
γ : Type u_2
mα : MeasurableSpace α
mγ : MeasurableSpace γ
κ✝ η✝ : ↥(kernel α γ)
hαγ : MeasurableSpace.CountableOrCountablyGenerated α γ
κ η : ↥(kernel α γ)
a : α
x : γ
⊢ rnDeriv κ η a x = ⊤ ↔ (a, x) ∈ mutuallySingularSet κ η
state_after: α : Type u_1
γ : Type u_2
mα : MeasurableSpace α
mγ : MeasurableSpace γ
κ✝ η✝ : ↥(kernel α γ)
hαγ : MeasurableSpace.CountableOrCountablyGenerated α γ
κ η : ↥(kernel α γ)
a : α
x : γ
⊢ 1 ≤ rnDerivAux κ (κ + η) a x → 0 < rnDerivAux κ (κ + η) a x

tactic: exact fun h ↦ zero_lt_one.trans_le h
state_before: α : Type u_1
γ : Type u_2
mα : MeasurableSpace α
mγ : MeasurableSpace γ
κ✝ η✝ : ↥(kernel α γ)
hαγ : MeasurableSpace.CountableOrCountablyGenerated α γ
κ η : ↥(kernel α γ)
a : α
x : γ
⊢ 1 ≤ rnDerivAux κ (κ + η) a x → 0 < rnDerivAux κ (κ + η) a x
state_after: no goals
Theorem: LinearMap.compMultilinearMap_domDomCongr
File: Mathlib/LinearAlgebra/Multilinear/Basic.lean

tactic: ext
state_before: R : Type uR
S : Type uS
ι : Type uι
n : ℕ
M : Fin n.succ → Type v
M₁ : ι → Type v₁
M₂ : Type v₂
M₃ : Type v₃
M' : Type v'
inst✝⁸ : Semiring R
inst✝⁷ : (i : ι) → AddCommMonoid (M₁ i)
inst✝⁶ : AddCommMonoid M₂
inst✝⁵ : AddCommMonoid M₃
inst✝⁴ : AddCommMonoid M'
inst✝³ : (i : ι) → Module R (M₁ i)
inst✝² : Module R M₂
inst✝¹ : Module R M₃
inst✝ : Module R M'
ι₁ : Type u_1
ι₂ : Type u_2
σ : ι₁ ≃ ι₂
g : M₂ →ₗ[R] M₃
f : MultilinearMap R (fun x => M') M₂
⊢ MultilinearMap.domDomCongr σ (g.compMultilinearMap f) = g.compMultilinearMap (MultilinearMap.domDomCongr σ f)
state_after: case H
R : Type uR
S : Type uS
ι : Type uι
n : ℕ
M : Fin n.succ → Type v
M₁ : ι → Type v₁
M₂ : Type v₂
M₃ : Type v₃
M' : Type v'
inst✝⁸ : Semiring R
inst✝⁷ : (i : ι) → AddCommMonoid (M₁ i)
inst✝⁶ : AddCommMonoid M₂
inst✝⁵ : AddCommMonoid M₃
inst✝⁴ : AddCommMonoid M'
inst✝³ : (i : ι) → Module R (M₁ i)
inst✝² : Module R M₂
inst✝¹ : Module R M₃
inst✝ : Module R M'
ι₁ : Type u_1
ι₂ : Type u_2
σ : ι₁ ≃ ι₂
g : M₂ →ₗ[R] M₃
f : MultilinearMap R (fun x => M') M₂
x✝ : ι₂ → M'
⊢ (MultilinearMap.domDomCongr σ (g.compMultilinearMap f)) x✝ =
    (g.compMultilinearMap (MultilinearMap.domDomCongr σ f)) x✝

tactic: simp [MultilinearMap.domDomCongr]
state_before: case H
R : Type uR
S : Type uS
ι : Type uι
n : ℕ
M : Fin n.succ → Type v
M₁ : ι → Type v₁
M₂ : Type v₂
M₃ : Type v₃
M' : Type v'
inst✝⁸ : Semiring R
inst✝⁷ : (i : ι) → AddCommMonoid (M₁ i)
inst✝⁶ : AddCommMonoid M₂
inst✝⁵ : AddCommMonoid M₃
inst✝⁴ : AddCommMonoid M'
inst✝³ : (i : ι) → Module R (M₁ i)
inst✝² : Module R M₂
inst✝¹ : Module R M₃
inst✝ : Module R M'
ι₁ : Type u_1
ι₂ : Type u_2
σ : ι₁ ≃ ι₂
g : M₂ →ₗ[R] M₃
f : MultilinearMap R (fun x => M') M₂
x✝ : ι₂ → M'
⊢ (MultilinearMap.domDomCongr σ (g.compMultilinearMap f)) x✝ =
    (g.compMultilinearMap (MultilinearMap.domDomCongr σ f)) x✝
state_after: no goals
Theorem: SimpleGraph.Walk.mem_support_iff
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: cases p <;> simp
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v w : V
p : G.Walk u v
⊢ w ∈ p.support ↔ w = u ∨ w ∈ p.support.tail
state_after: no goals
Theorem: AffineMap.homothety_add
File: Mathlib/LinearAlgebra/AffineSpace/AffineMap.lean

tactic: simp only [homothety_def, add_smul, vadd_vadd]
state_before: R : Type u_1
k : Type u_2
V1 : Type u_3
P1 : Type u_4
V2 : Type u_5
P2 : Type u_6
V3 : Type u_7
P3 : Type u_8
inst✝⁵ : CommRing k
inst✝⁴ : AddCommGroup V1
inst✝³ : AffineSpace V1 P1
inst✝² : AddCommGroup V2
inst✝¹ : Module k V1
inst✝ : Module k V2
c : P1
r₁ r₂ : k
⊢ homothety c (r₁ + r₂) = r₁ • (id k P1 -ᵥ const k P1 c) +ᵥ homothety c r₂
state_after: no goals
Theorem: Equiv.Perm.IsCycle.conj
File: Mathlib/GroupTheory/Perm/Cycle/Basic.lean

tactic: rintro ⟨x, hx, h⟩
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
f g : Perm α
x y : α
⊢ f.IsCycle → (g * f * g⁻¹).IsCycle
state_after: case intro.intro
ι : Type u_1
α : Type u_2
β : Type u_3
f g : Perm α
x✝ y x : α
hx : f x ≠ x
h : ∀ ⦃y : α⦄, f y ≠ y → f.SameCycle x y
⊢ (g * f * g⁻¹).IsCycle

tactic: refine ⟨g x, by simp [coe_mul, inv_apply_self, hx], fun y hy => ?_⟩
state_before: case intro.intro
ι : Type u_1
α : Type u_2
β : Type u_3
f g : Perm α
x✝ y x : α
hx : f x ≠ x
h : ∀ ⦃y : α⦄, f y ≠ y → f.SameCycle x y
⊢ (g * f * g⁻¹).IsCycle
state_after: case intro.intro
ι : Type u_1
α : Type u_2
β : Type u_3
f g : Perm α
x✝ y✝ x : α
hx : f x ≠ x
h : ∀ ⦃y : α⦄, f y ≠ y → f.SameCycle x y
y : α
hy : (g * f * g⁻¹) y ≠ y
⊢ (g * f * g⁻¹).SameCycle (g x) y

tactic: rw [← apply_inv_self g y]
state_before: case intro.intro
ι : Type u_1
α : Type u_2
β : Type u_3
f g : Perm α
x✝ y✝ x : α
hx : f x ≠ x
h : ∀ ⦃y : α⦄, f y ≠ y → f.SameCycle x y
y : α
hy : (g * f * g⁻¹) y ≠ y
⊢ (g * f * g⁻¹).SameCycle (g x) y
state_after: case intro.intro
ι : Type u_1
α : Type u_2
β : Type u_3
f g : Perm α
x✝ y✝ x : α
hx : f x ≠ x
h : ∀ ⦃y : α⦄, f y ≠ y → f.SameCycle x y
y : α
hy : (g * f * g⁻¹) y ≠ y
⊢ (g * f * g⁻¹).SameCycle (g x) (g (g⁻¹ y))

tactic: exact (h <| eq_inv_iff_eq.not.2 hy).conj
state_before: case intro.intro
ι : Type u_1
α : Type u_2
β : Type u_3
f g : Perm α
x✝ y✝ x : α
hx : f x ≠ x
h : ∀ ⦃y : α⦄, f y ≠ y → f.SameCycle x y
y : α
hy : (g * f * g⁻¹) y ≠ y
⊢ (g * f * g⁻¹).SameCycle (g x) (g (g⁻¹ y))
state_after: no goals

tactic: simp [coe_mul, inv_apply_self, hx]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
f g : Perm α
x✝ y x : α
hx : f x ≠ x
h : ∀ ⦃y : α⦄, f y ≠ y → f.SameCycle x y
⊢ (g * f * g⁻¹) (g x) ≠ g x
state_after: no goals
Theorem: LieModule.Weight.hasEigenvalueAt
File: Mathlib/Algebra/Lie/Weights/Basic.lean

tactic: obtain ⟨k : ℕ, hk : (toEnd R L M x).genEigenspace (χ x) k ≠ ⊥⟩ := by
  simpa [Module.End.maxGenEigenspace, weightSpaceOf] using χ.weightSpaceOf_ne_bot x
state_before: K : Type u_1
R : Type u_2
L : Type u_3
M : Type u_4
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
inst✝⁴ : LieAlgebra.IsNilpotent R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
χ : Weight R L M
x : L
⊢ ((toEnd R L M) x).HasEigenvalue (χ x)
state_after: case intro
K : Type u_1
R : Type u_2
L : Type u_3
M : Type u_4
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
inst✝⁴ : LieAlgebra.IsNilpotent R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
χ : Weight R L M
x : L
k : ℕ
hk : (((toEnd R L M) x).genEigenspace (χ x)) k ≠ ⊥
⊢ ((toEnd R L M) x).HasEigenvalue (χ x)

tactic: exact Module.End.hasEigenvalue_of_hasGenEigenvalue hk
state_before: case intro
K : Type u_1
R : Type u_2
L : Type u_3
M : Type u_4
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
inst✝⁴ : LieAlgebra.IsNilpotent R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
χ : Weight R L M
x : L
k : ℕ
hk : (((toEnd R L M) x).genEigenspace (χ x)) k ≠ ⊥
⊢ ((toEnd R L M) x).HasEigenvalue (χ x)
state_after: no goals

tactic: simpa [Module.End.maxGenEigenspace, weightSpaceOf] using χ.weightSpaceOf_ne_bot x
state_before: K : Type u_1
R : Type u_2
L : Type u_3
M : Type u_4
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
inst✝⁴ : LieAlgebra.IsNilpotent R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
χ : Weight R L M
x : L
⊢ ?m.153721
state_after: no goals
Theorem: Matrix.algebraMap_matrix_apply
File: Mathlib/Data/Matrix/Basic.lean

tactic: dsimp [algebraMap, Algebra.toRingHom, Matrix.scalar]
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝⁶ : Fintype n
inst✝⁵ : DecidableEq n
inst✝⁴ : CommSemiring R
inst✝³ : Semiring α
inst✝² : Semiring β
inst✝¹ : Algebra R α
inst✝ : Algebra R β
r : R
i j : n
⊢ (algebraMap R (Matrix n n α)) r i j = if i = j then (algebraMap R α) r else 0
state_after: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝⁶ : Fintype n
inst✝⁵ : DecidableEq n
inst✝⁴ : CommSemiring R
inst✝³ : Semiring α
inst✝² : Semiring β
inst✝¹ : Algebra R α
inst✝ : Algebra R β
r : R
i j : n
⊢ diagonal ((Pi.constRingHom n α) (Algebra.toRingHom r)) i j = if i = j then Algebra.toRingHom r else 0

tactic: split_ifs with h <;> simp [h, Matrix.one_apply_ne]
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝⁶ : Fintype n
inst✝⁵ : DecidableEq n
inst✝⁴ : CommSemiring R
inst✝³ : Semiring α
inst✝² : Semiring β
inst✝¹ : Algebra R α
inst✝ : Algebra R β
r : R
i j : n
⊢ diagonal ((Pi.constRingHom n α) (Algebra.toRingHom r)) i j = if i = j then Algebra.toRingHom r else 0
state_after: no goals
Theorem: Finset.inter_biUnion
File: Mathlib/Data/Finset/Union.lean

tactic: rw [inter_comm, biUnion_inter]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
s✝ s₁ s₂ : Finset α
t✝ t₁ t₂ : α → Finset β
inst✝ : DecidableEq β
t : Finset β
s : Finset α
f : α → Finset β
⊢ t ∩ s.biUnion f = s.biUnion fun x => t ∩ f x
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
s✝ s₁ s₂ : Finset α
t✝ t₁ t₂ : α → Finset β
inst✝ : DecidableEq β
t : Finset β
s : Finset α
f : α → Finset β
⊢ (s.biUnion fun x => f x ∩ t) = s.biUnion fun x => t ∩ f x

tactic: simp [inter_comm]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
s✝ s₁ s₂ : Finset α
t✝ t₁ t₂ : α → Finset β
inst✝ : DecidableEq β
t : Finset β
s : Finset α
f : α → Finset β
⊢ (s.biUnion fun x => f x ∩ t) = s.biUnion fun x => t ∩ f x
state_after: no goals
Theorem: Complex.sinh_sub_cosh
File: Mathlib/Data/Complex/Exponential.lean

tactic: rw [← neg_sub, cosh_sub_sinh]
state_before: x y : ℂ
⊢ sinh x - cosh x = -cexp (-x)
state_after: no goals
Theorem: Finset.sup'_le_iff
File: Mathlib/Data/Finset/Lattice.lean

tactic: simp_rw [← @WithBot.coe_le_coe α, coe_sup', Finset.sup_le_iff]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : SemilatticeSup α
s : Finset β
H : s.Nonempty
f : β → α
a : α
⊢ s.sup' H f ≤ a ↔ ∀ b ∈ s, f b ≤ a
state_after: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : SemilatticeSup α
s : Finset β
H : s.Nonempty
f : β → α
a : α
⊢ (∀ b ∈ s, (WithBot.some ∘ f) b ≤ ↑a) ↔ ∀ b ∈ s, ↑(f b) ≤ ↑a

tactic: rfl
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : SemilatticeSup α
s : Finset β
H : s.Nonempty
f : β → α
a : α
⊢ (∀ b ∈ s, (WithBot.some ∘ f) b ≤ ↑a) ↔ ∀ b ∈ s, ↑(f b) ≤ ↑a
state_after: no goals
Theorem: Profinite.NobelingProof.GoodProducts.linearIndependentSingleton
File: Mathlib/Topology/Category/Profinite/Nobeling.lean

tactic: refine linearIndependent_unique (eval ({fun _ ↦ false} : Set (I → Bool))) ?_
state_before: I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
⊢ LinearIndependent ℤ (eval {fun x => false})
state_after: I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
⊢ eval {fun x => false} default ≠ 0

tactic: simp only [eval, Products.eval, List.map, List.prod_nil, ne_eq, one_ne_zero, not_false_eq_true]
state_before: I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
⊢ eval {fun x => false} default ≠ 0
state_after: no goals
Theorem: Polynomial.support_eq_empty
File: Mathlib/Algebra/Polynomial/Basic.lean

tactic: rcases p with ⟨⟩
state_before: R : Type u
a b : R
m n : ℕ
inst✝ : Semiring R
p q : R[X]
⊢ p.support = ∅ ↔ p = 0
state_after: case ofFinsupp
R : Type u
a b : R
m n : ℕ
inst✝ : Semiring R
q : R[X]
toFinsupp✝ : R[ℕ]
⊢ { toFinsupp := toFinsupp✝ }.support = ∅ ↔ { toFinsupp := toFinsupp✝ } = 0

tactic: simp [support]
state_before: case ofFinsupp
R : Type u
a b : R
m n : ℕ
inst✝ : Semiring R
q : R[X]
toFinsupp✝ : R[ℕ]
⊢ { toFinsupp := toFinsupp✝ }.support = ∅ ↔ { toFinsupp := toFinsupp✝ } = 0
state_after: no goals