1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: integral_sin_mul_cos₂
File: Mathlib/Analysis/SpecialFunctions/Integrals.lean

tactic: simpa using integral_sin_pow_odd_mul_cos_pow 0 1
state_before: a b : ℝ
n : ℕ
⊢ ∫ (x : ℝ) in a..b, sin x * cos x = (cos a ^ 2 - cos b ^ 2) / 2
state_after: no goals
Theorem: bertrand_main_inequality
File: Mathlib/NumberTheory/Bertrand.lean

tactic: rw [← @cast_le ℝ]
state_before: n : ℕ
n_large : 512 ≤ n
⊢ n * (2 * n) ^ (2 * n).sqrt * 4 ^ (2 * n / 3) ≤ 4 ^ n
state_after: n : ℕ
n_large : 512 ≤ n
⊢ ↑(n * (2 * n) ^ (2 * n).sqrt * 4 ^ (2 * n / 3)) ≤ ↑(4 ^ n)

tactic: simp only [cast_add, cast_one, cast_mul, cast_pow, ← Real.rpow_natCast]
state_before: n : ℕ
n_large : 512 ≤ n
⊢ ↑(n * (2 * n) ^ (2 * n).sqrt * 4 ^ (2 * n / 3)) ≤ ↑(4 ^ n)
state_after: n : ℕ
n_large : 512 ≤ n
⊢ ↑n * (↑2 * ↑n) ^ ↑(2 * n).sqrt * ↑4 ^ ↑(2 * n / 3) ≤ ↑4 ^ ↑n

tactic: refine _root_.trans ?_ (Bertrand.real_main_inequality (by exact_mod_cast n_large))
state_before: n : ℕ
n_large : 512 ≤ n
⊢ ↑n * (↑2 * ↑n) ^ ↑(2 * n).sqrt * ↑4 ^ ↑(2 * n / 3) ≤ ↑4 ^ ↑n
state_after: n : ℕ
n_large : 512 ≤ n
⊢ ↑n * (↑2 * ↑n) ^ ↑(2 * n).sqrt * ↑4 ^ ↑(2 * n / 3) ≤ ↑n * (2 * ↑n) ^ √(2 * ↑n) * 4 ^ (2 * ↑n / 3)

tactic: gcongr
state_before: n : ℕ
n_large : 512 ≤ n
⊢ ↑n * (↑2 * ↑n) ^ ↑(2 * n).sqrt * ↑4 ^ ↑(2 * n / 3) ≤ ↑n * (2 * ↑n) ^ √(2 * ↑n) * 4 ^ (2 * ↑n / 3)
state_after: case h₁.h.hx
n : ℕ
n_large : 512 ≤ n
⊢ 1 ≤ ↑2 * ↑n

case h₁.h.hyz
n : ℕ
n_large : 512 ≤ n
⊢ ↑(2 * n).sqrt ≤ √(2 * ↑n)

case h₂.hx
n : ℕ
n_large : 512 ≤ n
⊢ 1 ≤ ↑4

case h₂.hyz
n : ℕ
n_large : 512 ≤ n
⊢ ↑(2 * n / 3) ≤ 2 * ↑n / 3

tactic: exact_mod_cast n_large
state_before: n : ℕ
n_large : 512 ≤ n
⊢ 512 ≤ ↑n
state_after: no goals

tactic: have n2_pos : 0 < 2 * n := by positivity
state_before: case h₁.h.hx
n : ℕ
n_large : 512 ≤ n
⊢ 1 ≤ ↑2 * ↑n
state_after: case h₁.h.hx
n : ℕ
n_large : 512 ≤ n
n2_pos : 0 < 2 * n
⊢ 1 ≤ ↑2 * ↑n

tactic: exact mod_cast n2_pos
state_before: case h₁.h.hx
n : ℕ
n_large : 512 ≤ n
n2_pos : 0 < 2 * n
⊢ 1 ≤ ↑2 * ↑n
state_after: no goals

tactic: positivity
state_before: n : ℕ
n_large : 512 ≤ n
⊢ 0 < 2 * n
state_after: no goals

tactic: exact_mod_cast Real.nat_sqrt_le_real_sqrt
state_before: case h₁.h.hyz
n : ℕ
n_large : 512 ≤ n
⊢ ↑(2 * n).sqrt ≤ √(2 * ↑n)
state_after: no goals

tactic: norm_num1
state_before: case h₂.hx
n : ℕ
n_large : 512 ≤ n
⊢ 1 ≤ ↑4
state_after: no goals

tactic: exact cast_div_le.trans (by norm_cast)
state_before: case h₂.hyz
n : ℕ
n_large : 512 ≤ n
⊢ ↑(2 * n / 3) ≤ 2 * ↑n / 3
state_after: no goals

tactic: norm_cast
state_before: n : ℕ
n_large : 512 ≤ n
⊢ ↑(2 * n) / ↑3 ≤ 2 * ↑n / 3
state_after: no goals
Theorem: ValuationSubring.nonunits_injective
File: Mathlib/RingTheory/Valuation/ValuationSubring.lean

