1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: MeasureTheory.lintegral_iInf_ae
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

tactic: induction' n with n ih
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
f : ℕ → α → ℝ≥0∞
h_meas : ∀ (n : ℕ), Measurable (f n)
h_mono✝ : ∀ (n : ℕ), f n.succ ≤ᶠ[ae μ] f n
h_fin : ∫⁻ (a : α), f 0 a ∂μ ≠ ⊤
fn_le_f0 : ∫⁻ (a : α), ⨅ n, f n a ∂μ ≤ ∫⁻ (a : α), f 0 a ∂μ
fn_le_f0' : ⨅ n, ∫⁻ (a : α), f n a ∂μ ≤ ∫⁻ (a : α), f 0 a ∂μ
h_mono : ∀ᵐ (a : α) ∂μ, ∀ (n : ℕ), f n.succ a ≤ f n a
n : ℕ
a : α
h : ∀ (n : ℕ), f n.succ a ≤ f n a
⊢ f n a ≤ f 0 a
state_after: case zero
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
f : ℕ → α → ℝ≥0∞
h_meas : ∀ (n : ℕ), Measurable (f n)
h_mono✝ : ∀ (n : ℕ), f n.succ ≤ᶠ[ae μ] f n
h_fin : ∫⁻ (a : α), f 0 a ∂μ ≠ ⊤
fn_le_f0 : ∫⁻ (a : α), ⨅ n, f n a ∂μ ≤ ∫⁻ (a : α), f 0 a ∂μ
fn_le_f0' : ⨅ n, ∫⁻ (a : α), f n a ∂μ ≤ ∫⁻ (a : α), f 0 a ∂μ
h_mono : ∀ᵐ (a : α) ∂μ, ∀ (n : ℕ), f n.succ a ≤ f n a
a : α
h : ∀ (n : ℕ), f n.succ a ≤ f n a
⊢ f 0 a ≤ f 0 a

case succ
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
f : ℕ → α → ℝ≥0∞
h_meas : ∀ (n : ℕ), Measurable (f n)
h_mono✝ : ∀ (n : ℕ), f n.succ ≤ᶠ[ae μ] f n
h_fin : ∫⁻ (a : α), f 0 a ∂μ ≠ ⊤
fn_le_f0 : ∫⁻ (a : α), ⨅ n, f n a ∂μ ≤ ∫⁻ (a : α), f 0 a ∂μ
fn_le_f0' : ⨅ n, ∫⁻ (a : α), f n a ∂μ ≤ ∫⁻ (a : α), f 0 a ∂μ
h_mono : ∀ᵐ (a : α) ∂μ, ∀ (n : ℕ), f n.succ a ≤ f n a
a : α
h : ∀ (n : ℕ), f n.succ a ≤ f n a
n : ℕ
ih : f n a ≤ f 0 a
⊢ f (n + 1) a ≤ f 0 a

tactic: exact le_rfl
state_before: case zero
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
f : ℕ → α → ℝ≥0∞
h_meas : ∀ (n : ℕ), Measurable (f n)
h_mono✝ : ∀ (n : ℕ), f n.succ ≤ᶠ[ae μ] f n
h_fin : ∫⁻ (a : α), f 0 a ∂μ ≠ ⊤
fn_le_f0 : ∫⁻ (a : α), ⨅ n, f n a ∂μ ≤ ∫⁻ (a : α), f 0 a ∂μ
fn_le_f0' : ⨅ n, ∫⁻ (a : α), f n a ∂μ ≤ ∫⁻ (a : α), f 0 a ∂μ
h_mono : ∀ᵐ (a : α) ∂μ, ∀ (n : ℕ), f n.succ a ≤ f n a
a : α
h : ∀ (n : ℕ), f n.succ a ≤ f n a
⊢ f 0 a ≤ f 0 a
state_after: no goals

tactic: exact le_trans (h n) ih
state_before: case succ
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
f : ℕ → α → ℝ≥0∞
h_meas : ∀ (n : ℕ), Measurable (f n)
h_mono✝ : ∀ (n : ℕ), f n.succ ≤ᶠ[ae μ] f n
h_fin : ∫⁻ (a : α), f 0 a ∂μ ≠ ⊤
fn_le_f0 : ∫⁻ (a : α), ⨅ n, f n a ∂μ ≤ ∫⁻ (a : α), f 0 a ∂μ
fn_le_f0' : ⨅ n, ∫⁻ (a : α), f n a ∂μ ≤ ∫⁻ (a : α), f 0 a ∂μ
h_mono : ∀ᵐ (a : α) ∂μ, ∀ (n : ℕ), f n.succ a ≤ f n a
a : α
h : ∀ (n : ℕ), f n.succ a ≤ f n a
n : ℕ
ih : f n a ≤ f 0 a
⊢ f (n + 1) a ≤ f 0 a
state_after: no goals
Theorem: Polynomial.derivative_X_add_C_pow
File: Mathlib/Algebra/Polynomial/Derivative.lean

