1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Set.neg_smul_set
File: Mathlib/Data/Set/Pointwise/SMul.lean

tactic: simp_rw [← image_smul, ← image_neg, image_image, neg_smul]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : Ring α
inst✝¹ : AddCommGroup β
inst✝ : Module α β
a : α
s : Set α
t : Set β
⊢ -a • t = -(a • t)
state_after: no goals
Theorem: Multiset.map_erase
File: Mathlib/Data/Multiset/Basic.lean

tactic: induction' s using Multiset.induction_on with y s ih
state_before: α : Type u_1
β : Type v
γ : Type u_2
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
f : α → β
hf : Injective f
x : α
s : Multiset α
⊢ map f (s.erase x) = (map f s).erase (f x)
state_after: case empty
α : Type u_1
β : Type v
γ : Type u_2
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
f : α → β
hf : Injective f
x : α
⊢ map f (erase 0 x) = (map f 0).erase (f x)

case cons
α : Type u_1
β : Type v
γ : Type u_2
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
f : α → β
hf : Injective f
x y : α
s : Multiset α
ih : map f (s.erase x) = (map f s).erase (f x)
⊢ map f ((y ::ₘ s).erase x) = (map f (y ::ₘ s)).erase (f x)

tactic: by_cases hxy : y = x
state_before: case cons
α : Type u_1
β : Type v
γ : Type u_2
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
f : α → β
hf : Injective f
x y : α
s : Multiset α
ih : map f (s.erase x) = (map f s).erase (f x)
⊢ map f ((y ::ₘ s).erase x) = (map f (y ::ₘ s)).erase (f x)
state_after: case pos
α : Type u_1
β : Type v
γ : Type u_2
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
f : α → β
hf : Injective f
x y : α
s : Multiset α
ih : map f (s.erase x) = (map f s).erase (f x)
hxy : y = x
⊢ map f ((y ::ₘ s).erase x) = (map f (y ::ₘ s)).erase (f x)

case neg
α : Type u_1
β : Type v
γ : Type u_2
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
f : α → β
hf : Injective f
x y : α
s : Multiset α
ih : map f (s.erase x) = (map f s).erase (f x)
hxy : ¬y = x
⊢ map f ((y ::ₘ s).erase x) = (map f (y ::ₘ s)).erase (f x)

tactic: simp
state_before: case empty
α : Type u_1
β : Type v
γ : Type u_2
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
f : α → β
hf : Injective f
x : α
⊢ map f (erase 0 x) = (map f 0).erase (f x)
state_after: no goals

tactic: cases hxy
state_before: case pos
α : Type u_1
β : Type v
γ : Type u_2
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
f : α → β
hf : Injective f
x y : α
s : Multiset α
ih : map f (s.erase x) = (map f s).erase (f x)
hxy : y = x
⊢ map f ((y ::ₘ s).erase x) = (map f (y ::ₘ s)).erase (f x)
state_after: case pos.refl
α : Type u_1
β : Type v
γ : Type u_2
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
f : α → β
hf : Injective f
x : α
s : Multiset α
ih : map f (s.erase x) = (map f s).erase (f x)
⊢ map f ((x ::ₘ s).erase x) = (map f (x ::ₘ s)).erase (f x)

tactic: simp
state_before: case pos.refl
α : Type u_1
β : Type v
γ : Type u_2
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
f : α → β
hf : Injective f
x : α
s : Multiset α
ih : map f (s.erase x) = (map f s).erase (f x)
⊢ map f ((x ::ₘ s).erase x) = (map f (x ::ₘ s)).erase (f x)
state_after: no goals

tactic: rw [s.erase_cons_tail hxy, map_cons, map_cons, (s.map f).erase_cons_tail (hf.ne hxy), ih]
state_before: case neg
α : Type u_1
β : Type v
γ : Type u_2
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
f : α → β
hf : Injective f
x y : α
s : Multiset α
ih : map f (s.erase x) = (map f s).erase (f x)
hxy : ¬y = x
⊢ map f ((y ::ₘ s).erase x) = (map f (y ::ₘ s)).erase (f x)
state_after: no goals
Theorem: MonoidAlgebra.mul_single_one_apply
File: Mathlib/Algebra/MonoidAlgebra/Basic.lean