tactic: simpa only [le_antisymm_iff, nonunits_le_nonunits] using h.symm
state_before: K : Type u
inst✝ : Field K
A✝ A B : ValuationSubring K
h : A.nonunits = B.nonunits
⊢ A = B
state_after: no goals
Theorem: Nat.properDivisors_eq_empty
File: Mathlib/NumberTheory/Divisors.lean

tactic: rw [← not_nonempty_iff_eq_empty, nonempty_properDivisors, not_lt]
state_before: n : ℕ
⊢ n.properDivisors = ∅ ↔ n ≤ 1
state_after: no goals
Theorem: disjoint_iSup₂_iff
File: Mathlib/Order/CompleteBooleanAlgebra.lean

tactic: simp_rw [disjoint_iSup_iff]
state_before: α : Type u
β : Type v
ι : Sort w
κ : ι → Sort w'
inst✝ : Frame α
s t : Set α
a b : α
f : (i : ι) → κ i → α
⊢ Disjoint a (⨆ i, ⨆ j, f i j) ↔ ∀ (i : ι) (j : κ i), Disjoint a (f i j)
state_after: no goals
Theorem: Cardinal.lift_le_one_iff
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: simpa using lift_le_nat_iff (n := 1)
state_before: α β : Type u
a : Cardinal.{u}
⊢ lift.{v, u} a ≤ 1 ↔ a ≤ 1
state_after: no goals
Theorem: Submodule.span_singleton_eq_top_iff
File: Mathlib/LinearAlgebra/Span.lean

tactic: rw [eq_top_iff, le_span_singleton_iff]
state_before: R : Type u_1
R₂ : Type u_2
K : Type u_3
M : Type u_4
M₂ : Type u_5
V : Type u_6
S : Type u_7
inst✝⁷ : Semiring R
inst✝⁶ : AddCommMonoid M
inst✝⁵ : Module R M
x✝ : M
p p' : Submodule R M
inst✝⁴ : Semiring R₂
σ₁₂ : R →+* R₂
inst✝³ : AddCommMonoid M₂
inst✝² : Module R₂ M₂
F : Type u_8
inst✝¹ : FunLike F M M₂
inst✝ : SemilinearMapClass F σ₁₂ M M₂
s t : Set M
x : M
⊢ span R {x} = ⊤ ↔ ∀ (v : M), ∃ r, r • x = v
state_after: R : Type u_1
R₂ : Type u_2
K : Type u_3
M : Type u_4
M₂ : Type u_5
V : Type u_6
S : Type u_7
inst✝⁷ : Semiring R
inst✝⁶ : AddCommMonoid M
inst✝⁵ : Module R M
x✝ : M
p p' : Submodule R M
inst✝⁴ : Semiring R₂
σ₁₂ : R →+* R₂
inst✝³ : AddCommMonoid M₂
inst✝² : Module R₂ M₂
F : Type u_8
inst✝¹ : FunLike F M M₂
inst✝ : SemilinearMapClass F σ₁₂ M M₂
s t : Set M
x : M
⊢ (∀ v ∈ ⊤, ∃ r, r • x = v) ↔ ∀ (v : M), ∃ r, r • x = v

tactic: tauto
state_before: R : Type u_1
R₂ : Type u_2
K : Type u_3
M : Type u_4
M₂ : Type u_5
V : Type u_6
S : Type u_7
inst✝⁷ : Semiring R
inst✝⁶ : AddCommMonoid M
inst✝⁵ : Module R M
x✝ : M
p p' : Submodule R M
inst✝⁴ : Semiring R₂
σ₁₂ : R →+* R₂
inst✝³ : AddCommMonoid M₂
inst✝² : Module R₂ M₂
F : Type u_8
inst✝¹ : FunLike F M M₂
inst✝ : SemilinearMapClass F σ₁₂ M M₂
s t : Set M
x : M
⊢ (∀ v ∈ ⊤, ∃ r, r • x = v) ↔ ∀ (v : M), ∃ r, r • x = v
state_after: no goals
Theorem: Complex.hasDerivAt_Gamma_one
File: Mathlib/NumberTheory/Harmonic/GammaDeriv.lean

tactic: simpa only [factorial_zero, cast_one, harmonic_zero, Rat.cast_zero, add_zero, mul_neg, one_mul,
  cast_zero, zero_add] using hasDerivAt_Gamma_nat 0
state_before: ⊢ HasDerivAt Gamma (-↑γ) 1
state_after: no goals
Theorem: ProbabilityTheory.kernel.indepSet_empty_right
File: Mathlib/Probability/Independence/Kernel.lean

tactic: simp only [IndepSet, generateFrom_singleton_empty]
state_before: α : Type u_1
Ω : Type u_2
ι : Type u_3
_mα : MeasurableSpace α
_mΩ : MeasurableSpace Ω
κ : ↥(kernel α Ω)
μ : Measure α
inst✝ : IsMarkovKernel κ
s : Set Ω
⊢ IndepSet s ∅ κ μ
state_after: α : Type u_1
Ω : Type u_2
ι : Type u_3
_mα : MeasurableSpace α
_mΩ : MeasurableSpace Ω
κ : ↥(kernel α Ω)
μ : Measure α
inst✝ : IsMarkovKernel κ
s : Set Ω
⊢ Indep (generateFrom {s}) ⊥ κ μ