tactic: rw [derivative_pow, derivative_X_add_C, mul_one]
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
A : Type z
a b : R
n : ℕ
inst✝ : CommSemiring R
c : R
m : ℕ
⊢ derivative ((X + C c) ^ m) = C ↑m * (X + C c) ^ (m - 1)
state_after: no goals
Theorem: iteratedFDeriv_apply_eq_iteratedDeriv_mul_prod
File: Mathlib/Analysis/Calculus/IteratedDeriv/Defs.lean

tactic: rw [iteratedDeriv_eq_iteratedFDeriv, ← ContinuousMultilinearMap.map_smul_univ]
state_before: 𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type u_2
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type u_3
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
n : ℕ
f : 𝕜 → F
s : Set 𝕜
x : 𝕜
m : Fin n → 𝕜
⊢ (iteratedFDeriv 𝕜 n f x) m = (∏ i : Fin n, m i) • iteratedDeriv n f x
state_after: 𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type u_2
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type u_3
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
n : ℕ
f : 𝕜 → F
s : Set 𝕜
x : 𝕜
m : Fin n → 𝕜
⊢ (iteratedFDeriv 𝕜 n f x) m = (iteratedFDeriv 𝕜 n f x) fun i => m i • 1

tactic: simp
state_before: 𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type u_2
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type u_3
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
n : ℕ
f : 𝕜 → F
s : Set 𝕜
x : 𝕜
m : Fin n → 𝕜
⊢ (iteratedFDeriv 𝕜 n f x) m = (iteratedFDeriv 𝕜 n f x) fun i => m i • 1
state_after: no goals
Theorem: Rat.intCast_div
File: Mathlib/Data/Rat/Lemmas.lean

tactic: rcases h with ⟨c, rfl⟩
state_before: a b : ℤ
h : b ∣ a
⊢ ↑(a / b) = ↑a / ↑b
state_after: case intro
b c : ℤ
⊢ ↑(b * c / b) = ↑(b * c) / ↑b

tactic: rw [mul_comm b, Int.mul_ediv_assoc c (dvd_refl b), Int.cast_mul,
  intCast_div_self, Int.cast_mul, mul_div_assoc]
state_before: case intro
b c : ℤ
⊢ ↑(b * c / b) = ↑(b * c) / ↑b
state_after: no goals
Theorem: intervalIntegral.integral_add_adjacent_intervals
File: Mathlib/MeasureTheory/Integral/IntervalIntegral.lean

tactic: rw [← add_neg_eq_zero, ← integral_symm, integral_add_adjacent_intervals_cancel hab hbc]
state_before: ι : Type u_1
𝕜 : Type u_2
E : Type u_3
F : Type u_4
A : Type u_5
inst✝² : NormedAddCommGroup E
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
a b c d : ℝ
f g : ℝ → E
μ : Measure ℝ
hab : IntervalIntegrable f μ a b
hbc : IntervalIntegrable f μ b c
⊢ ∫ (x : ℝ) in a..b, f x ∂μ + ∫ (x : ℝ) in b..c, f x ∂μ = ∫ (x : ℝ) in a..c, f x ∂μ
state_after: no goals
Theorem: Real.rpow_lt_one_iff_of_pos
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

tactic: rw [rpow_def_of_pos hx, exp_lt_one_iff, mul_neg_iff, log_pos_iff hx, log_neg_iff hx]
state_before: x y z : ℝ
n : ℕ
hx : 0 < x
⊢ x ^ y < 1 ↔ 1 < x ∧ y < 0 ∨ x < 1 ∧ 0 < y
state_after: no goals
Theorem: ONote.scale_eq_mul
File: Mathlib/SetTheory/Ordinal/Notation.lean

tactic: simp only [HMul.hMul]
state_before: x : ONote
inst✝ : x.NF
e : ONote
n : ℕ+
a : ONote
h : (e.oadd n a).NF
⊢ x.scale (e.oadd n a) = x.oadd 1 0 * e.oadd n a
state_after: x : ONote
inst✝ : x.NF
e : ONote
n : ℕ+
a : ONote
h : (e.oadd n a).NF
⊢ x.scale (e.oadd n a) = Mul.mul (x.oadd 1 0) (e.oadd n a)

tactic: simp only [scale]
state_before: x : ONote
inst✝ : x.NF
e : ONote
n : ℕ+
a : ONote
h : (e.oadd n a).NF
⊢ x.scale (e.oadd n a) = Mul.mul (x.oadd 1 0) (e.oadd n a)
state_after: x : ONote
inst✝ : x.NF
e : ONote
n : ℕ+
a : ONote
h : (e.oadd n a).NF
⊢ (x + e).oadd n (x.scale a) = Mul.mul (x.oadd 1 0) (e.oadd n a)

