1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Real.tan_add
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Arctan.lean

tactic: simpa only [← Complex.ofReal_inj, Complex.ofReal_sub, Complex.ofReal_add, Complex.ofReal_div,
  Complex.ofReal_mul, Complex.ofReal_tan] using
  @Complex.tan_add (x : ℂ) (y : ℂ) (by convert h <;> norm_cast)
state_before: x y : ℝ
h :
  ((∀ (k : ℤ), x ≠ (2 * ↑k + 1) * π / 2) ∧ ∀ (l : ℤ), y ≠ (2 * ↑l + 1) * π / 2) ∨
    (∃ k, x = (2 * ↑k + 1) * π / 2) ∧ ∃ l, y = (2 * ↑l + 1) * π / 2
⊢ tan (x + y) = (tan x + tan y) / (1 - tan x * tan y)
state_after: no goals

tactic: convert h <;> norm_cast
state_before: x y : ℝ
h :
  ((∀ (k : ℤ), x ≠ (2 * ↑k + 1) * π / 2) ∧ ∀ (l : ℤ), y ≠ (2 * ↑l + 1) * π / 2) ∨
    (∃ k, x = (2 * ↑k + 1) * π / 2) ∧ ∃ l, y = (2 * ↑l + 1) * π / 2
⊢ ((∀ (k : ℤ), ↑x ≠ (2 * ↑k + 1) * ↑π / 2) ∧ ∀ (l : ℤ), ↑y ≠ (2 * ↑l + 1) * ↑π / 2) ∨
    (∃ k, ↑x = (2 * ↑k + 1) * ↑π / 2) ∧ ∃ l, ↑y = (2 * ↑l + 1) * ↑π / 2
state_after: no goals
Theorem: ProbabilityTheory.kernel.snd_prod
File: Mathlib/Probability/Kernel/Composition.lean

tactic: ext x
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
inst✝¹ : IsMarkovKernel κ
η : ↥(kernel α γ)
inst✝ : IsSFiniteKernel η
⊢ snd (κ ×ₖ η) = η
state_after: case h.h
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
inst✝¹ : IsMarkovKernel κ
η : ↥(kernel α γ)
inst✝ : IsSFiniteKernel η
x : α
s✝ : Set γ
a✝ : MeasurableSet s✝
⊢ ((snd (κ ×ₖ η)) x) s✝ = (η x) s✝

tactic: simp [snd_apply, prod_apply]
state_before: case h.h
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
inst✝¹ : IsMarkovKernel κ
η : ↥(kernel α γ)
inst✝ : IsSFiniteKernel η
x : α
s✝ : Set γ
a✝ : MeasurableSet s✝
⊢ ((snd (κ ×ₖ η)) x) s✝ = (η x) s✝
state_after: no goals
Theorem: Real.sqrtTwoAddSeries_monotone_left
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

tactic: rw [sqrtTwoAddSeries, sqrtTwoAddSeries]
state_before: x✝ x y : ℝ
h : x ≤ y
n : ℕ
⊢ x.sqrtTwoAddSeries (n + 1) ≤ y.sqrtTwoAddSeries (n + 1)
state_after: x✝ x y : ℝ
h : x ≤ y
n : ℕ
⊢ √(2 + x.sqrtTwoAddSeries n) ≤ √(2 + y.sqrtTwoAddSeries n)

tactic: exact sqrt_le_sqrt (add_le_add_left (sqrtTwoAddSeries_monotone_left h _) _)
state_before: x✝ x y : ℝ
h : x ≤ y
n : ℕ
⊢ √(2 + x.sqrtTwoAddSeries n) ≤ √(2 + y.sqrtTwoAddSeries n)
state_after: no goals
Theorem: MeasureTheory.QuotientMeasureEqMeasurePreimage.unique
File: Mathlib/MeasureTheory/Group/FundamentalDomain.lean