tactic: rw [mul_one]
state_before: k : Type u₁
G : Type u₂
H : Type u_1
R : Type u_2
inst✝¹ : Semiring k
inst✝ : MulOneClass G
f : MonoidAlgebra k G
r : k
x a : G
⊢ a * 1 = x ↔ a = x
state_after: no goals
Theorem: Ordnode.Sized.induction
File: Mathlib/Data/Ordmap/Ordset.lean

tactic: induction t with
| nil => exact H0
| node _ _ _ _ t_ih_l t_ih_r =>
  rw [hl.eq_node']
  exact H1 _ _ _ (t_ih_l hl.2.1) (t_ih_r hl.2.2)
state_before: α : Type u_1
t : Ordnode α
hl : t.Sized
C : Ordnode α → Prop
H0 : C nil
H1 : ∀ (l : Ordnode α) (x : α) (r : Ordnode α), C l → C r → C (l.node' x r)
⊢ C t
state_after: no goals

tactic: exact H0
state_before: case nil
α : Type u_1
C : Ordnode α → Prop
H0 : C nil
H1 : ∀ (l : Ordnode α) (x : α) (r : Ordnode α), C l → C r → C (l.node' x r)
hl : nil.Sized
⊢ C nil
state_after: no goals

tactic: rw [hl.eq_node']
state_before: case node
α : Type u_1
C : Ordnode α → Prop
H0 : C nil
H1 : ∀ (l : Ordnode α) (x : α) (r : Ordnode α), C l → C r → C (l.node' x r)
size✝ : ℕ
l✝ : Ordnode α
x✝ : α
r✝ : Ordnode α
t_ih_l : l✝.Sized → C l✝
t_ih_r : r✝.Sized → C r✝
hl : (node size✝ l✝ x✝ r✝).Sized
⊢ C (node size✝ l✝ x✝ r✝)
state_after: case node
α : Type u_1
C : Ordnode α → Prop
H0 : C nil
H1 : ∀ (l : Ordnode α) (x : α) (r : Ordnode α), C l → C r → C (l.node' x r)
size✝ : ℕ
l✝ : Ordnode α
x✝ : α
r✝ : Ordnode α
t_ih_l : l✝.Sized → C l✝
t_ih_r : r✝.Sized → C r✝
hl : (node size✝ l✝ x✝ r✝).Sized
⊢ C (l✝.node' x✝ r✝)

tactic: exact H1 _ _ _ (t_ih_l hl.2.1) (t_ih_r hl.2.2)
state_before: case node
α : Type u_1
C : Ordnode α → Prop
H0 : C nil
H1 : ∀ (l : Ordnode α) (x : α) (r : Ordnode α), C l → C r → C (l.node' x r)
size✝ : ℕ
l✝ : Ordnode α
x✝ : α
r✝ : Ordnode α
t_ih_l : l✝.Sized → C l✝
t_ih_r : r✝.Sized → C r✝
hl : (node size✝ l✝ x✝ r✝).Sized
⊢ C (l✝.node' x✝ r✝)
state_after: no goals
Theorem: multiplicity.get_one_right
File: Mathlib/RingTheory/Multiplicity.lean

tactic: rw [PartENat.get_eq_iff_eq_coe, eq_coe_iff, _root_.pow_zero]
state_before: α : Type u_1
β : Type u_2
inst✝³ : Monoid α
inst✝² : Monoid β
inst✝¹ : DecidableRel fun x x_1 => x ∣ x_1
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
a : α
ha : Finite a 1
⊢ (multiplicity a 1).get ha = 0
state_after: α : Type u_1
β : Type u_2
inst✝³ : Monoid α
inst✝² : Monoid β
inst✝¹ : DecidableRel fun x x_1 => x ∣ x_1
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
a : α
ha : Finite a 1
⊢ 1 ∣ 1 ∧ ¬a ^ (0 + 1) ∣ 1

tactic: simp [not_dvd_one_of_finite_one_right ha]
state_before: α : Type u_1
β : Type u_2
inst✝³ : Monoid α
inst✝² : Monoid β
inst✝¹ : DecidableRel fun x x_1 => x ∣ x_1
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
a : α
ha : Finite a 1
⊢ 1 ∣ 1 ∧ ¬a ^ (0 + 1) ∣ 1
state_after: no goals
Theorem: MeasureTheory.le_extend
File: Mathlib/MeasureTheory/OuterMeasure/Induced.lean

tactic: simp only [extend, le_iInf_iff]
state_before: α : Type u_1
P : α → Prop
m : (s : α) → P s → ℝ≥0∞
s : α
h : P s
⊢ m s h ≤ extend m s
state_after: α : Type u_1
P : α → Prop
m : (s : α) → P s → ℝ≥0∞
s : α
h : P s
⊢ ∀ (i : P s), m s h ≤ m s i

tactic: intro
state_before: α : Type u_1
P : α → Prop
m : (s : α) → P s → ℝ≥0∞
s : α
h : P s
⊢ ∀ (i : P s), m s h ≤ m s i
state_after: α : Type u_1
P : α → Prop
m : (s : α) → P s → ℝ≥0∞
s : α
h i✝ : P s
⊢ m s h ≤ m s i✝

tactic: rfl
state_before: α : Type u_1
P : α → Prop
m : (s : α) → P s → ℝ≥0∞
s : α
h i✝ : P s
⊢ m s h ≤ m s i✝
state_after: no goals
Theorem: LinearMap.stdBasis_apply'
File: Mathlib/LinearAlgebra/StdBasis.lean

tactic: rw [LinearMap.stdBasis_apply, Function.update_apply, Pi.zero_apply]
state_before: R : Type u_1
ι : Type u_2
inst✝³ : Semiring R
φ : ι → Type u_3
inst✝² : (i : ι) → AddCommMonoid (φ i)
inst✝¹ : (i : ι) → Module R (φ i)
inst✝ : DecidableEq ι
i i' : ι
⊢ (stdBasis R (fun _x => R) i) 1 i' = if i = i' then 1 else 0
state_after: R : Type u_1
ι : Type u_2
inst✝³ : Semiring R
φ : ι → Type u_3
inst✝² : (i : ι) → AddCommMonoid (φ i)
inst✝¹ : (i : ι) → Module R (φ i)
inst✝ : DecidableEq ι
i i' : ι
⊢ (if i' = i then 1 else 0) = if i = i' then 1 else 0

tactic: congr 1
state_before: R : Type u_1
ι : Type u_2
inst✝³ : Semiring R
φ : ι → Type u_3
inst✝² : (i : ι) → AddCommMonoid (φ i)
inst✝¹ : (i : ι) → Module R (φ i)
inst✝ : DecidableEq ι
i i' : ι
⊢ (if i' = i then 1 else 0) = if i = i' then 1 else 0
state_after: case e_c
R : Type u_1
ι : Type u_2
inst✝³ : Semiring R
φ : ι → Type u_3
inst✝² : (i : ι) → AddCommMonoid (φ i)
inst✝¹ : (i : ι) → Module R (φ i)
inst✝ : DecidableEq ι
i i' : ι
⊢ (i' = i) = (i = i')

tactic: rw [eq_iff_iff, eq_comm]
state_before: case e_c
R : Type u_1
ι : Type u_2
inst✝³ : Semiring R
φ : ι → Type u_3
inst✝² : (i : ι) → AddCommMonoid (φ i)
inst✝¹ : (i : ι) → Module R (φ i)
inst✝ : DecidableEq ι
i i' : ι
⊢ (i' = i) = (i = i')
state_after: no goals
Theorem: eVariationOn.lowerSemicontinuous
File: Mathlib/Analysis/BoundedVariation.lean

tactic: apply @lowerSemicontinuous_aux _ _ _ _ (UniformOnFun α E (s.image singleton)) id (𝓝 f) f s _
state_before: α : Type u_1
inst✝¹ : LinearOrder α
E : Type u_2
inst✝ : PseudoEMetricSpace E
s : Set α
f : α →ᵤ[singleton '' s] E
⊢ LowerSemicontinuousAt (fun f => eVariationOn f s) f
state_after: α : Type u_1
inst✝¹ : LinearOrder α
E : Type u_2
inst✝ : PseudoEMetricSpace E
s : Set α
f : α →ᵤ[singleton '' s] E
⊢ ∀ x ∈ s, Tendsto (fun i => id i x) (𝓝 f) (𝓝 (f x))

tactic: simpa only [UniformOnFun.tendsto_iff_tendstoUniformlyOn, mem_image, forall_exists_index, and_imp,
  forall_apply_eq_imp_iff₂, tendstoUniformlyOn_singleton_iff_tendsto] using @tendsto_id _ (𝓝 f)
state_before: α : Type u_1
inst✝¹ : LinearOrder α
E : Type u_2
inst✝ : PseudoEMetricSpace E
s : Set α
f : α →ᵤ[singleton '' s] E
⊢ ∀ x ∈ s, Tendsto (fun i => id i x) (𝓝 f) (𝓝 (f x))
state_after: no goals
Theorem: List.foldl_hom
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

tactic: induction l generalizing init <;> simp [*, H]
state_before: α₁ : Type u_1
α₂ : Type u_2
β : Type u_3
f : α₁ → α₂
g₁ : α₁ → β → α₁
g₂ : α₂ → β → α₂
l : List β
init : α₁
H : ∀ (x : α₁) (y : β), g₂ (f x) y = f (g₁ x y)
⊢ foldl g₂ (f init) l = f (foldl g₁ init l)
state_after: no goals
Theorem: PointedCone.mem_dual
File: Mathlib/Analysis/Convex/Cone/Pointed.lean

tactic: rfl
state_before: 𝕜 : Type u_1
E✝ : Type u_2
F : Type u_3
G : Type u_4
E : Type u_5
inst✝¹ : NormedAddCommGroup E
inst✝ : InnerProductSpace ℝ E
S : PointedCone ℝ E
y : E
⊢ y ∈ S.dual ↔ ∀ ⦃x : E⦄, x ∈ S → 0 ≤ ⟪x, y⟫_ℝ
state_after: no goals
Theorem: Set.image_prod_mk_subset_prod_right
File: Mathlib/Data/Set/Prod.lean

tactic: rintro _ ⟨b, hb, 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 : β
ha : a ∈ s
⊢ Prod.mk a '' t ⊆ s ×ˢ t
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✝ : β
ha : a ∈ s
b : β
hb : b ∈ t
⊢ (a, b) ∈ s ×ˢ t

tactic: exact ⟨ha, hb⟩
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✝ : β
ha : a ∈ s
b : β
hb : b ∈ t
⊢ (a, b) ∈ s ×ˢ t
state_after: no goals
Theorem: smul_nonpos_iff
File: Mathlib/Algebra/Order/Module/Defs.lean

tactic: rw [← neg_nonneg, ← smul_neg, smul_nonneg_iff, neg_nonneg, neg_nonpos]
state_before: α : Type u_1
β : Type u_2
a✝ a₁ a₂ : α
b✝ b₁ b₂ : β
inst✝³ : LinearOrderedRing α
inst✝² : LinearOrderedAddCommGroup β
inst✝¹ : Module α β
inst✝ : PosSMulStrictMono α β
a : α
b : β
⊢ a • b ≤ 0 ↔ 0 ≤ a ∧ b ≤ 0 ∨ a ≤ 0 ∧ 0 ≤ b
state_after: no goals
Theorem: ProbabilityTheory.kernel.sum_comm
File: Mathlib/Probability/Kernel/Basic.lean

tactic: ext a s
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ✝ : ↥(kernel α β)
inst✝ : Countable ι
κ : ι → ι → ↥(kernel α β)
⊢ (kernel.sum fun n => kernel.sum (κ n)) = kernel.sum fun m => kernel.sum fun n => κ n m
state_after: case h.h
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ✝ : ↥(kernel α β)
inst✝ : Countable ι
κ : ι → ι → ↥(kernel α β)
a : α
s : Set β
a✝ : MeasurableSet s
⊢ ((kernel.sum fun n => kernel.sum (κ n)) a) s = ((kernel.sum fun m => kernel.sum fun n => κ n m) a) s

tactic: simp_rw [sum_apply]
state_before: case h.h
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ✝ : ↥(kernel α β)
inst✝ : Countable ι
κ : ι → ι → ↥(kernel α β)
a : α
s : Set β
a✝ : MeasurableSet s
⊢ ((kernel.sum fun n => kernel.sum (κ n)) a) s = ((kernel.sum fun m => kernel.sum fun n => κ n m) a) s
state_after: case h.h
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ✝ : ↥(kernel α β)
inst✝ : Countable ι
κ : ι → ι → ↥(kernel α β)
a : α
s : Set β
a✝ : MeasurableSet s
⊢ (Measure.sum fun n => Measure.sum fun n_1 => (κ n n_1) a) s =
    (Measure.sum fun n => Measure.sum fun n_1 => (κ n_1 n) a) s

tactic: rw [Measure.sum_comm]
state_before: case h.h
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ✝ : ↥(kernel α β)
inst✝ : Countable ι
κ : ι → ι → ↥(kernel α β)
a : α
s : Set β
a✝ : MeasurableSet s
⊢ (Measure.sum fun n => Measure.sum fun n_1 => (κ n n_1) a) s =
    (Measure.sum fun n => Measure.sum fun n_1 => (κ n_1 n) a) s
state_after: no goals
Theorem: integral_sin
File: Mathlib/Analysis/SpecialFunctions/Integrals.lean

tactic: rw [integral_deriv_eq_sub' fun x => -cos x]
state_before: a b : ℝ
n : ℕ
⊢ ∫ (x : ℝ) in a..b, sin x = cos a - cos b
state_after: a b : ℝ
n : ℕ
⊢ -cos b - -cos a = cos a - cos b

case hderiv
a b : ℝ
n : ℕ
⊢ (deriv fun x => -cos x) = sin

case hdiff
a b : ℝ
n : ℕ
⊢ ∀ x ∈ [[a, b]], DifferentiableAt ℝ (fun x => -cos x) x

case hcont
a b : ℝ
n : ℕ
⊢ ContinuousOn sin [[a, b]]

tactic: ring
state_before: a b : ℝ
n : ℕ
⊢ -cos b - -cos a = cos a - cos b
state_after: no goals

tactic: norm_num
state_before: case hderiv
a b : ℝ
n : ℕ
⊢ (deriv fun x => -cos x) = sin
state_after: no goals

tactic: simp only [differentiableAt_neg_iff, differentiableAt_cos, implies_true]
state_before: case hdiff
a b : ℝ
n : ℕ
⊢ ∀ x ∈ [[a, b]], DifferentiableAt ℝ (fun x => -cos x) x
state_after: no goals

tactic: exact continuousOn_sin
state_before: case hcont
a b : ℝ
n : ℕ
⊢ ContinuousOn sin [[a, b]]
state_after: no goals
Theorem: MeasureTheory.SimpleFunc.lintegral_restrict
File: Mathlib/MeasureTheory/Function/SimpleFunc.lean

tactic: simp only [lintegral, Measure.restrict_apply, f.measurableSet_preimage]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m✝ : MeasurableSpace α
μ✝ ν : Measure α
m : MeasurableSpace α
f : α →ₛ ℝ≥0∞
s : Set α
μ : Measure α
⊢ f.lintegral (μ.restrict s) = ∑ y ∈ f.range, y * μ (↑f ⁻¹' {y} ∩ s)
state_after: no goals
Theorem: AkraBazziRecurrence.isLittleO_deriv_one_add_smoothingFn
File: Mathlib/Computability/AkraBazzi/AkraBazzi.lean

tactic: filter_upwards [eventually_gt_atTop 1] with x hx
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : Nonempty α
T : ℕ → ℝ
g : ℝ → ℝ
a b : α → ℝ
r : α → ℕ → ℕ
R : AkraBazziRecurrence T g a b r
⊢ (deriv fun x => 1 + ε x) =ᶠ[atTop] fun z => deriv ε z
state_after: case h
α : Type u_1
inst✝¹ : Fintype α
inst✝ : Nonempty α
T : ℕ → ℝ
g : ℝ → ℝ
a b : α → ℝ
r : α → ℕ → ℕ
R : AkraBazziRecurrence T g a b r
x : ℝ
hx : 1 < x
⊢ deriv (fun x => 1 + ε x) x = deriv ε x

tactic: rw [deriv_add] <;> aesop
state_before: case h
α : Type u_1
inst✝¹ : Fintype α
inst✝ : Nonempty α
T : ℕ → ℝ
g : ℝ → ℝ
a b : α → ℝ
r : α → ℕ → ℕ
R : AkraBazziRecurrence T g a b r
x : ℝ
hx : 1 < x
⊢ deriv (fun x => 1 + ε x) x = deriv ε x
state_after: no goals
Theorem: Matrix.PosDef.posSemidef_add
File: Mathlib/LinearAlgebra/Matrix/PosDef.lean

tactic: rw [add_mulVec, dotProduct_add]
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 𝕜
A B : Matrix m m R
hA : A.PosSemidef
hB : B.PosDef
x : m → R
hx : x ≠ 0
⊢ 0 < star x ⬝ᵥ (A + B) *ᵥ x
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 𝕜
A B : Matrix m m R
hA : A.PosSemidef
hB : B.PosDef
x : m → R
hx : x ≠ 0
⊢ 0 < star x ⬝ᵥ A *ᵥ x + star x ⬝ᵥ B *ᵥ x

tactic: exact add_pos_of_nonneg_of_pos (hA.2 x) (hB.2 x hx)
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 𝕜
A B : Matrix m m R
hA : A.PosSemidef
hB : B.PosDef
x : m → R
hx : x ≠ 0
⊢ 0 < star x ⬝ᵥ A *ᵥ x + star x ⬝ᵥ B *ᵥ x
state_after: no goals
Theorem: List.Lex.cons_iff
File: Mathlib/Data/List/Lex.lean

tactic: cases' h with _ _ _ _ _ h _ _ _ _ h
state_before: α : Type u
r : α → α → Prop
inst✝ : IsIrrefl α r
a : α
l₁ l₂ : List α
h : Lex r (a :: l₁) (a :: l₂)
⊢ Lex r l₁ l₂
state_after: case cons
α : Type u
r : α → α → Prop
inst✝ : IsIrrefl α r
a : α
l₁ l₂ : List α
h : Lex r l₁ l₂
⊢ Lex r l₁ l₂

case rel
α : Type u
r : α → α → Prop
inst✝ : IsIrrefl α r
a : α
l₁ l₂ : List α
h : r a a
⊢ Lex r l₁ l₂

tactic: exacts [h, (irrefl_of r a h).elim]
state_before: case cons
α : Type u
r : α → α → Prop
inst✝ : IsIrrefl α r
a : α
l₁ l₂ : List α
h : Lex r l₁ l₂
⊢ Lex r l₁ l₂

case rel
α : Type u
r : α → α → Prop
inst✝ : IsIrrefl α r
a : α
l₁ l₂ : List α
h : r a a
⊢ Lex r l₁ l₂
state_after: no goals
Theorem: Finset.map_add_left_Ioc
File: Mathlib/Algebra/Order/Interval/Finset.lean

tactic: rw [← coe_inj, coe_map, coe_Ioc, coe_Ioc]
state_before: ι : Type u_1
α : Type u_2
inst✝² : OrderedCancelAddCommMonoid α
inst✝¹ : ExistsAddOfLE α
inst✝ : LocallyFiniteOrder α
a b c : α
⊢ map (addLeftEmbedding c) (Ioc a b) = Ioc (c + a) (c + b)
state_after: ι : Type u_1
α : Type u_2
inst✝² : OrderedCancelAddCommMonoid α
inst✝¹ : ExistsAddOfLE α
inst✝ : LocallyFiniteOrder α
a b c : α
⊢ ⇑(addLeftEmbedding c) '' Set.Ioc a b = Set.Ioc (c + a) (c + b)

tactic: exact Set.image_const_add_Ioc _ _ _
state_before: ι : Type u_1
α : Type u_2
inst✝² : OrderedCancelAddCommMonoid α
inst✝¹ : ExistsAddOfLE α
inst✝ : LocallyFiniteOrder α
a b c : α
⊢ ⇑(addLeftEmbedding c) '' Set.Ioc a b = Set.Ioc (c + a) (c + b)
state_after: no goals
Theorem: MeasureTheory.supermartingale_nat
File: Mathlib/Probability/Martingale/Basic.lean

tactic: rw [← neg_neg f]
state_before: Ω : Type u_1
E : Type u_2
ι : Type u_3
inst✝⁴ : Preorder ι
m0 : MeasurableSpace Ω
μ : Measure Ω
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : CompleteSpace E
f✝ g : ι → Ω → E
ℱ : Filtration ι m0
𝒢 : Filtration ℕ m0
inst✝ : IsFiniteMeasure μ
f : ℕ → Ω → ℝ
hadp : Adapted 𝒢 f
hint : ∀ (i : ℕ), Integrable (f i) μ
hf : ∀ (i : ℕ), μ[f (i + 1)|↑𝒢 i] ≤ᶠ[ae μ] f i
⊢ Supermartingale f 𝒢 μ
state_after: Ω : Type u_1
E : Type u_2
ι : Type u_3
inst✝⁴ : Preorder ι
m0 : MeasurableSpace Ω
μ : Measure Ω
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : CompleteSpace E
f✝ g : ι → Ω → E
ℱ : Filtration ι m0
𝒢 : Filtration ℕ m0
inst✝ : IsFiniteMeasure μ
f : ℕ → Ω → ℝ
hadp : Adapted 𝒢 f
hint : ∀ (i : ℕ), Integrable (f i) μ
hf : ∀ (i : ℕ), μ[f (i + 1)|↑𝒢 i] ≤ᶠ[ae μ] f i
⊢ Supermartingale (- -f) 𝒢 μ

tactic: refine (submartingale_nat hadp.neg (fun i => (hint i).neg) fun i =>
  EventuallyLE.trans ?_ (condexp_neg _).symm.le).neg
state_before: Ω : Type u_1
E : Type u_2
ι : Type u_3
inst✝⁴ : Preorder ι
m0 : MeasurableSpace Ω
μ : Measure Ω
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : CompleteSpace E
f✝ g : ι → Ω → E
ℱ : Filtration ι m0
𝒢 : Filtration ℕ m0
inst✝ : IsFiniteMeasure μ
f : ℕ → Ω → ℝ
hadp : Adapted 𝒢 f
hint : ∀ (i : ℕ), Integrable (f i) μ
hf : ∀ (i : ℕ), μ[f (i + 1)|↑𝒢 i] ≤ᶠ[ae μ] f i
⊢ Supermartingale (- -f) 𝒢 μ
state_after: Ω : Type u_1
E : Type u_2
ι : Type u_3
inst✝⁴ : Preorder ι
m0 : MeasurableSpace Ω
μ : Measure Ω
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : CompleteSpace E
f✝ g : ι → Ω → E
ℱ : Filtration ι m0
𝒢 : Filtration ℕ m0
inst✝ : IsFiniteMeasure μ
f : ℕ → Ω → ℝ
hadp : Adapted 𝒢 f
hint : ∀ (i : ℕ), Integrable (f i) μ
hf : ∀ (i : ℕ), μ[f (i + 1)|↑𝒢 i] ≤ᶠ[ae μ] f i
i : ℕ
⊢ (-f) i ≤ᶠ[ae μ] -μ[f (i + 1)|↑𝒢 i]

tactic: filter_upwards [hf i] with x hx using neg_le_neg hx
state_before: Ω : Type u_1
E : Type u_2
ι : Type u_3
inst✝⁴ : Preorder ι
m0 : MeasurableSpace Ω
μ : Measure Ω
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : CompleteSpace E
f✝ g : ι → Ω → E
ℱ : Filtration ι m0
𝒢 : Filtration ℕ m0
inst✝ : IsFiniteMeasure μ
f : ℕ → Ω → ℝ
hadp : Adapted 𝒢 f
hint : ∀ (i : ℕ), Integrable (f i) μ
hf : ∀ (i : ℕ), μ[f (i + 1)|↑𝒢 i] ≤ᶠ[ae μ] f i
i : ℕ
⊢ (-f) i ≤ᶠ[ae μ] -μ[f (i + 1)|↑𝒢 i]
state_after: no goals
Theorem: ascPochhammer_one
File: Mathlib/RingTheory/Polynomial/Pochhammer.lean

tactic: simp [ascPochhammer]
state_before: S : Type u
inst✝ : Semiring S
⊢ ascPochhammer S 1 = X
state_after: no goals
Theorem: ZMod.natCast_comp_val
File: Mathlib/Data/ZMod/Basic.lean

tactic: cases n
state_before: n : ℕ
R : Type u_1
inst✝¹ : Ring R
inst✝ : NeZero n
⊢ Nat.cast ∘ val = cast
state_after: case zero
R : Type u_1
inst✝¹ : Ring R
inst✝ : NeZero 0
⊢ Nat.cast ∘ val = cast

case succ
R : Type u_1
inst✝¹ : Ring R
n✝ : ℕ
inst✝ : NeZero (n✝ + 1)
⊢ Nat.cast ∘ val = cast

tactic: rfl
state_before: case succ
R : Type u_1
inst✝¹ : Ring R
n✝ : ℕ
inst✝ : NeZero (n✝ + 1)
⊢ Nat.cast ∘ val = cast
state_after: no goals

tactic: cases NeZero.ne 0 rfl
state_before: case zero
R : Type u_1
inst✝¹ : Ring R
inst✝ : NeZero 0
⊢ Nat.cast ∘ val = cast
state_after: no goals
Theorem: CategoryTheory.ComposableArrows.hom_ext_succ
File: Mathlib/CategoryTheory/ComposableArrows.lean

tactic: ext ⟨i, hi⟩
state_before: C : Type u_1
inst✝ : Category.{u_2, u_1} C
n m : ℕ
F✝ G✝ : ComposableArrows C n
F G : ComposableArrows C (n + 1)
f g : F ⟶ G
h₀ : app' f 0 ⋯ = app' g 0 ⋯
h₁ : δ₀Functor.map f = δ₀Functor.map g
⊢ f = g
state_after: case w.h.mk
C : Type u_1
inst✝ : Category.{u_2, u_1} C
n m : ℕ
F✝ G✝ : ComposableArrows C n
F G : ComposableArrows C (n + 1)
f g : F ⟶ G
h₀ : app' f 0 ⋯ = app' g 0 ⋯
h₁ : δ₀Functor.map f = δ₀Functor.map g
i : ℕ
hi : i < n + 1 + 1
⊢ f.app ⟨i, hi⟩ = g.app ⟨i, hi⟩

tactic: obtain _ | i := i
state_before: case w.h.mk
C : Type u_1
inst✝ : Category.{u_2, u_1} C
n m : ℕ
F✝ G✝ : ComposableArrows C n
F G : ComposableArrows C (n + 1)
f g : F ⟶ G
h₀ : app' f 0 ⋯ = app' g 0 ⋯
h₁ : δ₀Functor.map f = δ₀Functor.map g
i : ℕ
hi : i < n + 1 + 1
⊢ f.app ⟨i, hi⟩ = g.app ⟨i, hi⟩
state_after: case w.h.mk.zero
C : Type u_1
inst✝ : Category.{u_2, u_1} C
n m : ℕ
F✝ G✝ : ComposableArrows C n
F G : ComposableArrows C (n + 1)
f g : F ⟶ G
h₀ : app' f 0 ⋯ = app' g 0 ⋯
h₁ : δ₀Functor.map f = δ₀Functor.map g
hi : 0 < n + 1 + 1
⊢ f.app ⟨0, hi⟩ = g.app ⟨0, hi⟩

case w.h.mk.succ
C : Type u_1
inst✝ : Category.{u_2, u_1} C
n m : ℕ
F✝ G✝ : ComposableArrows C n
F G : ComposableArrows C (n + 1)
f g : F ⟶ G
h₀ : app' f 0 ⋯ = app' g 0 ⋯
h₁ : δ₀Functor.map f = δ₀Functor.map g
i : ℕ
hi : i + 1 < n + 1 + 1
⊢ f.app ⟨i + 1, hi⟩ = g.app ⟨i + 1, hi⟩

tactic: exact h₀
state_before: case w.h.mk.zero
C : Type u_1
inst✝ : Category.{u_2, u_1} C
n m : ℕ
F✝ G✝ : ComposableArrows C n
F G : ComposableArrows C (n + 1)
f g : F ⟶ G
h₀ : app' f 0 ⋯ = app' g 0 ⋯
h₁ : δ₀Functor.map f = δ₀Functor.map g
hi : 0 < n + 1 + 1
⊢ f.app ⟨0, hi⟩ = g.app ⟨0, hi⟩
state_after: no goals

tactic: exact congr_app h₁ ⟨i, by valid⟩
state_before: case w.h.mk.succ
C : Type u_1
inst✝ : Category.{u_2, u_1} C
n m : ℕ
F✝ G✝ : ComposableArrows C n
F G : ComposableArrows C (n + 1)
f g : F ⟶ G
h₀ : app' f 0 ⋯ = app' g 0 ⋯
h₁ : δ₀Functor.map f = δ₀Functor.map g
i : ℕ
hi : i + 1 < n + 1 + 1
⊢ f.app ⟨i + 1, hi⟩ = g.app ⟨i + 1, hi⟩
state_after: no goals

tactic: valid
state_before: C : Type u_1
inst✝ : Category.{u_2, u_1} C
n m : ℕ
F✝ G✝ : ComposableArrows C n
F G : ComposableArrows C (n + 1)
f g : F ⟶ G
h₀ : app' f 0 ⋯ = app' g 0 ⋯
h₁ : δ₀Functor.map f = δ₀Functor.map g
i : ℕ
hi : i + 1 < n + 1 + 1
⊢ i < n + 1
state_after: no goals
Theorem: Rat.exists
File: Mathlib/Data/Rat/Lemmas.lean

tactic: convert hr
state_before: p : ℚ → Prop
x✝ : ∃ r, p r
r : ℚ
hr : p r
⊢ p (↑r.num / ↑↑r.den)
state_after: case h.e'_1
p : ℚ → Prop
x✝ : ∃ r, p r
r : ℚ
hr : p r
⊢ ↑r.num / ↑↑r.den = r

tactic: convert num_div_den r
state_before: case h.e'_1
p : ℚ → Prop
x✝ : ∃ r, p r
r : ℚ
hr : p r
⊢ ↑r.num / ↑↑r.den = r
state_after: no goals