tactic: haveI := h.snd
state_before: x : ONote
inst✝ : x.NF
e : ONote
n : ℕ+
a : ONote
h : (e.oadd n a).NF
⊢ (x + e).oadd n (x.scale a) = Mul.mul (x.oadd 1 0) (e.oadd n a)
state_after: x : ONote
inst✝ : x.NF
e : ONote
n : ℕ+
a : ONote
h : (e.oadd n a).NF
this : a.NF
⊢ (x + e).oadd n (x.scale a) = Mul.mul (x.oadd 1 0) (e.oadd n a)

tactic: by_cases e0 : e = 0
state_before: x : ONote
inst✝ : x.NF
e : ONote
n : ℕ+
a : ONote
h : (e.oadd n a).NF
this : a.NF
⊢ (x + e).oadd n (x.scale a) = Mul.mul (x.oadd 1 0) (e.oadd n a)
state_after: case pos
x : ONote
inst✝ : x.NF
e : ONote
n : ℕ+
a : ONote
h : (e.oadd n a).NF
this : a.NF
e0 : e = 0
⊢ (x + e).oadd n (x.scale a) = Mul.mul (x.oadd 1 0) (e.oadd n a)

case neg
x : ONote
inst✝ : x.NF
e : ONote
n : ℕ+
a : ONote
h : (e.oadd n a).NF
this : a.NF
e0 : ¬e = 0
⊢ (x + e).oadd n (x.scale a) = Mul.mul (x.oadd 1 0) (e.oadd n a)

tactic: simp_rw [scale_eq_mul]
state_before: case pos
x : ONote
inst✝ : x.NF
e : ONote
n : ℕ+
a : ONote
h : (e.oadd n a).NF
this : a.NF
e0 : e = 0
⊢ (x + e).oadd n (x.scale a) = Mul.mul (x.oadd 1 0) (e.oadd n a)
state_after: case pos
x : ONote
inst✝ : x.NF
e : ONote
n : ℕ+
a : ONote
h : (e.oadd n a).NF
this : a.NF
e0 : e = 0
⊢ (x + e).oadd n (x.oadd 1 0 * a) = Mul.mul (x.oadd 1 0) (e.oadd n a)

tactic: simp [Mul.mul, mul, scale_eq_mul, e0, h.zero_of_zero,
  show x + 0 = x from repr_inj.1 (by simp)]
state_before: case pos
x : ONote
inst✝ : x.NF
e : ONote
n : ℕ+
a : ONote
h : (e.oadd n a).NF
this : a.NF
e0 : e = 0
⊢ (x + e).oadd n (x.oadd 1 0 * a) = Mul.mul (x.oadd 1 0) (e.oadd n a)
state_after: no goals

tactic: simp
state_before: x : ONote
inst✝ : x.NF
e : ONote
n : ℕ+
a : ONote
h : (e.oadd n a).NF
this : a.NF
e0 : e = 0
⊢ (x + 0).repr = x.repr
state_after: no goals
Theorem: Nat.ModEq.of_div
File: Mathlib/Data/Nat/ModEq.lean

tactic: convert h.mul_left' c <;> rwa [Nat.mul_div_cancel']
state_before: m n a b c d : ℕ
h : a / c ≡ b / c [MOD m / c]
ha✝¹ : c ∣ a
ha✝ : c ∣ b
ha : c ∣ m
⊢ a ≡ b [MOD m]
state_after: no goals
Theorem: DFinsupp.erase_ne
File: Mathlib/Data/DFinsupp/Basic.lean

tactic: simp [h]
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝¹ : DecidableEq ι
inst✝ : (i : ι) → Zero (β i)
s : Finset ι
x : (i : ↑↑s) → β ↑i
i✝ i i' : ι
f : Π₀ (i : ι), β i
h : i' ≠ i
⊢ (erase i f) i' = f i'
state_after: no goals
Theorem: Polynomial.isNilpotent_X_mul_iff
File: Mathlib/RingTheory/Polynomial/Nilpotent.lean

tactic: refine ⟨fun h ↦ ?_, ?_⟩
state_before: R : Type u_1
r : R
inst✝ : Semiring R
P : R[X]
⊢ IsNilpotent (X * P) ↔ IsNilpotent P
state_after: case refine_1
R : Type u_1
r : R
inst✝ : Semiring R
P : R[X]
h : IsNilpotent (X * P)
⊢ IsNilpotent P

case refine_2
R : Type u_1
r : R
inst✝ : Semiring R
P : R[X]
⊢ IsNilpotent P → IsNilpotent (X * P)

tactic: rwa [Commute.isNilpotent_mul_right_iff (commute_X P) (by simp)] at h
state_before: case refine_1
R : Type u_1
r : R
inst✝ : Semiring R
P : R[X]
h : IsNilpotent (X * P)
⊢ IsNilpotent P
state_after: no goals