tactic: obtain ⟨𝓕, h𝓕⟩ := hasFun.ExistsIsFundamentalDomain
state_before: G : Type u_1
H : Type u_2
α : Type u_3
β : Type u_4
E : Type u_5
inst✝⁸ : Group G
inst✝⁷ : MulAction G α
inst✝⁶ : MeasurableSpace α
ν : Measure α
inst✝⁵ : Countable G
inst✝⁴ : MeasurableSpace G
inst✝³ : SMulInvariantMeasure G α ν
inst✝² : MeasurableSMul G α
hasFun : HasFundamentalDomain G α ν
μ μ' : Measure (Quotient α_mod_G)
inst✝¹ : QuotientMeasureEqMeasurePreimage ν μ
inst✝ : QuotientMeasureEqMeasurePreimage ν μ'
⊢ μ = μ'
state_after: case intro
G : Type u_1
H : Type u_2
α : Type u_3
β : Type u_4
E : Type u_5
inst✝⁸ : Group G
inst✝⁷ : MulAction G α
inst✝⁶ : MeasurableSpace α
ν : Measure α
inst✝⁵ : Countable G
inst✝⁴ : MeasurableSpace G
inst✝³ : SMulInvariantMeasure G α ν
inst✝² : MeasurableSMul G α
hasFun : HasFundamentalDomain G α ν
μ μ' : Measure (Quotient α_mod_G)
inst✝¹ : QuotientMeasureEqMeasurePreimage ν μ
inst✝ : QuotientMeasureEqMeasurePreimage ν μ'
𝓕 : Set α
h𝓕 : IsFundamentalDomain G 𝓕 ν
⊢ μ = μ'

