1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Fin.lt_sub_one_iff
File: Mathlib/Algebra/Group/Fin.lean

tactic: rcases k with ⟨_ | k, hk⟩
state_before: m n : ℕ
k : Fin (n + 2)
⊢ k < k - 1 ↔ k = 0
state_after: case mk.zero
m n : ℕ
hk : 0 < n + 2
⊢ ⟨0, hk⟩ < ⟨0, hk⟩ - 1 ↔ ⟨0, hk⟩ = 0

case mk.succ
m n k : ℕ
hk : k + 1 < n + 2
⊢ ⟨k + 1, hk⟩ < ⟨k + 1, hk⟩ - 1 ↔ ⟨k + 1, hk⟩ = 0

tactic: have : (n + 1 + (k + 1)) % (n + 2) = k % (n + 2) := by
  rw [Nat.add_comm, Nat.add_right_comm, Nat.add_assoc, Nat.add_assoc, add_mod_right]
state_before: case mk.succ
m n k : ℕ
hk : k + 1 < n + 2
⊢ ⟨k + 1, hk⟩ < ⟨k + 1, hk⟩ - 1 ↔ ⟨k + 1, hk⟩ = 0
state_after: case mk.succ
m n k : ℕ
hk : k + 1 < n + 2
this : (n + 1 + (k + 1)) % (n + 2) = k % (n + 2)
⊢ ⟨k + 1, hk⟩ < ⟨k + 1, hk⟩ - 1 ↔ ⟨k + 1, hk⟩ = 0

tactic: simp [lt_iff_val_lt_val, ext_iff, Fin.coe_sub, this,
  mod_eq_of_lt ((lt_succ_self _).trans hk)]
state_before: case mk.succ
m n k : ℕ
hk : k + 1 < n + 2
this : (n + 1 + (k + 1)) % (n + 2) = k % (n + 2)
⊢ ⟨k + 1, hk⟩ < ⟨k + 1, hk⟩ - 1 ↔ ⟨k + 1, hk⟩ = 0
state_after: no goals

tactic: simp only [zero_eta, zero_sub, lt_iff_val_lt_val, val_zero, coe_neg_one, zero_lt_succ]
state_before: case mk.zero
m n : ℕ
hk : 0 < n + 2
⊢ ⟨0, hk⟩ < ⟨0, hk⟩ - 1 ↔ ⟨0, hk⟩ = 0
state_after: no goals

tactic: rw [Nat.add_comm, Nat.add_right_comm, Nat.add_assoc, Nat.add_assoc, add_mod_right]
state_before: m n k : ℕ
hk : k + 1 < n + 2
⊢ (n + 1 + (k + 1)) % (n + 2) = k % (n + 2)
state_after: no goals
Theorem: NNReal.rpow_left_injective
File: Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean

tactic: simpa only [rpow_inv_rpow_self hx] using congr_arg (fun y => y ^ (1 / x)) hyz
state_before: w x✝ y✝ z✝ x : ℝ
hx : x ≠ 0
y z : ℝ≥0
hyz : (fun y => y ^ x) y = (fun y => y ^ x) z
⊢ y = z
state_after: no goals
Theorem: Subsemiring.coe_iSup_of_directed
File: Mathlib/Algebra/Ring/Subsemiring/Basic.lean

tactic: simp [mem_iSup_of_directed hS]
state_before: R : Type u
S✝ : Type v
T : Type w
inst✝² : NonAssocSemiring R
M : Submonoid R
inst✝¹ : NonAssocSemiring S✝
inst✝ : NonAssocSemiring T
ι : Sort u_1
hι : Nonempty ι
S : ι → Subsemiring R
hS : Directed (fun x x_1 => x ≤ x_1) S
x : R
⊢ x ∈ ↑(⨆ i, S i) ↔ x ∈ ⋃ i, ↑(S i)
state_after: no goals
Theorem: MeasureTheory.HasFiniteIntegral.smul_measure
File: Mathlib/MeasureTheory/Function/L1Space.lean

tactic: simp only [HasFiniteIntegral, lintegral_smul_measure] at *
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → β
h : HasFiniteIntegral f μ
c : ℝ≥0∞
hc : c ≠ ⊤
⊢ HasFiniteIntegral f (c • μ)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → β
h : ∫⁻ (a : α), ↑‖f a‖₊ ∂μ < ⊤
c : ℝ≥0∞
hc : c ≠ ⊤
⊢ c * ∫⁻ (a : α), ↑‖f a‖₊ ∂μ < ⊤