tactic: simp
state_before: R : Type u_1
r : R
inst✝ : Semiring R
P : R[X]
h : IsNilpotent (X * P)
⊢ X ∈ nonZeroDivisorsRight R[X]
state_after: no goals

tactic: rintro ⟨k, hk⟩
state_before: case refine_2
R : Type u_1
r : R
inst✝ : Semiring R
P : R[X]
⊢ IsNilpotent P → IsNilpotent (X * P)
state_after: case refine_2.intro
R : Type u_1
r : R
inst✝ : Semiring R
P : R[X]
k : ℕ
hk : P ^ k = 0
⊢ IsNilpotent (X * P)

tactic: exact ⟨k, by simp [(commute_X P).mul_pow, hk]⟩
state_before: case refine_2.intro
R : Type u_1
r : R
inst✝ : Semiring R
P : R[X]
k : ℕ
hk : P ^ k = 0
⊢ IsNilpotent (X * P)
state_after: no goals

tactic: simp [(commute_X P).mul_pow, hk]
state_before: R : Type u_1
r : R
inst✝ : Semiring R
P : R[X]
k : ℕ
hk : P ^ k = 0
⊢ (X * P) ^ k = 0
state_after: no goals
Theorem: iSup_eq_top
File: Mathlib/Order/CompleteLattice.lean

tactic: simp only [← sSup_range, sSup_eq_top, Set.exists_range_iff]
state_before: α : Type u_1
β : Type u_2
β₂ : Type u_3
γ : Type u_4
ι : Sort u_5
ι' : Sort u_6
κ : ι → Sort u_7
κ' : ι' → Sort u_8
inst✝ : CompleteLinearOrder α
f : ι → α
⊢ iSup f = ⊤ ↔ ∀ b < ⊤, ∃ i, b < f i
state_after: no goals
Theorem: integrableOn_Icc_iff_integrableOn_Ico
File: Mathlib/MeasureTheory/Integral/IntegrableOn.lean

tactic: rw [measure_singleton]
state_before: α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝⁴ : MeasurableSpace α
inst✝³ : NormedAddCommGroup E
inst✝² : PartialOrder α
inst✝¹ : MeasurableSingletonClass α
f : α → E
μ : Measure α
a b : α
inst✝ : NoAtoms μ
⊢ μ {b} ≠ ⊤
state_after: α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝⁴ : MeasurableSpace α
inst✝³ : NormedAddCommGroup E
inst✝² : PartialOrder α
inst✝¹ : MeasurableSingletonClass α
f : α → E
μ : Measure α
a b : α
inst✝ : NoAtoms μ
⊢ 0 ≠ ⊤

tactic: exact ENNReal.zero_ne_top
state_before: α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝⁴ : MeasurableSpace α
inst✝³ : NormedAddCommGroup E
inst✝² : PartialOrder α
inst✝¹ : MeasurableSingletonClass α
f : α → E
μ : Measure α
a b : α
inst✝ : NoAtoms μ
⊢ 0 ≠ ⊤
state_after: no goals
Theorem: Equiv.Perm.zpow_aux
File: Mathlib/GroupTheory/Perm/Basic.lean

tactic: rw [zpow_negSucc]
state_before: α : Type u
β : Type v
p : α → Prop
f : Perm α
hf : ∀ (x : α), p x ↔ p (f x)
n : ℕ
⊢ ∀ (x : α), p x ↔ p ((f ^ Int.negSucc n) x)
state_after: α : Type u
β : Type v
p : α → Prop
f : Perm α
hf : ∀ (x : α), p x ↔ p (f x)
n : ℕ
⊢ ∀ (x : α), p x ↔ p ((f ^ (n + 1))⁻¹ x)

tactic: exact inv_aux.1 (pow_aux hf)
state_before: α : Type u
β : Type v
p : α → Prop
f : Perm α
hf : ∀ (x : α), p x ↔ p (f x)
n : ℕ
⊢ ∀ (x : α), p x ↔ p ((f ^ (n + 1))⁻¹ x)
state_after: no goals
Theorem: max_zero_add_max_neg_zero_eq_abs_self
File: Mathlib/Algebra/Order/Group/Abs.lean

tactic: symm
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
a✝ b c d a : α
⊢ max a 0 + max (-a) 0 = |a|
state_after: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
a✝ b c d a : α
⊢ |a| = max a 0 + max (-a) 0

tactic: rcases le_total 0 a with (ha | ha) <;> simp [ha]
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
a✝ b c d a : α
⊢ |a| = max a 0 + max (-a) 0
state_after: no goals
Theorem: Turing.ListBlank.append_mk
File: Mathlib/Computability/TuringMachine.lean

tactic: induction l₁ <;>
  simp only [*, ListBlank.append, List.nil_append, List.cons_append, ListBlank.cons_mk]