tactic: rw [h𝓕.projection_respects_measure (μ := μ), h𝓕.projection_respects_measure (μ := μ')]
state_before: case intro
G : Type u_1
H : Type u_2
α : Type u_3
β : Type u_4
E : Type u_5
inst✝⁸ : Group G
inst✝⁷ : MulAction G α
inst✝⁶ : MeasurableSpace α
ν : Measure α
inst✝⁵ : Countable G
inst✝⁴ : MeasurableSpace G
inst✝³ : SMulInvariantMeasure G α ν
inst✝² : MeasurableSMul G α
hasFun : HasFundamentalDomain G α ν
μ μ' : Measure (Quotient α_mod_G)
inst✝¹ : QuotientMeasureEqMeasurePreimage ν μ
inst✝ : QuotientMeasureEqMeasurePreimage ν μ'
𝓕 : Set α
h𝓕 : IsFundamentalDomain G 𝓕 ν
⊢ μ = μ'
state_after: no goals
Theorem: ArithmeticFunction.convolution_vonMangoldt_zeta
File: Mathlib/NumberTheory/LSeries/Dirichlet.lean

tactic: ext n
state_before: ⊢ ((fun n => ↑(Λ n)) ⍟ fun n => ↑(ζ n)) = fun n => Complex.log ↑n
state_after: case h
n : ℕ
⊢ ((fun n => ↑(Λ n)) ⍟ fun n => ↑(ζ n)) n = Complex.log ↑n
Theorem: groupCohomology.isTwoCoboundary_of_twoCoboundaries
File: Mathlib/RepresentationTheory/GroupCohomology/LowDegree.lean

tactic: rcases mem_range_of_mem_twoCoboundaries f.2 with ⟨x, hx⟩
state_before: k✝ G✝ : Type u
inst✝⁷ : CommRing k✝
inst✝⁶ : Group G✝
A✝ : Rep k✝ G✝
k G A : Type u
inst✝⁵ : CommRing k
inst✝⁴ : Group G
inst✝³ : AddCommGroup A
inst✝² : Module k A
inst✝¹ : DistribMulAction G A
inst✝ : SMulCommClass G k A
f : ↥(twoCoboundaries (Rep.ofDistribMulAction k G A))
⊢ IsTwoCoboundary ↑↑f
state_after: case intro
k✝ G✝ : Type u
inst✝⁷ : CommRing k✝
inst✝⁶ : Group G✝
A✝ : Rep k✝ G✝
k G A : Type u
inst✝⁵ : CommRing k
inst✝⁴ : Group G
inst✝³ : AddCommGroup A
inst✝² : Module k A
inst✝¹ : DistribMulAction G A
inst✝ : SMulCommClass G k A
f : ↥(twoCoboundaries (Rep.ofDistribMulAction k G A))
x : G → CoeSort.coe (Rep.ofDistribMulAction k G A)
hx : (dOne (Rep.ofDistribMulAction k G A)) x = (twoCocycles (Rep.ofDistribMulAction k G A)).subtype ↑f
⊢ IsTwoCoboundary ↑↑f

tactic: exact ⟨x, fun g h => Function.funext_iff.1 hx (g, h)⟩
state_before: case intro
k✝ G✝ : Type u
inst✝⁷ : CommRing k✝
inst✝⁶ : Group G✝
A✝ : Rep k✝ G✝
k G A : Type u
inst✝⁵ : CommRing k
inst✝⁴ : Group G
inst✝³ : AddCommGroup A
inst✝² : Module k A
inst✝¹ : DistribMulAction G A
inst✝ : SMulCommClass G k A
f : ↥(twoCoboundaries (Rep.ofDistribMulAction k G A))
x : G → CoeSort.coe (Rep.ofDistribMulAction k G A)
hx : (dOne (Rep.ofDistribMulAction k G A)) x = (twoCocycles (Rep.ofDistribMulAction k G A)).subtype ↑f
⊢ IsTwoCoboundary ↑↑f
state_after: no goals
Theorem: Rat.inv_neg
File: Mathlib/Data/Rat/Lemmas.lean

tactic: rw [← num_divInt_den q]
state_before: q : ℚ
⊢ (-q)⁻¹ = -q⁻¹
state_after: q : ℚ
⊢ (-(q.num /. ↑q.den))⁻¹ = -(q.num /. ↑q.den)⁻¹

tactic: simp only [Rat.neg_divInt, Rat.inv_divInt', eq_self_iff_true, Rat.divInt_neg]
state_before: q : ℚ
⊢ (-(q.num /. ↑q.den))⁻¹ = -(q.num /. ↑q.den)⁻¹
state_after: no goals
Theorem: sub_one_div_inv_le_two
File: Mathlib/Algebra/Order/Field/Basic.lean

tactic: refine (inv_le_inv_of_le (inv_pos.2 <| zero_lt_two' α) ?_).trans_eq (inv_inv (2 : α))
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedField α
a b c d : α
n : ℤ
a2 : 2 ≤ a
⊢ (1 - 1 / a)⁻¹ ≤ 2
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedField α
a b c d : α
n : ℤ
a2 : 2 ≤ a
⊢ 2⁻¹ ≤ 1 - 1 / a

tactic: rw [le_sub_iff_add_le, add_comm, ← le_sub_iff_add_le]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedField α
a b c d : α
n : ℤ
a2 : 2 ≤ a
⊢ 2⁻¹ ≤ 1 - 1 / a
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedField α
a b c d : α
n : ℤ
a2 : 2 ≤ a
⊢ 1 / a ≤ 1 - 2⁻¹

tactic: convert (one_div a).le.trans (inv_le_inv_of_le zero_lt_two a2) using 1
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedField α
a b c d : α
n : ℤ
a2 : 2 ≤ a
⊢ 1 / a ≤ 1 - 2⁻¹
state_after: case h.e'_4
ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedField α
a b c d : α
n : ℤ
a2 : 2 ≤ a
⊢ 1 - 2⁻¹ = 2⁻¹

tactic: rw [sub_eq_iff_eq_add, ← two_mul, mul_inv_cancel two_ne_zero]
state_before: case h.e'_4
ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedField α
a b c d : α
n : ℤ
a2 : 2 ≤ a
⊢ 1 - 2⁻¹ = 2⁻¹
state_after: no goals
Theorem: AdicCompletion.Ideal.mk_eq_mk
File: Mathlib/RingTheory/AdicCompletion/Algebra.lean

tactic: have h : I ^ m = I ^ m • ⊤ := by simp
state_before: R : Type u_1
inst✝² : CommRing R
I : Ideal R
M : Type u_2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
m n : ℕ
hmn : m ≤ n
r : AdicCauchySequence I R
⊢ (Ideal.Quotient.mk (I ^ m)) (↑r n) = (Ideal.Quotient.mk (I ^ m)) (↑r m)
state_after: R : Type u_1
inst✝² : CommRing R
I : Ideal R
M : Type u_2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
m n : ℕ
hmn : m ≤ n
r : AdicCauchySequence I R
h : I ^ m = I ^ m • ⊤
⊢ (Ideal.Quotient.mk (I ^ m)) (↑r n) = (Ideal.Quotient.mk (I ^ m)) (↑r m)

tactic: rw [h, ← Ideal.Quotient.mk_eq_mk, ← Ideal.Quotient.mk_eq_mk]
state_before: R : Type u_1
inst✝² : CommRing R
I : Ideal R
M : Type u_2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
m n : ℕ
hmn : m ≤ n
r : AdicCauchySequence I R
h : I ^ m = I ^ m • ⊤
⊢ (Ideal.Quotient.mk (I ^ m)) (↑r n) = (Ideal.Quotient.mk (I ^ m)) (↑r m)
state_after: R : Type u_1
inst✝² : CommRing R
I : Ideal R
M : Type u_2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
m n : ℕ
hmn : m ≤ n
r : AdicCauchySequence I R
h : I ^ m = I ^ m • ⊤
⊢ Submodule.Quotient.mk (↑r n) = Submodule.Quotient.mk (↑r m)

tactic: exact (r.property hmn).symm
state_before: R : Type u_1
inst✝² : CommRing R
I : Ideal R
M : Type u_2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
m n : ℕ
hmn : m ≤ n
r : AdicCauchySequence I R
h : I ^ m = I ^ m • ⊤
⊢ Submodule.Quotient.mk (↑r n) = Submodule.Quotient.mk (↑r m)
state_after: no goals

tactic: simp
state_before: R : Type u_1
inst✝² : CommRing R
I : Ideal R
M : Type u_2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
m n : ℕ
hmn : m ≤ n
r : AdicCauchySequence I R
⊢ I ^ m = I ^ m • ⊤
state_after: no goals
Theorem: Ring.inverse_mul_cancel
File: Mathlib/Algebra/GroupWithZero/Units/Basic.lean

tactic: rcases h with ⟨u, rfl⟩
state_before: α : Type u_1
M₀ : Type u_2
G₀ : Type u_3
M₀' : Type u_4
G₀' : Type u_5
F : Type u_6
F' : Type u_7
inst✝ : MonoidWithZero M₀
x : M₀
h : IsUnit x
⊢ inverse x * x = 1
state_after: case intro
α : Type u_1
M₀ : Type u_2
G₀ : Type u_3
M₀' : Type u_4
G₀' : Type u_5
F : Type u_6
F' : Type u_7
inst✝ : MonoidWithZero M₀
u : M₀ˣ
⊢ inverse ↑u * ↑u = 1

tactic: rw [inverse_unit, Units.inv_mul]
state_before: case intro
α : Type u_1
M₀ : Type u_2
G₀ : Type u_3
M₀' : Type u_4
G₀' : Type u_5
F : Type u_6
F' : Type u_7
inst✝ : MonoidWithZero M₀
u : M₀ˣ
⊢ inverse ↑u * ↑u = 1
state_after: no goals
Theorem: Finset.min_singleton
File: Mathlib/Data/Finset/Lattice.lean

tactic: rw [← insert_emptyc_eq]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : LinearOrder α
a : α
⊢ {a}.min = ↑a
state_after: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : LinearOrder α
a : α
⊢ (insert a ∅).min = ↑a

tactic: exact min_insert
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : LinearOrder α
a : α
⊢ (insert a ∅).min = ↑a
state_after: no goals
Theorem: intervalIntegral.tendsto_integral_filter_of_dominated_convergence
File: Mathlib/MeasureTheory/Integral/DominatedConvergence.lean

tactic: simp only [intervalIntegrable_iff, intervalIntegral_eq_integral_uIoc,
  ← ae_restrict_iff' (α := ℝ) (μ := μ) measurableSet_uIoc] at *
state_before: ι✝ : Type u_1
𝕜 : Type u_2
E : Type u_3
F✝ : Type u_4
inst✝³ : NormedAddCommGroup E
inst✝² : CompleteSpace E
inst✝¹ : NormedSpace ℝ E
a b : ℝ
f : ℝ → E
μ : Measure ℝ
ι : Type u_5
l : Filter ι
inst✝ : l.IsCountablyGenerated
F : ι → ℝ → E
bound : ℝ → ℝ
hF_meas : ∀ᶠ (n : ι) in l, AEStronglyMeasurable (F n) (μ.restrict (Ι a b))
h_bound : ∀ᶠ (n : ι) in l, ∀ᵐ (x : ℝ) ∂μ, x ∈ Ι a b → ‖F n x‖ ≤ bound x
bound_integrable : IntervalIntegrable bound μ a b
h_lim : ∀ᵐ (x : ℝ) ∂μ, x ∈ Ι a b → Tendsto (fun n => F n x) l (𝓝 (f x))
⊢ Tendsto (fun n => ∫ (x : ℝ) in a..b, F n x ∂μ) l (𝓝 (∫ (x : ℝ) in a..b, f x ∂μ))
state_after: ι✝ : Type u_1
𝕜 : Type u_2
E : Type u_3
F✝ : Type u_4
inst✝³ : NormedAddCommGroup E
inst✝² : CompleteSpace E
inst✝¹ : NormedSpace ℝ E
a b : ℝ
f : ℝ → E
μ : Measure ℝ
ι : Type u_5
l : Filter ι
inst✝ : l.IsCountablyGenerated
F : ι → ℝ → E
bound : ℝ → ℝ
hF_meas : ∀ᶠ (n : ι) in l, AEStronglyMeasurable (F n) (μ.restrict (Ι a b))
h_bound : ∀ᶠ (n : ι) in l, ∀ᵐ (x : ℝ) ∂μ.restrict (Ι a b), ‖F n x‖ ≤ bound x
bound_integrable : IntegrableOn bound (Ι a b) μ
h_lim : ∀ᵐ (x : ℝ) ∂μ.restrict (Ι a b), Tendsto (fun n => F n x) l (𝓝 (f x))
⊢ Tendsto (fun n => (if a ≤ b then 1 else -1) • ∫ (x : ℝ) in Ι a b, F n x ∂μ) l
    (𝓝 ((if a ≤ b then 1 else -1) • ∫ (x : ℝ) in Ι a b, f x ∂μ))

tactic: exact tendsto_const_nhds.smul <|
  tendsto_integral_filter_of_dominated_convergence bound hF_meas h_bound bound_integrable h_lim
state_before: ι✝ : Type u_1
𝕜 : Type u_2
E : Type u_3
F✝ : Type u_4
inst✝³ : NormedAddCommGroup E
inst✝² : CompleteSpace E
inst✝¹ : NormedSpace ℝ E
a b : ℝ
f : ℝ → E
μ : Measure ℝ
ι : Type u_5
l : Filter ι
inst✝ : l.IsCountablyGenerated
F : ι → ℝ → E
bound : ℝ → ℝ
hF_meas : ∀ᶠ (n : ι) in l, AEStronglyMeasurable (F n) (μ.restrict (Ι a b))
h_bound : ∀ᶠ (n : ι) in l, ∀ᵐ (x : ℝ) ∂μ.restrict (Ι a b), ‖F n x‖ ≤ bound x
bound_integrable : IntegrableOn bound (Ι a b) μ
h_lim : ∀ᵐ (x : ℝ) ∂μ.restrict (Ι a b), Tendsto (fun n => F n x) l (𝓝 (f x))
⊢ Tendsto (fun n => (if a ≤ b then 1 else -1) • ∫ (x : ℝ) in Ι a b, F n x ∂μ) l
    (𝓝 ((if a ≤ b then 1 else -1) • ∫ (x : ℝ) in Ι a b, f x ∂μ))
state_after: no goals
Theorem: Finsupp.total_apply_of_mem_supported
File: Mathlib/LinearAlgebra/Finsupp.lean

tactic: rw [not_mem_support_iff.1 hxg, zero_smul]
state_before: α : Type u_1
M : Type u_2
N : Type u_3
P : Type u_4
R : Type u_5
S : Type u_6
inst✝⁹ : Semiring R
inst✝⁸ : Semiring S
inst✝⁷ : AddCommMonoid M
inst✝⁶ : Module R M
inst✝⁵ : AddCommMonoid N
inst✝⁴ : Module R N
inst✝³ : AddCommMonoid P
inst✝² : Module R P
α' : Type u_7
M' : Type u_8
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
v : α → M
v' : α' → M'
l : α →₀ R
s : Finset α
hs : l ∈ supported R R ↑s
x : α
x✝ : x ∈ s
hxg : x ∉ l.support
⊢ l x • v x = 0
state_after: no goals
Theorem: LieAlgebra.IsKilling.chainLength_zero_right
File: Mathlib/Algebra/Lie/Weights/RootSystem.lean

tactic: rw [← chainBotCoeff_add_chainTopCoeff, chainTopCoeff_zero_right α hα,
  chainBotCoeff_zero_right α hα]
state_before: K : Type u_1
L : Type u_2
inst✝⁸ : Field K
inst✝⁷ : CharZero K
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra K L
inst✝⁴ : IsKilling K L
inst✝³ : FiniteDimensional K L
H : LieSubalgebra K L
inst✝² : H.IsCartanSubalgebra
inst✝¹ : IsTriangularizable K (↥H) L
α β : Weight K (↥H) L
hα : α.IsNonZero
inst✝ : Nontrivial L
⊢ chainLength α 0 = 2
state_after: no goals
Theorem: CategoryTheory.Functor.pentagon
File: Mathlib/CategoryTheory/Whiskering.lean

tactic: aesop_cat
state_before: A : Type u₁
inst✝⁴ : Category.{v₁, u₁} A
B : Type u₂
inst✝³ : Category.{v₂, u₂} B
C : Type u₃
inst✝² : Category.{v₃, u₃} C
D : Type u₄
inst✝¹ : Category.{v₄, u₄} D
E : Type u₅
inst✝ : Category.{v₅, u₅} E
F : A ⥤ B
G : B ⥤ C
H : C ⥤ D
K : D ⥤ E
⊢ whiskerRight (F.associator G H).hom K ≫ (F.associator (G ⋙ H) K).hom ≫ whiskerLeft F (G.associator H K).hom =
    ((F ⋙ G).associator H K).hom ≫ (F.associator G (H ⋙ K)).hom
state_after: no goals
Theorem: SpectrumRestricts.real_iff
File: Mathlib/Analysis/NormedSpace/Spectrum.lean

tactic: refine ⟨fun h x hx ↦ ?_, fun h ↦ ?_⟩
state_before: 𝕜 : Type u_1
A✝ : Type u_2
A : Type u_3
inst✝¹ : Ring A
inst✝ : Algebra ℂ A
a : A
⊢ SpectrumRestricts a ⇑Complex.reCLM ↔ ∀ x ∈ spectrum ℂ a, x = ↑x.re
state_after: case refine_1
𝕜 : Type u_1
A✝ : Type u_2
A : Type u_3
inst✝¹ : Ring A
inst✝ : Algebra ℂ A
a : A
h : SpectrumRestricts a ⇑Complex.reCLM
x : ℂ
hx : x ∈ spectrum ℂ a
⊢ x = ↑x.re

case refine_2
𝕜 : Type u_1
A✝ : Type u_2
A : Type u_3
inst✝¹ : Ring A
inst✝ : Algebra ℂ A
a : A
h : ∀ x ∈ spectrum ℂ a, x = ↑x.re
⊢ SpectrumRestricts a ⇑Complex.reCLM

tactic: obtain ⟨x, -, rfl⟩ := h.algebraMap_image.symm ▸ hx
state_before: case refine_1
𝕜 : Type u_1
A✝ : Type u_2
A : Type u_3
inst✝¹ : Ring A
inst✝ : Algebra ℂ A
a : A
h : SpectrumRestricts a ⇑Complex.reCLM
x : ℂ
hx : x ∈ spectrum ℂ a
⊢ x = ↑x.re
state_after: case refine_1.intro.intro
𝕜 : Type u_1
A✝ : Type u_2
A : Type u_3
inst✝¹ : Ring A
inst✝ : Algebra ℂ A
a : A
h : SpectrumRestricts a ⇑Complex.reCLM
x : ℝ
hx : (algebraMap ℝ ℂ) x ∈ spectrum ℂ a
⊢ (algebraMap ℝ ℂ) x = ↑((algebraMap ℝ ℂ) x).re

tactic: simp
state_before: case refine_1.intro.intro
𝕜 : Type u_1
A✝ : Type u_2
A : Type u_3
inst✝¹ : Ring A
inst✝ : Algebra ℂ A
a : A
h : SpectrumRestricts a ⇑Complex.reCLM
x : ℝ
hx : (algebraMap ℝ ℂ) x ∈ spectrum ℂ a
⊢ (algebraMap ℝ ℂ) x = ↑((algebraMap ℝ ℂ) x).re
state_after: no goals

tactic: exact .of_subset_range_algebraMap Complex.ofReal_re fun x hx ↦ ⟨x.re, (h x hx).symm⟩
state_before: case refine_2
𝕜 : Type u_1
A✝ : Type u_2
A : Type u_3
inst✝¹ : Ring A
inst✝ : Algebra ℂ A
a : A
h : ∀ x ∈ spectrum ℂ a, x = ↑x.re
⊢ SpectrumRestricts a ⇑Complex.reCLM
state_after: no goals
Theorem: dslope_sub_smul_of_ne
File: Mathlib/Analysis/Calculus/Dslope.lean

tactic: rw [dslope_of_ne _ h, slope_sub_smul _ h.symm]
state_before: 𝕜 : Type u_1
E : Type u_2
inst✝² : NontriviallyNormedField 𝕜
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f✝ : 𝕜 → E
a b : 𝕜
s : Set 𝕜
f : 𝕜 → E
h : b ≠ a
⊢ dslope (fun x => (x - a) • f x) a b = f b
state_after: no goals
Theorem: Multiset.toFinset_prod_dvd_prod
File: Mathlib/Algebra/BigOperators/Group/Finset.lean

tactic: rw [Finset.prod_eq_multiset_prod]
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s s₁ s₂ : Finset α
a : α
f g : α → β
inst✝¹ : DecidableEq α
inst✝ : CommMonoid α
S : Multiset α
⊢ S.toFinset.prod id ∣ S.prod
state_after: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s s₁ s₂ : Finset α
a : α
f g : α → β
inst✝¹ : DecidableEq α
inst✝ : CommMonoid α
S : Multiset α
⊢ (map id S.toFinset.val).prod ∣ S.prod

tactic: refine Multiset.prod_dvd_prod_of_le ?_
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s s₁ s₂ : Finset α
a : α
f g : α → β
inst✝¹ : DecidableEq α
inst✝ : CommMonoid α
S : Multiset α
⊢ (map id S.toFinset.val).prod ∣ S.prod
state_after: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s s₁ s₂ : Finset α
a : α
f g : α → β
inst✝¹ : DecidableEq α
inst✝ : CommMonoid α
S : Multiset α
⊢ map id S.toFinset.val ≤ S

tactic: simp [Multiset.dedup_le S]
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s s₁ s₂ : Finset α
a : α
f g : α → β
inst✝¹ : DecidableEq α
inst✝ : CommMonoid α
S : Multiset α
⊢ map id S.toFinset.val ≤ S
state_after: no goals
Theorem: Real.tan_int_mul_pi_div_two
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Arctan.lean

tactic: use n
state_before: n : ℤ
⊢ ∃ k, ↑k * π / 2 = ↑n * π / 2
state_after: no goals
Theorem: StrictMono.add_le_nat
File: Mathlib/Order/Monotone/Basic.lean

tactic: rw [Nat.add_comm m, Nat.add_comm m]
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
δ : Type u_2
π : ι → Type u_3
r : α → α → Prop
inst✝¹ : Preorder α
inst✝ : Preorder β
f✝ g : α → β
a : α
f : ℕ → ℕ
hf : StrictMono f
m n : ℕ
⊢ m + f n ≤ f (m + n)
state_after: ι : Type u_1
α : Type u
β : Type v
γ : Type w
δ : Type u_2
π : ι → Type u_3
r : α → α → Prop
inst✝¹ : Preorder α
inst✝ : Preorder β
f✝ g : α → β
a : α
f : ℕ → ℕ
hf : StrictMono f
m n : ℕ
⊢ f n + m ≤ f (n + m)

tactic: induction' m with m ih
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
δ : Type u_2
π : ι → Type u_3
r : α → α → Prop
inst✝¹ : Preorder α
inst✝ : Preorder β
f✝ g : α → β
a : α
f : ℕ → ℕ
hf : StrictMono f
m n : ℕ
⊢ f n + m ≤ f (n + m)
state_after: case zero
ι : Type u_1
α : Type u
β : Type v
γ : Type w
δ : Type u_2
π : ι → Type u_3
r : α → α → Prop
inst✝¹ : Preorder α
inst✝ : Preorder β
f✝ g : α → β
a : α
f : ℕ → ℕ
hf : StrictMono f
n : ℕ
⊢ f n + 0 ≤ f (n + 0)

case succ
ι : Type u_1
α : Type u
β : Type v
γ : Type w
δ : Type u_2
π : ι → Type u_3
r : α → α → Prop
inst✝¹ : Preorder α
inst✝ : Preorder β
f✝ g : α → β
a : α
f : ℕ → ℕ
hf : StrictMono f
n m : ℕ
ih : f n + m ≤ f (n + m)
⊢ f n + (m + 1) ≤ f (n + (m + 1))

tactic: rw [Nat.add_zero, Nat.add_zero]
state_before: case zero
ι : Type u_1
α : Type u
β : Type v
γ : Type w
δ : Type u_2
π : ι → Type u_3
r : α → α → Prop
inst✝¹ : Preorder α
inst✝ : Preorder β
f✝ g : α → β
a : α
f : ℕ → ℕ
hf : StrictMono f
n : ℕ
⊢ f n + 0 ≤ f (n + 0)
state_after: no goals

tactic: rw [← Nat.add_assoc, ← Nat.add_assoc, Nat.succ_le]
state_before: case succ
ι : Type u_1
α : Type u
β : Type v
γ : Type w
δ : Type u_2
π : ι → Type u_3
r : α → α → Prop
inst✝¹ : Preorder α
inst✝ : Preorder β
f✝ g : α → β
a : α
f : ℕ → ℕ
hf : StrictMono f
n m : ℕ
ih : f n + m ≤ f (n + m)
⊢ f n + (m + 1) ≤ f (n + (m + 1))
state_after: case succ
ι : Type u_1
α : Type u
β : Type v
γ : Type w
δ : Type u_2
π : ι → Type u_3
r : α → α → Prop
inst✝¹ : Preorder α
inst✝ : Preorder β
f✝ g : α → β
a : α
f : ℕ → ℕ
hf : StrictMono f
n m : ℕ
ih : f n + m ≤ f (n + m)
⊢ f n + m < f (n + m + 1)

tactic: exact ih.trans_lt (hf (n + m).lt_succ_self)
state_before: case succ
ι : Type u_1
α : Type u
β : Type v
γ : Type w
δ : Type u_2
π : ι → Type u_3
r : α → α → Prop
inst✝¹ : Preorder α
inst✝ : Preorder β
f✝ g : α → β
a : α
f : ℕ → ℕ
hf : StrictMono f
n m : ℕ
ih : f n + m ≤ f (n + m)
⊢ f n + m < f (n + m + 1)
state_after: no goals
Theorem: PadicInt.norm_eq_of_norm_add_lt_left
File: Mathlib/NumberTheory/Padics/PadicIntegers.lean

tactic: rw [norm_add_eq_max_of_ne hne]
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
z1 z2 : ℤ_[p]
h : ‖z1 + z2‖ < ‖z1‖
hne : ¬‖z1‖ = ‖z2‖
⊢ ‖z1 + z2‖ ≥ ‖z1‖
state_after: p : ℕ
inst✝ : Fact (Nat.Prime p)
z1 z2 : ℤ_[p]
h : ‖z1 + z2‖ < ‖z1‖
hne : ¬‖z1‖ = ‖z2‖
⊢ max ‖z1‖ ‖z2‖ ≥ ‖z1‖

tactic: apply le_max_left
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
z1 z2 : ℤ_[p]
h : ‖z1 + z2‖ < ‖z1‖
hne : ¬‖z1‖ = ‖z2‖
⊢ max ‖z1‖ ‖z2‖ ≥ ‖z1‖
state_after: no goals
Theorem: Ordering.then_eq_eq
File: .lake/packages/batteries/Batteries/Classes/Order.lean

tactic: cases o₁ <;> simp [«then»]
state_before: o₁ o₂ : Ordering
⊢ o₁.then o₂ = eq ↔ o₁ = eq ∧ o₂ = eq
state_after: no goals
Theorem: Filter.eventually_or_distrib_left
File: Mathlib/Order/Filter/Basic.lean

tactic: simp [h]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f : Filter α
p : Prop
q : α → Prop
h : p
⊢ (∀ᶠ (x : α) in f, p ∨ q x) ↔ p ∨ ∀ᶠ (x : α) in f, q x
state_after: no goals

tactic: simp [h]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f : Filter α
p : Prop
q : α → Prop
h : ¬p
⊢ (∀ᶠ (x : α) in f, p ∨ q x) ↔ p ∨ ∀ᶠ (x : α) in f, q x
state_after: no goals
Theorem: CategoryTheory.pre_id
File: Mathlib/CategoryTheory/Closed/Cartesian.lean

tactic: simp [pre]
state_before: C : Type u
inst✝³ : Category.{v, u} C
A✝ B X X' Y Y' Z : C
inst✝² : HasFiniteProducts C
inst✝¹ : Exponentiable A✝
A : C
inst✝ : Exponentiable A
⊢ pre (𝟙 A) = 𝟙 (exp A)
state_after: no goals