tactic: exact indep_bot_right _
state_before: α : Type u_1
Ω : Type u_2
ι : Type u_3
_mα : MeasurableSpace α
_mΩ : MeasurableSpace Ω
κ : ↥(kernel α Ω)
μ : Measure α
inst✝ : IsMarkovKernel κ
s : Set Ω
⊢ Indep (generateFrom {s}) ⊥ κ μ
state_after: no goals
Theorem: IsExposed.isClosed
File: Mathlib/Analysis/Convex/Exposed.lean

tactic: obtain rfl | hB := B.eq_empty_or_nonempty
state_before: 𝕜 : Type u_1
E : Type u_2
inst✝⁵ : TopologicalSpace 𝕜
inst✝⁴ : OrderedRing 𝕜
inst✝³ : AddCommMonoid E
inst✝² : TopologicalSpace E
inst✝¹ : Module 𝕜 E
l : E →L[𝕜] 𝕜
A✝ B✝ C : Set E
X : Finset E
x : E
inst✝ : OrderClosedTopology 𝕜
A B : Set E
hAB : IsExposed 𝕜 A B
hA : IsClosed A
⊢ IsClosed B
state_after: case inl
𝕜 : Type u_1
E : Type u_2
inst✝⁵ : TopologicalSpace 𝕜
inst✝⁴ : OrderedRing 𝕜
inst✝³ : AddCommMonoid E
inst✝² : TopologicalSpace E
inst✝¹ : Module 𝕜 E
l : E →L[𝕜] 𝕜
A✝ B C : Set E
X : Finset E
x : E
inst✝ : OrderClosedTopology 𝕜
A : Set E
hA : IsClosed A
hAB : IsExposed 𝕜 A ∅
⊢ IsClosed ∅

case inr
𝕜 : Type u_1
E : Type u_2
inst✝⁵ : TopologicalSpace 𝕜
inst✝⁴ : OrderedRing 𝕜
inst✝³ : AddCommMonoid E
inst✝² : TopologicalSpace E
inst✝¹ : Module 𝕜 E
l : E →L[𝕜] 𝕜
A✝ B✝ C : Set E
X : Finset E
x : E
inst✝ : OrderClosedTopology 𝕜
A B : Set E
hAB : IsExposed 𝕜 A B
hA : IsClosed A
hB : B.Nonempty
⊢ IsClosed B

tactic: obtain ⟨l, a, rfl⟩ := hAB.eq_inter_halfspace' hB
state_before: case inr
𝕜 : Type u_1
E : Type u_2
inst✝⁵ : TopologicalSpace 𝕜
inst✝⁴ : OrderedRing 𝕜
inst✝³ : AddCommMonoid E
inst✝² : TopologicalSpace E
inst✝¹ : Module 𝕜 E
l : E →L[𝕜] 𝕜
A✝ B✝ C : Set E
X : Finset E
x : E
inst✝ : OrderClosedTopology 𝕜
A B : Set E
hAB : IsExposed 𝕜 A B
hA : IsClosed A
hB : B.Nonempty
⊢ IsClosed B
state_after: case inr.intro.intro
𝕜 : Type u_1
E : Type u_2
inst✝⁵ : TopologicalSpace 𝕜
inst✝⁴ : OrderedRing 𝕜
inst✝³ : AddCommMonoid E
inst✝² : TopologicalSpace E
inst✝¹ : Module 𝕜 E
l✝ : E →L[𝕜] 𝕜
A✝ B C : Set E
X : Finset E
x : E
inst✝ : OrderClosedTopology 𝕜
A : Set E
hA : IsClosed A
l : E →L[𝕜] 𝕜
a : 𝕜
hAB : IsExposed 𝕜 A {x | x ∈ A ∧ a ≤ l x}
hB : {x | x ∈ A ∧ a ≤ l x}.Nonempty
⊢ IsClosed {x | x ∈ A ∧ a ≤ l x}

tactic: exact hA.isClosed_le continuousOn_const l.continuous.continuousOn
state_before: case inr.intro.intro
𝕜 : Type u_1
E : Type u_2
inst✝⁵ : TopologicalSpace 𝕜
inst✝⁴ : OrderedRing 𝕜
inst✝³ : AddCommMonoid E
inst✝² : TopologicalSpace E
inst✝¹ : Module 𝕜 E
l✝ : E →L[𝕜] 𝕜
A✝ B C : Set E
X : Finset E
x : E
inst✝ : OrderClosedTopology 𝕜
A : Set E
hA : IsClosed A
l : E →L[𝕜] 𝕜
a : 𝕜
hAB : IsExposed 𝕜 A {x | x ∈ A ∧ a ≤ l x}
hB : {x | x ∈ A ∧ a ≤ l x}.Nonempty
⊢ IsClosed {x | x ∈ A ∧ a ≤ l x}
state_after: no goals