state_before: Γ : Type u_1
inst✝ : Inhabited Γ
l₁ l₂ : List Γ
⊢ append l₁ (mk l₂) = mk (l₁ ++ l₂)
state_after: no goals
Theorem: Matrix.isNilpotent_trace_of_isNilpotent
File: Mathlib/LinearAlgebra/Matrix/Charpoly/Coeff.lean

tactic: cases isEmpty_or_nonempty n
state_before: R : Type u
inst✝⁴ : CommRing R
n G : Type v
inst✝³ : DecidableEq n
inst✝² : Fintype n
α β : Type v
inst✝¹ : DecidableEq α
M : Matrix n n R
p : ℕ
inst✝ : Fact (Nat.Prime p)
hM : IsNilpotent M
⊢ IsNilpotent M.trace
state_after: case inl
R : Type u
inst✝⁴ : CommRing R
n G : Type v
inst✝³ : DecidableEq n
inst✝² : Fintype n
α β : Type v
inst✝¹ : DecidableEq α
M : Matrix n n R
p : ℕ
inst✝ : Fact (Nat.Prime p)
hM : IsNilpotent M
h✝ : IsEmpty n
⊢ IsNilpotent M.trace

case inr
R : Type u
inst✝⁴ : CommRing R
n G : Type v
inst✝³ : DecidableEq n
inst✝² : Fintype n
α β : Type v
inst✝¹ : DecidableEq α
M : Matrix n n R
p : ℕ
inst✝ : Fact (Nat.Prime p)
hM : IsNilpotent M
h✝ : Nonempty n
⊢ IsNilpotent M.trace

tactic: suffices IsNilpotent (coeff (charpolyRev M) 1) by simpa using this
state_before: case inr
R : Type u
inst✝⁴ : CommRing R
n G : Type v
inst✝³ : DecidableEq n
inst✝² : Fintype n
α β : Type v
inst✝¹ : DecidableEq α
M : Matrix n n R
p : ℕ
inst✝ : Fact (Nat.Prime p)
hM : IsNilpotent M
h✝ : Nonempty n
⊢ IsNilpotent M.trace
state_after: case inr
R : Type u
inst✝⁴ : CommRing R
n G : Type v
inst✝³ : DecidableEq n
inst✝² : Fintype n
α β : Type v
inst✝¹ : DecidableEq α
M : Matrix n n R
p : ℕ
inst✝ : Fact (Nat.Prime p)
hM : IsNilpotent M
h✝ : Nonempty n
⊢ IsNilpotent (M.charpolyRev.coeff 1)

tactic: exact (isUnit_iff_coeff_isUnit_isNilpotent.mp (isUnit_charpolyRev_of_isNilpotent hM)).2
  _ one_ne_zero
state_before: case inr
R : Type u
inst✝⁴ : CommRing R
n G : Type v
inst✝³ : DecidableEq n
inst✝² : Fintype n
α β : Type v
inst✝¹ : DecidableEq α
M : Matrix n n R
p : ℕ
inst✝ : Fact (Nat.Prime p)
hM : IsNilpotent M
h✝ : Nonempty n
⊢ IsNilpotent (M.charpolyRev.coeff 1)
state_after: no goals

tactic: simp
state_before: case inl
R : Type u
inst✝⁴ : CommRing R
n G : Type v
inst✝³ : DecidableEq n
inst✝² : Fintype n
α β : Type v
inst✝¹ : DecidableEq α
M : Matrix n n R
p : ℕ
inst✝ : Fact (Nat.Prime p)
hM : IsNilpotent M
h✝ : IsEmpty n
⊢ IsNilpotent M.trace
state_after: no goals

tactic: simpa using this
state_before: R : Type u
inst✝⁴ : CommRing R
n G : Type v
inst✝³ : DecidableEq n
inst✝² : Fintype n
α β : Type v
inst✝¹ : DecidableEq α
M : Matrix n n R
p : ℕ
inst✝ : Fact (Nat.Prime p)
hM : IsNilpotent M
h✝ : Nonempty n
this : IsNilpotent (M.charpolyRev.coeff 1)
⊢ IsNilpotent M.trace
state_after: no goals
Theorem: Filter.generate_neBot_iff
File: Mathlib/Order/Filter/Bases.lean

tactic: simp only [← and_imp, and_comm]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
l l' : Filter α
p : ι → Prop
s✝ : ι → Set α
t : Set α
i : ι
p' : ι' → Prop
s' : ι' → Set α
i' : ι'
s : Set (Set α)
⊢ (∀ {i : Set (Set α)}, i.Finite ∧ i ⊆ s → (⋂₀ i).Nonempty) ↔ ∀ t ⊆ s, t.Finite → (⋂₀ t).Nonempty
state_after: no goals
Theorem: le_bihimp_iff
File: Mathlib/Order/SymmDiff.lean