tactic: exact mul_lt_top hc h.ne
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → β
h : ∫⁻ (a : α), ↑‖f a‖₊ ∂μ < ⊤
c : ℝ≥0∞
hc : c ≠ ⊤
⊢ c * ∫⁻ (a : α), ↑‖f a‖₊ ∂μ < ⊤
state_after: no goals
Theorem: LieSubmodule.map_comap_eq
File: Mathlib/Algebra/Lie/IdealOperations.lean

tactic: rw [SetLike.ext'_iff]
state_before: R : Type u
L : Type v
M : Type w
M₂ : Type w₁
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' : LieSubmodule R L M
I J : LieIdeal R L
N₂ : LieSubmodule R L M₂
f : M →ₗ⁅R,L⁆ M₂
hf : N₂ ≤ f.range
⊢ map f (comap f N₂) = N₂
state_after: R : Type u
L : Type v
M : Type w
M₂ : Type w₁
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' : LieSubmodule R L M
I J : LieIdeal R L
N₂ : LieSubmodule R L M₂
f : M →ₗ⁅R,L⁆ M₂
hf : N₂ ≤ f.range
⊢ ↑(map f (comap f N₂)) = ↑N₂

tactic: exact Set.image_preimage_eq_of_subset hf
state_before: R : Type u
L : Type v
M : Type w
M₂ : Type w₁
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' : LieSubmodule R L M
I J : LieIdeal R L
N₂ : LieSubmodule R L M₂
f : M →ₗ⁅R,L⁆ M₂
hf : N₂ ≤ f.range
⊢ ↑(map f (comap f N₂)) = ↑N₂
state_after: no goals
Theorem: Real.abs_cos_eq_sqrt_one_sub_sin_sq
File: Mathlib/Data/Complex/Exponential.lean

tactic: rw [← cos_sq', sqrt_sq_eq_abs]
state_before: x✝ y x : ℝ
⊢ |cos x| = √(1 - sin x ^ 2)
state_after: no goals
Theorem: Finset.weightedVSub_eq_linear_combination
File: Mathlib/LinearAlgebra/AffineSpace/Combination.lean

tactic: simp [s.weightedVSub_apply, vsub_eq_sub, smul_sub, ← Finset.sum_smul, 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
S : AffineSpace V P
ι✝ : Type u_4
s✝ : Finset ι✝
ι₂ : Type u_5
s₂ : Finset ι₂
ι : Type u_6
s : Finset ι
w : ι → k
p : ι → V
hw : s.sum w = 0
⊢ (s.weightedVSub p) w = ∑ i ∈ s, w i • p i
state_after: no goals
Theorem: mem_nhdsWithin_insert
File: Mathlib/Topology/ContinuousOn.lean

tactic: simp
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : TopologicalSpace α
a : α
s t : Set α
⊢ t ∈ 𝓝[insert a s] a ↔ a ∈ t ∧ t ∈ 𝓝[s] a
state_after: no goals
Theorem: Multiset.toEnumFinset_filter_eq
File: Mathlib/Data/Multiset/Fintype.lean

tactic: ext ⟨y, i⟩
state_before: α : Type u_1
inst✝ : DecidableEq α
m✝ m : Multiset α
x : α
⊢ Finset.filter (fun p => x = p.1) m.toEnumFinset =
    Finset.map { toFun := Prod.mk x, inj' := ⋯ } (Finset.range (count x m))
state_after: case a.mk
α : Type u_1
inst✝ : DecidableEq α
m✝ m : Multiset α
x y : α
i : ℕ
⊢ (y, i) ∈ Finset.filter (fun p => x = p.1) m.toEnumFinset ↔
    (y, i) ∈ Finset.map { toFun := Prod.mk x, inj' := ⋯ } (Finset.range (count x m))

tactic: simp only [eq_comm, Finset.mem_filter, Multiset.mem_toEnumFinset, Finset.mem_map,
  Finset.mem_range, Function.Embedding.coeFn_mk, Prod.mk.inj_iff, exists_prop,
  exists_eq_right_right', and_congr_left_iff]
state_before: case a.mk
α : Type u_1
inst✝ : DecidableEq α
m✝ m : Multiset α
x y : α
i : ℕ
⊢ (y, i) ∈ Finset.filter (fun p => x = p.1) m.toEnumFinset ↔
    (y, i) ∈ Finset.map { toFun := Prod.mk x, inj' := ⋯ } (Finset.range (count x m))
state_after: case a.mk
α : Type u_1
inst✝ : DecidableEq α
m✝ m : Multiset α
x y : α
i : ℕ
⊢ x = y → (i < count y m ↔ i < count x m)

tactic: rintro rfl
state_before: case a.mk
α : Type u_1
inst✝ : DecidableEq α
m✝ m : Multiset α
x y : α
i : ℕ
⊢ x = y → (i < count y m ↔ i < count x m)
state_after: case a.mk
α : Type u_1
inst✝ : DecidableEq α
m✝ m : Multiset α
x : α
i : ℕ
⊢ i < count x m ↔ i < count x m

tactic: rfl
state_before: case a.mk
α : Type u_1
inst✝ : DecidableEq α
m✝ m : Multiset α
x : α
i : ℕ
⊢ i < count x m ↔ i < count x m
state_after: no goals
Theorem: Matrix.inv_add_inv
File: Mathlib/LinearAlgebra/Matrix/NonsingularInverse.lean

tactic: simpa only [nonsing_inv_eq_ring_inverse] using Ring.inverse_add_inverse h
state_before: l : Type u_1
m : Type u
n : Type u'
α : Type v
inst✝² : Fintype n
inst✝¹ : DecidableEq n
inst✝ : CommRing α
A✝ B✝ A B : Matrix n n α
h : IsUnit A ↔ IsUnit B
⊢ A⁻¹ + B⁻¹ = A⁻¹ * (A + B) * B⁻¹
state_after: no goals
Theorem: NormedSpace.expSeries_eq_expSeries
File: Mathlib/Analysis/NormedSpace/Exponential.lean

tactic: rw [expSeries_apply_eq, expSeries_apply_eq, inv_natCast_smul_eq 𝕂 𝕂']
state_before: 𝕂 : Type u_1
𝕂' : Type u_2
𝔸 : Type u_3
inst✝⁶ : Field 𝕂
inst✝⁵ : Field 𝕂'
inst✝⁴ : Ring 𝔸
inst✝³ : Algebra 𝕂 𝔸
inst✝² : Algebra 𝕂' 𝔸
inst✝¹ : TopologicalSpace 𝔸
inst✝ : TopologicalRing 𝔸
n : ℕ
x : 𝔸
⊢ ((expSeries 𝕂 𝔸 n) fun x_1 => x) = (expSeries 𝕂' 𝔸 n) fun x_1 => x
state_after: no goals
Theorem: GeneralizedContinuedFraction.squashGCF_nth_of_lt
File: Mathlib/Algebra/ContinuedFractions/ConvergentsEquiv.lean

tactic: simp only [squashGCF, squashSeq_nth_of_lt m_lt_n, Nat.add_eq, add_zero]
state_before: K : Type u_1
n : ℕ
g : GeneralizedContinuedFraction K
s : Stream'.Seq (Pair K)
inst✝ : DivisionRing K
m : ℕ
m_lt_n : m < n
⊢ (g.squashGCF (n + 1)).s.get? m = g.s.get? m
state_after: no goals
Theorem: Sym2.GameAdd.snd_fst
File: Mathlib/Order/GameAdd.lean

tactic: rw [Sym2.eq_swap]
state_before: α : Type u_1
β : Type u_2
rα : α → α → Prop
rβ : β → β → Prop
a : α
b✝ : β
a₁ a₂ b : α
h : rα a₁ a₂
⊢ GameAdd rα s(b, a₁) s(a₂, b)
state_after: α : Type u_1
β : Type u_2
rα : α → α → Prop
rβ : β → β → Prop
a : α
b✝ : β
a₁ a₂ b : α
h : rα a₁ a₂
⊢ GameAdd rα s(a₁, b) s(a₂, b)

tactic: exact GameAdd.fst h
state_before: α : Type u_1
β : Type u_2
rα : α → α → Prop
rβ : β → β → Prop
a : α
b✝ : β
a₁ a₂ b : α
h : rα a₁ a₂
⊢ GameAdd rα s(a₁, b) s(a₂, b)
state_after: no goals
Theorem: Relation.reflGen_minimal
File: Mathlib/Logic/Relation.lean

tactic: simpa [reflGen_eq_self hr'] using ReflGen.mono h hxy
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
a b c d : α
r' : α → α → Prop
hr' : Reflexive r'
h : ∀ (x y : α), r x y → r' x y
x y : α
hxy : ReflGen r x y
⊢ r' x y
state_after: no goals
Theorem: bihimp_left_comm
File: Mathlib/Order/SymmDiff.lean

tactic: simp_rw [← bihimp_assoc, bihimp_comm]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝ : BooleanAlgebra α
a b c d : α
⊢ a ⇔ (b ⇔ c) = b ⇔ (a ⇔ c)
state_after: no goals
Theorem: IsClosed.measure_eq_one_iff_eq_univ
File: Mathlib/MeasureTheory/Measure/OpenPos.lean

tactic: rw [← measure_univ (μ := μ), hF.measure_eq_univ_iff_eq]
state_before: X : Type u_1
Y : Type u_2
inst✝⁵ : TopologicalSpace X
m : MeasurableSpace X
inst✝⁴ : TopologicalSpace Y
inst✝³ : T2Space Y
μ ν : Measure X
inst✝² : μ.IsOpenPosMeasure
s U F : Set X
x : X
inst✝¹ : OpensMeasurableSpace X
inst✝ : IsProbabilityMeasure μ
hF : IsClosed F
⊢ μ F = 1 ↔ F = univ
state_after: no goals
Theorem: Filter.lift'_iInf
File: Mathlib/Order/Filter/Lift.lean

tactic: simp only [inf_principal, comp, hg]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
f✝ f₁ f₂ : Filter α
h h₁ h₂ : Set α → Set β
inst✝ : Nonempty ι
f : ι → Filter α
g : Set α → Set β
hg : ∀ (s t : Set α), g (s ∩ t) = g s ∩ g t
s t : Set α
⊢ (𝓟 ∘ g) (s ∩ t) = (𝓟 ∘ g) s ⊓ (𝓟 ∘ g) t
state_after: no goals
Theorem: Rep.linearization_single
File: Mathlib/RepresentationTheory/Rep.lean

tactic: rw [linearization_obj_ρ, Finsupp.lmapDomain_apply, Finsupp.mapDomain_single]
state_before: k G : Type u
inst✝¹ : CommRing k
inst✝ : Monoid G
X : Action (Type u) (MonCat.of G)
g : G
x : X.V
r : k
⊢ (((linearization k G).obj X).ρ g) (Finsupp.single x r) = Finsupp.single (X.ρ g x) r
state_after: no goals
Theorem: ContMDiff.div₀
File: Mathlib/Geometry/Manifold/Algebra/LieGroup.lean

tactic: simpa only [div_eq_mul_inv] using hf.mul (hg.inv₀ h₀)
state_before: 𝕜 : Type u_1
inst✝¹³ : NontriviallyNormedField 𝕜
H : Type u_2
inst✝¹² : TopologicalSpace H
E : Type u_3
inst✝¹¹ : NormedAddCommGroup E
inst✝¹⁰ : NormedSpace 𝕜 E
I : ModelWithCorners 𝕜 E H
G : Type u_4
inst✝⁹ : TopologicalSpace G
inst✝⁸ : ChartedSpace H G
inst✝⁷ : GroupWithZero G
inst✝⁶ : SmoothInv₀ I G
inst✝⁵ : SmoothMul I G
E' : Type u_5
inst✝⁴ : NormedAddCommGroup E'
inst✝³ : NormedSpace 𝕜 E'
H' : Type u_6
inst✝² : TopologicalSpace H'
I' : ModelWithCorners 𝕜 E' H'
M : Type u_7
inst✝¹ : TopologicalSpace M
inst✝ : ChartedSpace H' M
f g : M → G
s : Set M
a : M
n : ℕ∞
hf : ContMDiff I' I n f
hg : ContMDiff I' I n g
h₀ : ∀ (x : M), g x ≠ 0
⊢ ContMDiff I' I n (f / g)
state_after: no goals
Theorem: Real.abs_le_sqrt
File: Mathlib/Data/Real/Sqrt.lean

tactic: rw [← sqrt_sq_eq_abs]
state_before: x y : ℝ
h : x ^ 2 ≤ y
⊢ |x| ≤ √y
state_after: x y : ℝ
h : x ^ 2 ≤ y
⊢ √(x ^ 2) ≤ √y

tactic: exact sqrt_le_sqrt h
state_before: x y : ℝ
h : x ^ 2 ≤ y
⊢ √(x ^ 2) ≤ √y
state_after: no goals
Theorem: Continuous.fourier_inversion
File: Mathlib/Analysis/Fourier/Inversion.lean

tactic: ext v
state_before: V : Type u_1
E : Type u_2
inst✝⁷ : NormedAddCommGroup V
inst✝⁶ : InnerProductSpace ℝ V
inst✝⁵ : MeasurableSpace V
inst✝⁴ : BorelSpace V
inst✝³ : FiniteDimensional ℝ V
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
f : V → E
inst✝ : CompleteSpace E
h : Continuous f
hf : Integrable f volume
h'f : Integrable (𝓕 f) volume
⊢ 𝓕⁻ (𝓕 f) = f
state_after: case h
V : Type u_1
E : Type u_2
inst✝⁷ : NormedAddCommGroup V
inst✝⁶ : InnerProductSpace ℝ V
inst✝⁵ : MeasurableSpace V
inst✝⁴ : BorelSpace V
inst✝³ : FiniteDimensional ℝ V
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
f : V → E
inst✝ : CompleteSpace E
h : Continuous f
hf : Integrable f volume
h'f : Integrable (𝓕 f) volume
v : V
⊢ 𝓕⁻ (𝓕 f) v = f v

tactic: exact hf.fourier_inversion h'f h.continuousAt
state_before: case h
V : Type u_1
E : Type u_2
inst✝⁷ : NormedAddCommGroup V
inst✝⁶ : InnerProductSpace ℝ V
inst✝⁵ : MeasurableSpace V
inst✝⁴ : BorelSpace V
inst✝³ : FiniteDimensional ℝ V
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
f : V → E
inst✝ : CompleteSpace E
h : Continuous f
hf : Integrable f volume
h'f : Integrable (𝓕 f) volume
v : V
⊢ 𝓕⁻ (𝓕 f) v = f v
state_after: no goals
Theorem: bernoulli_zero_fourier_coeff
File: Mathlib/NumberTheory/ZetaValues.lean

tactic: simpa using bernoulliFourierCoeff_recurrence 0 hn
state_before: n : ℤ
hn : n ≠ 0
⊢ bernoulliFourierCoeff 0 n = 0
state_after: no goals
Theorem: monomial_has_deriv_aux
File: Mathlib/Analysis/Calculus/Taylor.lean

tactic: simp_rw [sub_eq_neg_add]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
t x : ℝ
n : ℕ
⊢ HasDerivAt (fun y => (x - y) ^ (n + 1)) (-(↑n + 1) * (x - t) ^ n) t
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
t x : ℝ
n : ℕ
⊢ HasDerivAt (fun y => (-y + x) ^ (n + 1)) (-(↑n + 1) * (-t + x) ^ n) t

tactic: rw [← neg_one_mul, mul_comm (-1 : ℝ), mul_assoc, mul_comm (-1 : ℝ), ← mul_assoc]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
t x : ℝ
n : ℕ
⊢ HasDerivAt (fun y => (-y + x) ^ (n + 1)) (-(↑n + 1) * (-t + x) ^ n) t
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
t x : ℝ
n : ℕ
⊢ HasDerivAt (fun y => (-y + x) ^ (n + 1)) ((↑n + 1) * (-t + x) ^ n * -1) t

tactic: convert HasDerivAt.pow (n + 1) ((hasDerivAt_id t).neg.add_const x)
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
t x : ℝ
n : ℕ
⊢ HasDerivAt (fun y => (-y + x) ^ (n + 1)) ((↑n + 1) * (-t + x) ^ n * -1) t
state_after: case h.e'_7.h.e'_5.h.e'_5
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
t x : ℝ
n : ℕ
⊢ ↑n + 1 = ↑(n + 1)

tactic: simp only [Nat.cast_add, Nat.cast_one]
state_before: case h.e'_7.h.e'_5.h.e'_5
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
t x : ℝ
n : ℕ
⊢ ↑n + 1 = ↑(n + 1)
state_after: no goals
Theorem: convexHull_exists_dist_ge2
File: Mathlib/Analysis/Convex/Normed.lean

tactic: rcases convexHull_exists_dist_ge hx y with ⟨x', hx', Hx'⟩
state_before: ι : Type u_1
E : Type u_2
P : Type u_3
inst✝³ : SeminormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : PseudoMetricSpace P
inst✝ : NormedAddTorsor E P
s✝ t✝ s t : Set E
x y : E
hx : x ∈ (convexHull ℝ) s
hy : y ∈ (convexHull ℝ) t
⊢ ∃ x' ∈ s, ∃ y' ∈ t, dist x y ≤ dist x' y'
state_after: case intro.intro
ι : Type u_1
E : Type u_2
P : Type u_3
inst✝³ : SeminormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : PseudoMetricSpace P
inst✝ : NormedAddTorsor E P
s✝ t✝ s t : Set E
x y : E
hx : x ∈ (convexHull ℝ) s
hy : y ∈ (convexHull ℝ) t
x' : E
hx' : x' ∈ s
Hx' : dist x y ≤ dist x' y
⊢ ∃ x' ∈ s, ∃ y' ∈ t, dist x y ≤ dist x' y'

tactic: rcases convexHull_exists_dist_ge hy x' with ⟨y', hy', Hy'⟩
state_before: case intro.intro
ι : Type u_1
E : Type u_2
P : Type u_3
inst✝³ : SeminormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : PseudoMetricSpace P
inst✝ : NormedAddTorsor E P
s✝ t✝ s t : Set E
x y : E
hx : x ∈ (convexHull ℝ) s
hy : y ∈ (convexHull ℝ) t
x' : E
hx' : x' ∈ s
Hx' : dist x y ≤ dist x' y
⊢ ∃ x' ∈ s, ∃ y' ∈ t, dist x y ≤ dist x' y'
state_after: case intro.intro.intro.intro
ι : Type u_1
E : Type u_2
P : Type u_3
inst✝³ : SeminormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : PseudoMetricSpace P
inst✝ : NormedAddTorsor E P
s✝ t✝ s t : Set E
x y : E
hx : x ∈ (convexHull ℝ) s
hy : y ∈ (convexHull ℝ) t
x' : E
hx' : x' ∈ s
Hx' : dist x y ≤ dist x' y
y' : E
hy' : y' ∈ t
Hy' : dist y x' ≤ dist y' x'
⊢ ∃ x' ∈ s, ∃ y' ∈ t, dist x y ≤ dist x' y'

tactic: use x', hx', y', hy'
state_before: case intro.intro.intro.intro
ι : Type u_1
E : Type u_2
P : Type u_3
inst✝³ : SeminormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : PseudoMetricSpace P
inst✝ : NormedAddTorsor E P
s✝ t✝ s t : Set E
x y : E
hx : x ∈ (convexHull ℝ) s
hy : y ∈ (convexHull ℝ) t
x' : E
hx' : x' ∈ s
Hx' : dist x y ≤ dist x' y
y' : E
hy' : y' ∈ t
Hy' : dist y x' ≤ dist y' x'
⊢ ∃ x' ∈ s, ∃ y' ∈ t, dist x y ≤ dist x' y'
state_after: case right
ι : Type u_1
E : Type u_2
P : Type u_3
inst✝³ : SeminormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : PseudoMetricSpace P
inst✝ : NormedAddTorsor E P
s✝ t✝ s t : Set E
x y : E
hx : x ∈ (convexHull ℝ) s
hy : y ∈ (convexHull ℝ) t
x' : E
hx' : x' ∈ s
Hx' : dist x y ≤ dist x' y
y' : E
hy' : y' ∈ t
Hy' : dist y x' ≤ dist y' x'
⊢ dist x y ≤ dist x' y'

tactic: exact le_trans Hx' (dist_comm y x' ▸ dist_comm y' x' ▸ Hy')
state_before: case right
ι : Type u_1
E : Type u_2
P : Type u_3
inst✝³ : SeminormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : PseudoMetricSpace P
inst✝ : NormedAddTorsor E P
s✝ t✝ s t : Set E
x y : E
hx : x ∈ (convexHull ℝ) s
hy : y ∈ (convexHull ℝ) t
x' : E
hx' : x' ∈ s
Hx' : dist x y ≤ dist x' y
y' : E
hy' : y' ∈ t
Hy' : dist y x' ≤ dist y' x'
⊢ dist x y ≤ dist x' y'
state_after: no goals
Theorem: CategoryTheory.Limits.Types.descSet_spec
File: Mathlib/CategoryTheory/Limits/Preserves/Ulift.lean

tactic: refine ⟨?_, fun he ↦ funext fun x ↦ ?_⟩
state_before: J : Type u_1
inst✝ : Category.{u_2, u_1} J
K : J ⥤ Type u
c : Cocone K
hc : IsColimit c
lc : Cocone (K ⋙ uliftFunctor.{v, u})
s : Set c.pt
ls : Set lc.pt
⊢ descSet hc ls = s ↔ ∀ (j : J) (x : K.obj j), lc.ι.app j { down := x } ∈ ls ↔ c.ι.app j x ∈ s
state_after: case refine_1
J : Type u_1
inst✝ : Category.{u_2, u_1} J
K : J ⥤ Type u
c : Cocone K
hc : IsColimit c
lc : Cocone (K ⋙ uliftFunctor.{v, u})
s : Set c.pt
ls : Set lc.pt
⊢ descSet hc ls = s → ∀ (j : J) (x : K.obj j), lc.ι.app j { down := x } ∈ ls ↔ c.ι.app j x ∈ s

case refine_2
J : Type u_1
inst✝ : Category.{u_2, u_1} J
K : J ⥤ Type u
c : Cocone K
hc : IsColimit c
lc : Cocone (K ⋙ uliftFunctor.{v, u})
s : Set c.pt
ls : Set lc.pt
he : ∀ (j : J) (x : K.obj j), lc.ι.app j { down := x } ∈ ls ↔ c.ι.app j x ∈ s
x : c.pt
⊢ descSet hc ls x = s x

tactic: rintro rfl j x
state_before: case refine_1
J : Type u_1
inst✝ : Category.{u_2, u_1} J
K : J ⥤ Type u
c : Cocone K
hc : IsColimit c
lc : Cocone (K ⋙ uliftFunctor.{v, u})
s : Set c.pt
ls : Set lc.pt
⊢ descSet hc ls = s → ∀ (j : J) (x : K.obj j), lc.ι.app j { down := x } ∈ ls ↔ c.ι.app j x ∈ s
state_after: case refine_1
J : Type u_1
inst✝ : Category.{u_2, u_1} J
K : J ⥤ Type u
c : Cocone K
hc : IsColimit c
lc : Cocone (K ⋙ uliftFunctor.{v, u})
ls : Set lc.pt
j : J
x : K.obj j
⊢ lc.ι.app j { down := x } ∈ ls ↔ c.ι.app j x ∈ descSet hc ls

tactic: exact (congr_arg ULift.down (congr_fun (hc.fac (coconeOfSet ls) j) x).symm).to_iff
state_before: case refine_1
J : Type u_1
inst✝ : Category.{u_2, u_1} J
K : J ⥤ Type u
c : Cocone K
hc : IsColimit c
lc : Cocone (K ⋙ uliftFunctor.{v, u})
ls : Set lc.pt
j : J
x : K.obj j
⊢ lc.ι.app j { down := x } ∈ ls ↔ c.ι.app j x ∈ descSet hc ls
state_after: no goals

tactic: ext y
state_before: case refine_2
J : Type u_1
inst✝ : Category.{u_2, u_1} J
K : J ⥤ Type u
c : Cocone K
hc : IsColimit c
lc : Cocone (K ⋙ uliftFunctor.{v, u})
s : Set c.pt
ls : Set lc.pt
he : ∀ (j : J) (x : K.obj j), lc.ι.app j { down := x } ∈ ls ↔ c.ι.app j x ∈ s
x : c.pt
j : J
⊢ (c.ι.app j ≫ fun x => { down := x ∈ s }) = (coconeOfSet ls).ι.app j
state_after: case refine_2.h
J : Type u_1
inst✝ : Category.{u_2, u_1} J
K : J ⥤ Type u
c : Cocone K
hc : IsColimit c
lc : Cocone (K ⋙ uliftFunctor.{v, u})
s : Set c.pt
ls : Set lc.pt
he : ∀ (j : J) (x : K.obj j), lc.ι.app j { down := x } ∈ ls ↔ c.ι.app j x ∈ s
x : c.pt
j : J
y : K.obj j
⊢ (c.ι.app j ≫ fun x => { down := x ∈ s }) y = (coconeOfSet ls).ι.app j y

tactic: exact congr_arg ULift.up (propext (he j y).symm)
state_before: case refine_2.h
J : Type u_1
inst✝ : Category.{u_2, u_1} J
K : J ⥤ Type u
c : Cocone K
hc : IsColimit c
lc : Cocone (K ⋙ uliftFunctor.{v, u})
s : Set c.pt
ls : Set lc.pt
he : ∀ (j : J) (x : K.obj j), lc.ι.app j { down := x } ∈ ls ↔ c.ι.app j x ∈ s
x : c.pt
j : J
y : K.obj j
⊢ (c.ι.app j ≫ fun x => { down := x ∈ s }) y = (coconeOfSet ls).ι.app j y
state_after: no goals
Theorem: Finsupp.toAList_keys_toFinset
File: Mathlib/Data/Finsupp/AList.lean

tactic: ext
state_before: α : Type u_1
M : Type u_2
inst✝¹ : Zero M
inst✝ : DecidableEq α
f : α →₀ M
⊢ f.toAList.keys.toFinset = f.support
state_after: case a
α : Type u_1
M : Type u_2
inst✝¹ : Zero M
inst✝ : DecidableEq α
f : α →₀ M
a✝ : α
⊢ a✝ ∈ f.toAList.keys.toFinset ↔ a✝ ∈ f.support

tactic: simp [toAList, AList.mem_keys, AList.keys, List.keys]
state_before: case a
α : Type u_1
M : Type u_2
inst✝¹ : Zero M
inst✝ : DecidableEq α
f : α →₀ M
a✝ : α
⊢ a✝ ∈ f.toAList.keys.toFinset ↔ a✝ ∈ f.support
state_after: no goals
Theorem: Set.image_prod_mk_subset_prod
File: Mathlib/Data/Set/Prod.lean

tactic: rintro _ ⟨x, hx, rfl⟩
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
s✝ s₁ s₂ : Set α
t t₁ t₂ : Set β
a : α
b : β
f : α → β
g : α → γ
s : Set α
⊢ (fun x => (f x, g x)) '' s ⊆ (f '' s) ×ˢ (g '' s)
state_after: case intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
s✝ s₁ s₂ : Set α
t t₁ t₂ : Set β
a : α
b : β
f : α → β
g : α → γ
s : Set α
x : α
hx : x ∈ s
⊢ (fun x => (f x, g x)) x ∈ (f '' s) ×ˢ (g '' s)

tactic: exact mk_mem_prod (mem_image_of_mem f hx) (mem_image_of_mem g hx)
state_before: case intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
s✝ s₁ s₂ : Set α
t t₁ t₂ : Set β
a : α
b : β
f : α → β
g : α → γ
s : Set α
x : α
hx : x ∈ s
⊢ (fun x => (f x, g x)) x ∈ (f '' s) ×ˢ (g '' s)
state_after: no goals
Theorem: Module.End.IsSemisimple.aeval
File: Mathlib/LinearAlgebra/Semisimple.lean

tactic: rw [← Ideal.Quotient.liftₐ_comp (.span {minpoly K f}) (aeval f)
  fun a h ↦ by rwa [Ideal.span, ← minpoly.ker_aeval_eq_span_minpoly] at h, aeval_algHom,
  AlgHom.comp_apply, AlgHom.comp_apply, ← aeval_algHom_apply, minpoly.aeval, map_zero]
state_before: R✝ : Type u_1
M : Type u_2
inst✝⁵ : CommRing R✝
inst✝⁴ : AddCommGroup M
inst✝³ : Module R✝ M
K : Type u_3
inst✝² : Field K
inst✝¹ : Module K M
f g : End K M
inst✝ : FiniteDimensional K M
hf : f.IsSemisimple
p : K[X]
R : Type u_3 := K[X] ⧸ Ideal.span {minpoly K f}
this✝ : Finite K R
this : IsReduced R
⊢ (aeval ((aeval f) p)) (minpoly K ((Ideal.Quotient.mkₐ K (Ideal.span {minpoly K f})) p)) = 0
state_after: no goals

tactic: rwa [Ideal.span, ← minpoly.ker_aeval_eq_span_minpoly] at h
state_before: R✝ : Type u_1
M : Type u_2
inst✝⁵ : CommRing R✝
inst✝⁴ : AddCommGroup M
inst✝³ : Module R✝ M
K : Type u_3
inst✝² : Field K
inst✝¹ : Module K M
f g : End K M
inst✝ : FiniteDimensional K M
hf : f.IsSemisimple
p : K[X]
R : Type u_3 := K[X] ⧸ Ideal.span {minpoly K f}
this✝ : Finite K R
this : IsReduced R
a : K[X]
h : a ∈ Ideal.span {minpoly K f}
⊢ (aeval f) a = 0
state_after: no goals