tactic: simp
state_before: case inl
𝕜 : Type u_1
E : Type u_2
inst✝⁵ : TopologicalSpace 𝕜
inst✝⁴ : OrderedRing 𝕜
inst✝³ : AddCommMonoid E
inst✝² : TopologicalSpace E
inst✝¹ : Module 𝕜 E
l : E →L[𝕜] 𝕜
A✝ B C : Set E
X : Finset E
x : E
inst✝ : OrderClosedTopology 𝕜
A : Set E
hA : IsClosed A
hAB : IsExposed 𝕜 A ∅
⊢ IsClosed ∅
state_after: no goals
Theorem: Nat.factorizationEquiv_apply
File: Mathlib/Data/Nat/Factorization/Basic.lean

tactic: cases n
state_before: a b m n✝ p : ℕ
n : ℕ+
⊢ ↑(factorizationEquiv n) = (↑n).factorization
state_after: case mk
a b m n p val✝ : ℕ
property✝ : 0 < val✝
⊢ ↑(factorizationEquiv ⟨val✝, property✝⟩) = (↑⟨val✝, property✝⟩).factorization

tactic: rfl
state_before: case mk
a b m n p val✝ : ℕ
property✝ : 0 < val✝
⊢ ↑(factorizationEquiv ⟨val✝, property✝⟩) = (↑⟨val✝, property✝⟩).factorization
state_after: no goals
Theorem: injective_iff_map_eq_one
File: Mathlib/Algebra/Group/Hom/Basic.lean

tactic: rw [map_mul, hxy, ← map_mul, mul_inv_self, map_one]
state_before: α : Type u_1
β : Type u_2
M : Type u_3
N : Type u_4
P : Type u_5
G✝ : Type u_6
H✝ : Type u_7
F : Type u_8
inst✝⁵ : Group G✝
inst✝⁴ : CommGroup H✝
G : Type u_9
H : Type u_10
inst✝³ : Group G
inst✝² : MulOneClass H
inst✝¹ : FunLike F G H
inst✝ : MonoidHomClass F G H
f : F
h : ∀ (a : G), f a = 1 → a = 1
x y : G
hxy : f x = f y
⊢ f (x * y⁻¹) = 1
state_after: no goals
Theorem: frontier_sphere'
File: Mathlib/Analysis/NormedSpace/Real.lean