tactic: simp_rw [bihimp, le_inf_iff, le_himp_iff, and_comm]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝ : GeneralizedHeytingAlgebra α
a✝ b✝ c✝ d a b c : α
⊢ a ≤ b ⇔ c ↔ a ⊓ b ≤ c ∧ a ⊓ c ≤ b
state_after: no goals
Theorem: ZFSet.sInter_empty
File: Mathlib/SetTheory/ZFC/Basic.lean

tactic: simp
state_before: ⊢ ¬∅.Nonempty
state_after: no goals
Theorem: tendsto_rpow_atBot_of_base_lt_one
File: Mathlib/Analysis/SpecialFunctions/Pow/Asymptotics.lean

tactic: simp_rw [Real.rpow_def_of_pos (by positivity : 0 < b)]
state_before: b : ℝ
hb₀ : 0 < b
hb₁ : b < 1
⊢ Tendsto (fun x => b ^ x) atBot atTop
state_after: b : ℝ
hb₀ : 0 < b
hb₁ : b < 1
⊢ Tendsto (fun x => rexp (log b * x)) atBot atTop

tactic: refine tendsto_exp_atTop.comp <| (tendsto_const_mul_atTop_iff_neg <| tendsto_id (α := ℝ)).mpr ?_
state_before: b : ℝ
hb₀ : 0 < b
hb₁ : b < 1
⊢ Tendsto (fun x => rexp (log b * x)) atBot atTop
state_after: b : ℝ
hb₀ : 0 < b
hb₁ : b < 1
⊢ log b < 0

tactic: exact (log_neg_iff hb₀).mpr hb₁
state_before: b : ℝ
hb₀ : 0 < b
hb₁ : b < 1
⊢ log b < 0
state_after: no goals

tactic: positivity
state_before: b : ℝ
hb₀ : 0 < b
hb₁ : b < 1
⊢ 0 < b
state_after: no goals
Theorem: List.alternatingProd_reverse
File: Mathlib/Algebra/BigOperators/Group/List.lean

tactic: simp only [alternatingProd_nil, one_zpow, reverse_nil]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝ : CommGroup α
⊢ [].reverse.alternatingProd = [].alternatingProd ^ (-1) ^ ([].length + 1)
state_after: no goals

tactic: simp_rw [reverse_cons, alternatingProd_append, alternatingProd_reverse,
  alternatingProd_singleton, alternatingProd_cons, length_reverse, length, pow_succ',
  Int.neg_mul, one_mul, zpow_neg, inv_inv]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝ : CommGroup α
a : α
l : List α
⊢ (a :: l).reverse.alternatingProd = (a :: l).alternatingProd ^ (-1) ^ ((a :: l).length + 1)
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝ : CommGroup α
a : α
l : List α
⊢ (l.alternatingProd ^ (-1) ^ l.length)⁻¹ * a ^ (-1) ^ l.length = (a / l.alternatingProd) ^ (-1) ^ l.length

tactic: rw [mul_comm, ← div_eq_mul_inv, div_zpow]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝ : CommGroup α
a : α
l : List α
⊢ (l.alternatingProd ^ (-1) ^ l.length)⁻¹ * a ^ (-1) ^ l.length = (a / l.alternatingProd) ^ (-1) ^ l.length
state_after: no goals
Theorem: fourierBasis_repr
File: Mathlib/Analysis/Fourier/AddCircle.lean

tactic: trans ∫ t : AddCircle T, conj ((@fourierLp T hT 2 _ i : AddCircle T → ℂ) t) * f t ∂haarAddCircle
state_before: T : ℝ
hT : Fact (0 < T)
f : ↥(Lp ℂ 2 haarAddCircle)
i : ℤ
⊢ ↑(fourierBasis.repr f) i = fourierCoeff (↑↑f) i
state_after: T : ℝ
hT : Fact (0 < T)
f : ↥(Lp ℂ 2 haarAddCircle)
i : ℤ
⊢ ↑(fourierBasis.repr f) i = ∫ (t : AddCircle T), (starRingEnd ℂ) (↑↑(fourierLp 2 i) t) * ↑↑f t ∂haarAddCircle

T : ℝ
hT : Fact (0 < T)
f : ↥(Lp ℂ 2 haarAddCircle)
i : ℤ
⊢ ∫ (t : AddCircle T), (starRingEnd ℂ) (↑↑(fourierLp 2 i) t) * ↑↑f t ∂haarAddCircle = fourierCoeff (↑↑f) i

tactic: rw [fourierBasis.repr_apply_apply f i, MeasureTheory.L2.inner_def, coe_fourierBasis]
state_before: T : ℝ
hT : Fact (0 < T)
f : ↥(Lp ℂ 2 haarAddCircle)
i : ℤ
⊢ ↑(fourierBasis.repr f) i = ∫ (t : AddCircle T), (starRingEnd ℂ) (↑↑(fourierLp 2 i) t) * ↑↑f t ∂haarAddCircle
state_after: T : ℝ
hT : Fact (0 < T)
f : ↥(Lp ℂ 2 haarAddCircle)
i : ℤ
⊢ ∫ (a : AddCircle T), ⟪↑↑(fourierLp 2 i) a, ↑↑f a⟫_ℂ ∂haarAddCircle =
    ∫ (t : AddCircle T), (starRingEnd ℂ) (↑↑(fourierLp 2 i) t) * ↑↑f t ∂haarAddCircle

tactic: simp only [RCLike.inner_apply]
state_before: T : ℝ
hT : Fact (0 < T)
f : ↥(Lp ℂ 2 haarAddCircle)
i : ℤ
⊢ ∫ (a : AddCircle T), ⟪↑↑(fourierLp 2 i) a, ↑↑f a⟫_ℂ ∂haarAddCircle =
    ∫ (t : AddCircle T), (starRingEnd ℂ) (↑↑(fourierLp 2 i) t) * ↑↑f t ∂haarAddCircle
state_after: no goals

tactic: apply integral_congr_ae
state_before: T : ℝ
hT : Fact (0 < T)
f : ↥(Lp ℂ 2 haarAddCircle)
i : ℤ
⊢ ∫ (t : AddCircle T), (starRingEnd ℂ) (↑↑(fourierLp 2 i) t) * ↑↑f t ∂haarAddCircle = fourierCoeff (↑↑f) i
state_after: case h
T : ℝ
hT : Fact (0 < T)
f : ↥(Lp ℂ 2 haarAddCircle)
i : ℤ
⊢ (fun a => (starRingEnd ℂ) (↑↑(fourierLp 2 i) a) * ↑↑f a) =ᶠ[ae haarAddCircle] fun a => (fourier (-i)) a • ↑↑f a

tactic: filter_upwards [coeFn_fourierLp 2 i] with _ ht
state_before: case h
T : ℝ
hT : Fact (0 < T)
f : ↥(Lp ℂ 2 haarAddCircle)
i : ℤ
⊢ (fun a => (starRingEnd ℂ) (↑↑(fourierLp 2 i) a) * ↑↑f a) =ᶠ[ae haarAddCircle] fun a => (fourier (-i)) a • ↑↑f a
state_after: case h
T : ℝ
hT : Fact (0 < T)
f : ↥(Lp ℂ 2 haarAddCircle)
i : ℤ
a✝ : AddCircle T
ht : ↑↑(fourierLp 2 i) a✝ = (fourier i) a✝
⊢ (starRingEnd ℂ) (↑↑(fourierLp 2 i) a✝) * ↑↑f a✝ = (fourier (-i)) a✝ • ↑↑f a✝

tactic: rw [ht, ← fourier_neg, smul_eq_mul]
state_before: case h
T : ℝ
hT : Fact (0 < T)
f : ↥(Lp ℂ 2 haarAddCircle)
i : ℤ
a✝ : AddCircle T
ht : ↑↑(fourierLp 2 i) a✝ = (fourier i) a✝
⊢ (starRingEnd ℂ) (↑↑(fourierLp 2 i) a✝) * ↑↑f a✝ = (fourier (-i)) a✝ • ↑↑f a✝
state_after: no goals
Theorem: CategoryTheory.Limits.BiconeMorphism.ext
File: Mathlib/CategoryTheory/Limits/Shapes/Biproducts.lean