tactic: rw [isClosed_sphere.frontier_eq, interior_sphere' x, diff_empty]
state_before: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : Nontrivial E
x : E
r : ℝ
⊢ frontier (sphere x r) = sphere x r
state_after: no goals
Theorem: Fin.pred_lt_castPred
File: Mathlib/Data/Fin/Basic.lean

tactic: rw [pred_lt_castPred_iff, le_def]
state_before: n m : ℕ
a : Fin (n + 1)
h₁ : a ≠ 0
h₂ : a ≠ last n
⊢ a.pred h₁ < a.castPred h₂
state_after: no goals
Theorem: List.Nodup.cyclicPermutations
File: Mathlib/Data/List/Rotate.lean

tactic: rcases eq_or_ne l [] with rfl | hl
state_before: α : Type u
l✝ l' l : List α
hn : l.Nodup
⊢ l.cyclicPermutations.Nodup
state_after: case inl
α : Type u
l l' : List α
hn : [].Nodup
⊢ [].cyclicPermutations.Nodup

case inr
α : Type u
l✝ l' l : List α
hn : l.Nodup
hl : l ≠ []
⊢ l.cyclicPermutations.Nodup

tactic: simp
state_before: case inl
α : Type u
l l' : List α
hn : [].Nodup
⊢ [].cyclicPermutations.Nodup
state_after: no goals

tactic: rw [nodup_iff_injective_get]
state_before: case inr
α : Type u
l✝ l' l : List α
hn : l.Nodup
hl : l ≠ []
⊢ l.cyclicPermutations.Nodup
state_after: case inr
α : Type u
l✝ l' l : List α
hn : l.Nodup
hl : l ≠ []
⊢ Injective l.cyclicPermutations.get

tactic: rintro ⟨i, hi⟩ ⟨j, hj⟩ h
state_before: case inr
α : Type u
l✝ l' l : List α
hn : l.Nodup
hl : l ≠ []
⊢ Injective l.cyclicPermutations.get
state_after: case inr.mk.mk
α : Type u
l✝ l' l : List α
hn : l.Nodup
hl : l ≠ []
i : ℕ
hi : i < l.cyclicPermutations.length
j : ℕ
hj : j < l.cyclicPermutations.length
h : l.cyclicPermutations.get ⟨i, hi⟩ = l.cyclicPermutations.get ⟨j, hj⟩
⊢ ⟨i, hi⟩ = ⟨j, hj⟩

tactic: simp only [length_cyclicPermutations_of_ne_nil l hl] at hi hj
state_before: case inr.mk.mk
α : Type u
l✝ l' l : List α
hn : l.Nodup
hl : l ≠ []
i : ℕ
hi : i < l.cyclicPermutations.length
j : ℕ
hj : j < l.cyclicPermutations.length
h : l.cyclicPermutations.get ⟨i, hi⟩ = l.cyclicPermutations.get ⟨j, hj⟩
⊢ ⟨i, hi⟩ = ⟨j, hj⟩
state_after: case inr.mk.mk
α : Type u
l✝ l' l : List α
hn : l.Nodup
hl : l ≠ []
i : ℕ
hi✝ : i < l.cyclicPermutations.length
j : ℕ
hj✝ : j < l.cyclicPermutations.length
h : l.cyclicPermutations.get ⟨i, hi✝⟩ = l.cyclicPermutations.get ⟨j, hj✝⟩
hi : i < l.length
hj : j < l.length
⊢ ⟨i, hi✝⟩ = ⟨j, hj✝⟩

tactic: simpa [hn.rotate_congr_iff, mod_eq_of_lt, *] using h
state_before: case inr.mk.mk
α : Type u
l✝ l' l : List α
hn : l.Nodup
hl : l ≠ []
i : ℕ
hi✝ : i < l.cyclicPermutations.length
j : ℕ
hj✝ : j < l.cyclicPermutations.length
h : l.cyclicPermutations.get ⟨i, hi✝⟩ = l.cyclicPermutations.get ⟨j, hj✝⟩
hi : i < l.length
hj : j < l.length
⊢ ⟨i, hi✝⟩ = ⟨j, hj✝⟩
state_after: no goals
Theorem: Matrix.PosDef.eigenvalues_pos
File: Mathlib/LinearAlgebra/Matrix/PosDef.lean

tactic: simp only [hA.1.eigenvalues_eq]
state_before: m : Type u_1
n : Type u_2
R : Type u_3
𝕜 : Type u_4
inst✝⁷ : Fintype m
inst✝⁶ : Fintype n
inst✝⁵ : CommRing R
inst✝⁴ : PartialOrder R
inst✝³ : StarRing R
inst✝² : StarOrderedRing R
inst✝¹ : RCLike 𝕜
inst✝ : DecidableEq n
A : Matrix n n 𝕜
hA : A.PosDef
i : n
⊢ 0 < ⋯.eigenvalues i
state_after: m : Type u_1
n : Type u_2
R : Type u_3
𝕜 : Type u_4
inst✝⁷ : Fintype m
inst✝⁶ : Fintype n
inst✝⁵ : CommRing R
inst✝⁴ : PartialOrder R
inst✝³ : StarRing R
inst✝² : StarOrderedRing R
inst✝¹ : RCLike 𝕜
inst✝ : DecidableEq n
A : Matrix n n 𝕜
hA : A.PosDef
i : n
⊢ 0 <
    RCLike.re
      (star ((WithLp.equiv 2 (n → 𝕜)) (⋯.eigenvectorBasis i)) ⬝ᵥ A *ᵥ (WithLp.equiv 2 (n → 𝕜)) (⋯.eigenvectorBasis i))

tactic: exact hA.re_dotProduct_pos <| hA.1.eigenvectorBasis.orthonormal.ne_zero i
state_before: m : Type u_1
n : Type u_2
R : Type u_3
𝕜 : Type u_4
inst✝⁷ : Fintype m
inst✝⁶ : Fintype n
inst✝⁵ : CommRing R
inst✝⁴ : PartialOrder R
inst✝³ : StarRing R
inst✝² : StarOrderedRing R
inst✝¹ : RCLike 𝕜
inst✝ : DecidableEq n
A : Matrix n n 𝕜
hA : A.PosDef
i : n
⊢ 0 <
    RCLike.re
      (star ((WithLp.equiv 2 (n → 𝕜)) (⋯.eigenvectorBasis i)) ⬝ᵥ A *ᵥ (WithLp.equiv 2 (n → 𝕜)) (⋯.eigenvectorBasis i))
state_after: no goals
Theorem: monotone_of_odd_of_monotoneOn_nonneg
File: Mathlib/Order/Monotone/Odd.lean

tactic: refine MonotoneOn.Iic_union_Ici (fun x hx y hy hxy => neg_le_neg_iff.1 ?_) h₂
state_before: G : Type u_1
H : Type u_2
inst✝¹ : LinearOrderedAddCommGroup G
inst✝ : OrderedAddCommGroup H
f : G → H
h₁ : ∀ (x : G), f (-x) = -f x
h₂ : MonotoneOn f (Ici 0)
⊢ Monotone f
state_after: G : Type u_1
H : Type u_2
inst✝¹ : LinearOrderedAddCommGroup G
inst✝ : OrderedAddCommGroup H
f : G → H
h₁ : ∀ (x : G), f (-x) = -f x
h₂ : MonotoneOn f (Ici 0)
x : G
hx : x ∈ Iic 0
y : G
hy : y ∈ Iic 0
hxy : x ≤ y
⊢ -f y ≤ -f x

tactic: rw [← h₁, ← h₁]
state_before: G : Type u_1
H : Type u_2
inst✝¹ : LinearOrderedAddCommGroup G
inst✝ : OrderedAddCommGroup H
f : G → H
h₁ : ∀ (x : G), f (-x) = -f x
h₂ : MonotoneOn f (Ici 0)
x : G
hx : x ∈ Iic 0
y : G
hy : y ∈ Iic 0
hxy : x ≤ y
⊢ -f y ≤ -f x
state_after: G : Type u_1
H : Type u_2
inst✝¹ : LinearOrderedAddCommGroup G
inst✝ : OrderedAddCommGroup H
f : G → H
h₁ : ∀ (x : G), f (-x) = -f x
h₂ : MonotoneOn f (Ici 0)
x : G
hx : x ∈ Iic 0
y : G
hy : y ∈ Iic 0
hxy : x ≤ y
⊢ f (-y) ≤ f (-x)

tactic: exact h₂ (neg_nonneg.2 hy) (neg_nonneg.2 hx) (neg_le_neg hxy)
state_before: G : Type u_1
H : Type u_2
inst✝¹ : LinearOrderedAddCommGroup G
inst✝ : OrderedAddCommGroup H
f : G → H
h₁ : ∀ (x : G), f (-x) = -f x
h₂ : MonotoneOn f (Ici 0)
x : G
hx : x ∈ Iic 0
y : G
hy : y ∈ Iic 0
hxy : x ≤ y
⊢ f (-y) ≤ f (-x)
state_after: no goals
Theorem: ae_restrict_iff_subtype
File: Mathlib/MeasureTheory/Measure/Restrict.lean

tactic: rw [← map_comap_subtype_coe hs, (MeasurableEmbedding.subtype_coe hs).ae_map_iff]
state_before: R : Type u_1
α : Type u_2
β : Type u_3
δ : Type u_4
γ : Type u_5
ι : Type u_6
m0 : MeasurableSpace α
μ : Measure α
s : Set α
hs : MeasurableSet s
p : α → Prop
⊢ (∀ᵐ (x : α) ∂μ.restrict s, p x) ↔ ∀ᵐ (x : ↑s) ∂Measure.comap Subtype.val μ, p ↑x
state_after: no goals
Theorem: Real.contDiff_rpow_const_of_le
File: Mathlib/Analysis/SpecialFunctions/Pow/Deriv.lean

tactic: induction' n with n ihn generalizing p
state_before: z x y p : ℝ
n : ℕ
h : ↑n ≤ p
⊢ ContDiff ℝ ↑n fun x => x ^ p
state_after: case zero
z x y p : ℝ
h : ↑0 ≤ p
⊢ ContDiff ℝ ↑0 fun x => x ^ p

case succ
z x y : ℝ
n : ℕ
ihn : ∀ {p : ℝ}, ↑n ≤ p → ContDiff ℝ ↑n fun x => x ^ p
p : ℝ
h : ↑(n + 1) ≤ p
⊢ ContDiff ℝ ↑(n + 1) fun x => x ^ p

tactic: exact contDiff_zero.2 (continuous_id.rpow_const fun x => Or.inr <| by simpa using h)
state_before: case zero
z x y p : ℝ
h : ↑0 ≤ p
⊢ ContDiff ℝ ↑0 fun x => x ^ p
state_after: no goals

tactic: simpa using h
state_before: z x✝ y p : ℝ
h : ↑0 ≤ p
x : ℝ
⊢ 0 ≤ p
state_after: no goals

tactic: have h1 : 1 ≤ p := le_trans (by simp) h
state_before: case succ
z x y : ℝ
n : ℕ
ihn : ∀ {p : ℝ}, ↑n ≤ p → ContDiff ℝ ↑n fun x => x ^ p
p : ℝ
h : ↑(n + 1) ≤ p
⊢ ContDiff ℝ ↑(n + 1) fun x => x ^ p
state_after: case succ
z x y : ℝ
n : ℕ
ihn : ∀ {p : ℝ}, ↑n ≤ p → ContDiff ℝ ↑n fun x => x ^ p
p : ℝ
h : ↑(n + 1) ≤ p
h1 : 1 ≤ p
⊢ ContDiff ℝ ↑(n + 1) fun x => x ^ p

tactic: rw [Nat.cast_succ, ← le_sub_iff_add_le] at h
state_before: case succ
z x y : ℝ
n : ℕ
ihn : ∀ {p : ℝ}, ↑n ≤ p → ContDiff ℝ ↑n fun x => x ^ p
p : ℝ
h : ↑(n + 1) ≤ p
h1 : 1 ≤ p
⊢ ContDiff ℝ ↑(n + 1) fun x => x ^ p
state_after: case succ
z x y : ℝ
n : ℕ
ihn : ∀ {p : ℝ}, ↑n ≤ p → ContDiff ℝ ↑n fun x => x ^ p
p : ℝ
h : ↑n ≤ p - 1
h1 : 1 ≤ p
⊢ ContDiff ℝ ↑(n + 1) fun x => x ^ p

tactic: rw [contDiff_succ_iff_deriv, deriv_rpow_const' h1]
state_before: case succ
z x y : ℝ
n : ℕ
ihn : ∀ {p : ℝ}, ↑n ≤ p → ContDiff ℝ ↑n fun x => x ^ p
p : ℝ
h : ↑n ≤ p - 1
h1 : 1 ≤ p
⊢ ContDiff ℝ ↑(n + 1) fun x => x ^ p
state_after: case succ
z x y : ℝ
n : ℕ
ihn : ∀ {p : ℝ}, ↑n ≤ p → ContDiff ℝ ↑n fun x => x ^ p
p : ℝ
h : ↑n ≤ p - 1
h1 : 1 ≤ p
⊢ (Differentiable ℝ fun x => x ^ p) ∧ ContDiff ℝ ↑n fun x => p * x ^ (p - 1)

tactic: exact ⟨differentiable_rpow_const h1, contDiff_const.mul (ihn h)⟩
state_before: case succ
z x y : ℝ
n : ℕ
ihn : ∀ {p : ℝ}, ↑n ≤ p → ContDiff ℝ ↑n fun x => x ^ p
p : ℝ
h : ↑n ≤ p - 1
h1 : 1 ≤ p
⊢ (Differentiable ℝ fun x => x ^ p) ∧ ContDiff ℝ ↑n fun x => p * x ^ (p - 1)
state_after: no goals

tactic: simp
state_before: z x y : ℝ
n : ℕ
ihn : ∀ {p : ℝ}, ↑n ≤ p → ContDiff ℝ ↑n fun x => x ^ p
p : ℝ
h : ↑(n + 1) ≤ p
⊢ 1 ≤ ↑(n + 1)
state_after: no goals
Theorem: MeasureTheory.condexp_stopping_time_ae_eq_restrict_eq
File: Mathlib/Probability/Process/Stopping.lean

tactic: refine condexp_ae_eq_restrict_of_measurableSpace_eq_on hτ.measurableSpace_le (ℱ.le i)
  (hτ.measurableSet_eq' i) fun t => ?_
state_before: Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝⁹ : LinearOrder ι
μ : Measure Ω
ℱ : Filtration ι m
τ σ : Ω → ι
E : Type u_4
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : CompleteSpace E
f : Ω → E
inst✝⁵ : atTop.IsCountablyGenerated
inst✝⁴ : TopologicalSpace ι
inst✝³ : OrderTopology ι
inst✝² : FirstCountableTopology ι
inst✝¹ : SigmaFiniteFiltration μ ℱ
hτ : IsStoppingTime ℱ τ
inst✝ : SigmaFinite (μ.trim ⋯)
i : ι
⊢ μ[f|hτ.measurableSpace] =ᶠ[ae (μ.restrict {x | τ x = i})] μ[f|↑ℱ i]
state_after: Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝⁹ : LinearOrder ι
μ : Measure Ω
ℱ : Filtration ι m
τ σ : Ω → ι
E : Type u_4
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : CompleteSpace E
f : Ω → E
inst✝⁵ : atTop.IsCountablyGenerated
inst✝⁴ : TopologicalSpace ι
inst✝³ : OrderTopology ι
inst✝² : FirstCountableTopology ι
inst✝¹ : SigmaFiniteFiltration μ ℱ
hτ : IsStoppingTime ℱ τ
inst✝ : SigmaFinite (μ.trim ⋯)
i : ι
t : Set Ω
⊢ MeasurableSet ({x | τ x = i} ∩ t) ↔ MeasurableSet ({x | τ x = i} ∩ t)

tactic: rw [Set.inter_comm _ t, IsStoppingTime.measurableSet_inter_eq_iff]
state_before: Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝⁹ : LinearOrder ι
μ : Measure Ω
ℱ : Filtration ι m
τ σ : Ω → ι
E : Type u_4
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : CompleteSpace E
f : Ω → E
inst✝⁵ : atTop.IsCountablyGenerated
inst✝⁴ : TopologicalSpace ι
inst✝³ : OrderTopology ι
inst✝² : FirstCountableTopology ι
inst✝¹ : SigmaFiniteFiltration μ ℱ
hτ : IsStoppingTime ℱ τ
inst✝ : SigmaFinite (μ.trim ⋯)
i : ι
t : Set Ω
⊢ MeasurableSet ({x | τ x = i} ∩ t) ↔ MeasurableSet ({x | τ x = i} ∩ t)
state_after: no goals
Theorem: Basis.toDual_injective
File: Mathlib/LinearAlgebra/Dual.lean

tactic: simp_rw [← toDual_eq_repr]
state_before: R : Type uR
M : Type uM
K : Type uK
V : Type uV
ι : Type uι
inst✝³ : CommSemiring R
inst✝² : AddCommMonoid M
inst✝¹ : Module R M
inst✝ : DecidableEq ι
b : Basis ι R M
x y : M
h : b.toDual x = b.toDual y
i : ι
⊢ (b.repr x) i = (b.repr y) i
state_after: R : Type uR
M : Type uM
K : Type uK
V : Type uV
ι : Type uι
inst✝³ : CommSemiring R
inst✝² : AddCommMonoid M
inst✝¹ : Module R M
inst✝ : DecidableEq ι
b : Basis ι R M
x y : M
h : b.toDual x = b.toDual y
i : ι
⊢ (b.toDual x) (b i) = (b.toDual y) (b i)

tactic: exact DFunLike.congr_fun h _
state_before: R : Type uR
M : Type uM
K : Type uK
V : Type uV
ι : Type uι
inst✝³ : CommSemiring R
inst✝² : AddCommMonoid M
inst✝¹ : Module R M
inst✝ : DecidableEq ι
b : Basis ι R M
x y : M
h : b.toDual x = b.toDual y
i : ι
⊢ (b.toDual x) (b i) = (b.toDual y) (b i)
state_after: no goals
Theorem: Stream'.Seq.coinduction2
File: Mathlib/Data/Seq/Seq.lean

tactic: refine eq_of_bisim (fun s1 s2 => ∃ s, s1 = f s ∧ s2 = g s) ?_ ⟨s, rfl, rfl⟩
state_before: α : Type u
β : Type v
γ : Type w
s : Seq α
f g : Seq α → Seq β
H : ∀ (s : Seq α), BisimO (fun s1 s2 => ∃ s, s1 = f s ∧ s2 = g s) (f s).destruct (g s).destruct
⊢ f s = g s
state_after: α : Type u
β : Type v
γ : Type w
s : Seq α
f g : Seq α → Seq β
H : ∀ (s : Seq α), BisimO (fun s1 s2 => ∃ s, s1 = f s ∧ s2 = g s) (f s).destruct (g s).destruct
⊢ IsBisimulation fun s1 s2 => ∃ s, s1 = f s ∧ s2 = g s

tactic: intro s1 s2 h
state_before: α : Type u
β : Type v
γ : Type w
s : Seq α
f g : Seq α → Seq β
H : ∀ (s : Seq α), BisimO (fun s1 s2 => ∃ s, s1 = f s ∧ s2 = g s) (f s).destruct (g s).destruct
⊢ IsBisimulation fun s1 s2 => ∃ s, s1 = f s ∧ s2 = g s
state_after: α : Type u
β : Type v
γ : Type w
s : Seq α
f g : Seq α → Seq β
H : ∀ (s : Seq α), BisimO (fun s1 s2 => ∃ s, s1 = f s ∧ s2 = g s) (f s).destruct (g s).destruct
s1 s2 : Seq β
h : ∃ s, s1 = f s ∧ s2 = g s
⊢ BisimO (fun s1 s2 => ∃ s, s1 = f s ∧ s2 = g s) s1.destruct s2.destruct

tactic: rcases h with ⟨s, h1, h2⟩
state_before: α : Type u
β : Type v
γ : Type w
s : Seq α
f g : Seq α → Seq β
H : ∀ (s : Seq α), BisimO (fun s1 s2 => ∃ s, s1 = f s ∧ s2 = g s) (f s).destruct (g s).destruct
s1 s2 : Seq β
h : ∃ s, s1 = f s ∧ s2 = g s
⊢ BisimO (fun s1 s2 => ∃ s, s1 = f s ∧ s2 = g s) s1.destruct s2.destruct
state_after: case intro.intro
α : Type u
β : Type v
γ : Type w
s✝ : Seq α
f g : Seq α → Seq β
H : ∀ (s : Seq α), BisimO (fun s1 s2 => ∃ s, s1 = f s ∧ s2 = g s) (f s).destruct (g s).destruct
s1 s2 : Seq β
s : Seq α
h1 : s1 = f s
h2 : s2 = g s
⊢ BisimO (fun s1 s2 => ∃ s, s1 = f s ∧ s2 = g s) s1.destruct s2.destruct

tactic: rw [h1, h2]
state_before: case intro.intro
α : Type u
β : Type v
γ : Type w
s✝ : Seq α
f g : Seq α → Seq β
H : ∀ (s : Seq α), BisimO (fun s1 s2 => ∃ s, s1 = f s ∧ s2 = g s) (f s).destruct (g s).destruct
s1 s2 : Seq β
s : Seq α
h1 : s1 = f s
h2 : s2 = g s
⊢ BisimO (fun s1 s2 => ∃ s, s1 = f s ∧ s2 = g s) s1.destruct s2.destruct
state_after: case intro.intro
α : Type u
β : Type v
γ : Type w
s✝ : Seq α
f g : Seq α → Seq β
H : ∀ (s : Seq α), BisimO (fun s1 s2 => ∃ s, s1 = f s ∧ s2 = g s) (f s).destruct (g s).destruct
s1 s2 : Seq β
s : Seq α
h1 : s1 = f s
h2 : s2 = g s
⊢ BisimO (fun s1 s2 => ∃ s, s1 = f s ∧ s2 = g s) (f s).destruct (g s).destruct

tactic: apply H
state_before: case intro.intro
α : Type u
β : Type v
γ : Type w
s✝ : Seq α
f g : Seq α → Seq β
H : ∀ (s : Seq α), BisimO (fun s1 s2 => ∃ s, s1 = f s ∧ s2 = g s) (f s).destruct (g s).destruct
s1 s2 : Seq β
s : Seq α
h1 : s1 = f s
h2 : s2 = g s
⊢ BisimO (fun s1 s2 => ∃ s, s1 = f s ∧ s2 = g s) (f s).destruct (g s).destruct
state_after: no goals