tactic: cases f
state_before: J : Type w
C : Type uC
inst✝³ : Category.{uC', uC} C
inst✝² : HasZeroMorphisms C
D : Type uD
inst✝¹ : Category.{uD', uD} D
inst✝ : HasZeroMorphisms D
F : J → C
c c' : Bicone F
f g : c ⟶ c'
w : f.hom = g.hom
⊢ f = g
state_after: case mk
J : Type w
C : Type uC
inst✝³ : Category.{uC', uC} C
inst✝² : HasZeroMorphisms C
D : Type uD
inst✝¹ : Category.{uD', uD} D
inst✝ : HasZeroMorphisms D
F : J → C
c c' : Bicone F
g : c ⟶ c'
hom✝ : c.pt ⟶ c'.pt
wπ✝ : ∀ (j : J), hom✝ ≫ c'.π j = c.π j
wι✝ : ∀ (j : J), c.ι j ≫ hom✝ = c'.ι j
w : { hom := hom✝, wπ := wπ✝, wι := wι✝ }.hom = g.hom
⊢ { hom := hom✝, wπ := wπ✝, wι := wι✝ } = g

tactic: cases g
state_before: case mk
J : Type w
C : Type uC
inst✝³ : Category.{uC', uC} C
inst✝² : HasZeroMorphisms C
D : Type uD
inst✝¹ : Category.{uD', uD} D
inst✝ : HasZeroMorphisms D
F : J → C
c c' : Bicone F
g : c ⟶ c'
hom✝ : c.pt ⟶ c'.pt
wπ✝ : ∀ (j : J), hom✝ ≫ c'.π j = c.π j
wι✝ : ∀ (j : J), c.ι j ≫ hom✝ = c'.ι j
w : { hom := hom✝, wπ := wπ✝, wι := wι✝ }.hom = g.hom
⊢ { hom := hom✝, wπ := wπ✝, wι := wι✝ } = g
state_after: case mk.mk
J : Type w
C : Type uC
inst✝³ : Category.{uC', uC} C
inst✝² : HasZeroMorphisms C
D : Type uD
inst✝¹ : Category.{uD', uD} D
inst✝ : HasZeroMorphisms D
F : J → C
c c' : Bicone F
hom✝¹ : c.pt ⟶ c'.pt
wπ✝¹ : ∀ (j : J), hom✝¹ ≫ c'.π j = c.π j
wι✝¹ : ∀ (j : J), c.ι j ≫ hom✝¹ = c'.ι j
hom✝ : c.pt ⟶ c'.pt
wπ✝ : ∀ (j : J), hom✝ ≫ c'.π j = c.π j
wι✝ : ∀ (j : J), c.ι j ≫ hom✝ = c'.ι j
w : { hom := hom✝¹, wπ := wπ✝¹, wι := wι✝¹ }.hom = { hom := hom✝, wπ := wπ✝, wι := wι✝ }.hom
⊢ { hom := hom✝¹, wπ := wπ✝¹, wι := wι✝¹ } = { hom := hom✝, wπ := wπ✝, wι := wι✝ }

tactic: congr
state_before: case mk.mk
J : Type w
C : Type uC
inst✝³ : Category.{uC', uC} C
inst✝² : HasZeroMorphisms C
D : Type uD
inst✝¹ : Category.{uD', uD} D
inst✝ : HasZeroMorphisms D
F : J → C
c c' : Bicone F
hom✝¹ : c.pt ⟶ c'.pt
wπ✝¹ : ∀ (j : J), hom✝¹ ≫ c'.π j = c.π j
wι✝¹ : ∀ (j : J), c.ι j ≫ hom✝¹ = c'.ι j
hom✝ : c.pt ⟶ c'.pt
wπ✝ : ∀ (j : J), hom✝ ≫ c'.π j = c.π j
wι✝ : ∀ (j : J), c.ι j ≫ hom✝ = c'.ι j
w : { hom := hom✝¹, wπ := wπ✝¹, wι := wι✝¹ }.hom = { hom := hom✝, wπ := wπ✝, wι := wι✝ }.hom
⊢ { hom := hom✝¹, wπ := wπ✝¹, wι := wι✝¹ } = { hom := hom✝, wπ := wπ✝, wι := wι✝ }
state_after: no goals
Theorem: imageSubobjectIso_imageToKernel'
File: Mathlib/Algebra/Homology/ImageToKernel.lean

tactic: ext
state_before: ι : Type u_1
V : Type u
inst✝³ : Category.{v, u} V
inst✝² : HasZeroMorphisms V
A B C : V
f : A ⟶ B
g : B ⟶ C
w✝ : f ≫ g = 0
inst✝¹ : HasKernels V
inst✝ : HasImages V
w : f ≫ g = 0
⊢ (imageSubobjectIso f).hom ≫ imageToKernel' f g w = imageToKernel f g w ≫ (kernelSubobjectIso g).hom
state_after: case h
ι : Type u_1
V : Type u
inst✝³ : Category.{v, u} V
inst✝² : HasZeroMorphisms V
A B C : V
f : A ⟶ B
g : B ⟶ C
w✝ : f ≫ g = 0
inst✝¹ : HasKernels V
inst✝ : HasImages V
w : f ≫ g = 0
⊢ ((imageSubobjectIso f).hom ≫ imageToKernel' f g w) ≫ equalizer.ι g 0 =
    (imageToKernel f g w ≫ (kernelSubobjectIso g).hom) ≫ equalizer.ι g 0

tactic: simp [imageToKernel']
state_before: case h
ι : Type u_1
V : Type u
inst✝³ : Category.{v, u} V
inst✝² : HasZeroMorphisms V
A B C : V
f : A ⟶ B
g : B ⟶ C
w✝ : f ≫ g = 0
inst✝¹ : HasKernels V
inst✝ : HasImages V
w : f ≫ g = 0
⊢ ((imageSubobjectIso f).hom ≫ imageToKernel' f g w) ≫ equalizer.ι g 0 =
    (imageToKernel f g w ≫ (kernelSubobjectIso g).hom) ≫ equalizer.ι g 0
state_after: no goals