1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: MeasureTheory.Submartingale.sum_sub_upcrossingStrat_mul
File: Mathlib/Probability/Martingale/Upcrossing.lean

tactic: refine hf.sum_mul_sub (fun n => (adapted_const ℱ 1 n).sub (hf.adapted.upcrossingStrat_adapted n))
  (?_ : ∀ n ω, (1 - upcrossingStrat a b f N n) ω ≤ 1) ?_
state_before: Ω : Type u_1
ι : Type u_2
m0 : MeasurableSpace Ω
μ : Measure Ω
a✝ b✝ : ℝ
f : ℕ → Ω → ℝ
N✝ n m : ℕ
ω : Ω
ℱ : Filtration ℕ m0
inst✝ : IsFiniteMeasure μ
hf : Submartingale f ℱ μ
a b : ℝ
N : ℕ
⊢ Submartingale (fun n => ∑ k ∈ Finset.range n, (1 - upcrossingStrat a b f N k) * (f (k + 1) - f k)) ℱ μ
state_after: case refine_1
Ω : Type u_1
ι : Type u_2
m0 : MeasurableSpace Ω
μ : Measure Ω
a✝ b✝ : ℝ
f : ℕ → Ω → ℝ
N✝ n m : ℕ
ω : Ω
ℱ : Filtration ℕ m0
inst✝ : IsFiniteMeasure μ
hf : Submartingale f ℱ μ
a b : ℝ
N : ℕ
⊢ ∀ (n : ℕ) (ω : Ω), (1 - upcrossingStrat a b f N n) ω ≤ 1

case refine_2
Ω : Type u_1
ι : Type u_2
m0 : MeasurableSpace Ω
μ : Measure Ω
a✝ b✝ : ℝ
f : ℕ → Ω → ℝ
N✝ n m : ℕ
ω : Ω
ℱ : Filtration ℕ m0
inst✝ : IsFiniteMeasure μ
hf : Submartingale f ℱ μ
a b : ℝ
N : ℕ
⊢ ∀ (n : ℕ) (ω : Ω), 0 ≤ (1 - upcrossingStrat a b f N n) ω

tactic: exact fun n ω => sub_le_self _ upcrossingStrat_nonneg
state_before: case refine_1
Ω : Type u_1
ι : Type u_2
m0 : MeasurableSpace Ω
μ : Measure Ω
a✝ b✝ : ℝ
f : ℕ → Ω → ℝ
N✝ n m : ℕ
ω : Ω
ℱ : Filtration ℕ m0
inst✝ : IsFiniteMeasure μ
hf : Submartingale f ℱ μ
a b : ℝ
N : ℕ
⊢ ∀ (n : ℕ) (ω : Ω), (1 - upcrossingStrat a b f N n) ω ≤ 1
state_after: no goals

tactic: intro n ω
state_before: case refine_2
Ω : Type u_1
ι : Type u_2
m0 : MeasurableSpace Ω
μ : Measure Ω
a✝ b✝ : ℝ
f : ℕ → Ω → ℝ
N✝ n m : ℕ
ω : Ω
ℱ : Filtration ℕ m0
inst✝ : IsFiniteMeasure μ
hf : Submartingale f ℱ μ
a b : ℝ
N : ℕ
⊢ ∀ (n : ℕ) (ω : Ω), 0 ≤ (1 - upcrossingStrat a b f N n) ω
state_after: case refine_2
Ω : Type u_1
ι : Type u_2
m0 : MeasurableSpace Ω
μ : Measure Ω
a✝ b✝ : ℝ
f : ℕ → Ω → ℝ
N✝ n✝ m : ℕ
ω✝ : Ω
ℱ : Filtration ℕ m0
inst✝ : IsFiniteMeasure μ
hf : Submartingale f ℱ μ
a b : ℝ
N n : ℕ
ω : Ω
⊢ 0 ≤ (1 - upcrossingStrat a b f N n) ω

tactic: simp [upcrossingStrat_le_one]
state_before: case refine_2
Ω : Type u_1
ι : Type u_2
m0 : MeasurableSpace Ω
μ : Measure Ω
a✝ b✝ : ℝ
f : ℕ → Ω → ℝ
N✝ n✝ m : ℕ
ω✝ : Ω
ℱ : Filtration ℕ m0
inst✝ : IsFiniteMeasure μ
hf : Submartingale f ℱ μ
a b : ℝ
N n : ℕ
ω : Ω
⊢ 0 ≤ (1 - upcrossingStrat a b f N n) ω
state_after: no goals
Theorem: Complex.differentiable_Gammaℝ_inv
File: Mathlib/Analysis/SpecialFunctions/Gamma/Deligne.lean

tactic: conv => enter [2, s]; rw [Gammaℝ, mul_inv]
state_before: ⊢ Differentiable ℂ fun s => s.Gammaℝ⁻¹
state_after: ⊢ Differentiable ℂ fun s => (↑π ^ (-s / 2))⁻¹ * (Gamma (s / 2))⁻¹

tactic: refine Differentiable.mul (fun s ↦ .inv ?_ (by simp [pi_ne_zero])) ?_
state_before: ⊢ Differentiable ℂ fun s => (↑π ^ (-s / 2))⁻¹ * (Gamma (s / 2))⁻¹
state_after: case refine_1
s : ℂ
⊢ DifferentiableAt ℂ (fun s => ↑π ^ (-s / 2)) s

case refine_2

⊢ Differentiable ℂ fun s => (Gamma (s / 2))⁻¹

tactic: simp [pi_ne_zero]
state_before: s : ℂ
⊢ ↑π ^ (-s / 2) ≠ 0
state_after: no goals

tactic: refine ((differentiableAt_id.neg.div_const (2 : ℂ)).const_cpow ?_)
state_before: case refine_1
s : ℂ
⊢ DifferentiableAt ℂ (fun s => ↑π ^ (-s / 2)) s
state_after: case refine_1
s : ℂ
⊢ ↑π ≠ 0 ∨ -s / 2 ≠ 0

tactic: exact Or.inl (ofReal_ne_zero.mpr pi_ne_zero)
state_before: case refine_1
s : ℂ
⊢ ↑π ≠ 0 ∨ -s / 2 ≠ 0
state_after: no goals

tactic: exact differentiable_one_div_Gamma.comp (differentiable_id.div_const _)
state_before: case refine_2

⊢ Differentiable ℂ fun s => (Gamma (s / 2))⁻¹
state_after: no goals
Theorem: Set.Icc_union_Ici'
File: Mathlib/Order/Interval/Set/Basic.lean

tactic: ext1 x
state_before: α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
h₁ : c ≤ b
⊢ Icc a b ∪ Ici c = Ici (min a c)
state_after: case h
α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
h₁ : c ≤ b
x : α
⊢ x ∈ Icc a b ∪ Ici c ↔ x ∈ Ici (min a c)

tactic: simp_rw [mem_union, mem_Icc, mem_Ici, min_le_iff]
state_before: case h
α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
h₁ : c ≤ b
x : α
⊢ x ∈ Icc a b ∪ Ici c ↔ x ∈ Ici (min a c)
state_after: case h
α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
h₁ : c ≤ b
x : α
⊢ a ≤ x ∧ x ≤ b ∨ c ≤ x ↔ a ≤ x ∨ c ≤ x

tactic: by_cases hc : c ≤ x
state_before: case h
α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
h₁ : c ≤ b
x : α
⊢ a ≤ x ∧ x ≤ b ∨ c ≤ x ↔ a ≤ x ∨ c ≤ x
state_after: case pos
α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
h₁ : c ≤ b
x : α
hc : c ≤ x
⊢ a ≤ x ∧ x ≤ b ∨ c ≤ x ↔ a ≤ x ∨ c ≤ x

case neg
α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
h₁ : c ≤ b
x : α
hc : ¬c ≤ x
⊢ a ≤ x ∧ x ≤ b ∨ c ≤ x ↔ a ≤ x ∨ c ≤ x

tactic: simp only [hc, or_true]
state_before: case pos
α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
h₁ : c ≤ b
x : α
hc : c ≤ x
⊢ a ≤ x ∧ x ≤ b ∨ c ≤ x ↔ a ≤ x ∨ c ≤ x
state_after: no goals

tactic: have hxb : x ≤ b := (le_of_not_ge hc).trans h₁
state_before: case neg
α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
h₁ : c ≤ b
x : α
hc : ¬c ≤ x
⊢ a ≤ x ∧ x ≤ b ∨ c ≤ x ↔ a ≤ x ∨ c ≤ x
state_after: case neg
α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
h₁ : c ≤ b
x : α
hc : ¬c ≤ x
hxb : x ≤ b
⊢ a ≤ x ∧ x ≤ b ∨ c ≤ x ↔ a ≤ x ∨ c ≤ x

tactic: simp only [hxb, and_true]
state_before: case neg
α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
h₁ : c ≤ b
x : α
hc : ¬c ≤ x
hxb : x ≤ b
⊢ a ≤ x ∧ x ≤ b ∨ c ≤ x ↔ a ≤ x ∨ c ≤ x
state_after: no goals
Theorem: IsRelPrime.pow_right
File: Mathlib/RingTheory/Coprime/Lemmas.lean

tactic: rw [← Finset.card_range n, ← Finset.prod_const]
state_before: α : Type u_1
I : Type ?u.59381
inst✝¹ : CommMonoid α
inst✝ : DecompositionMonoid α
x y z : α
s : I → α
t : Finset I
m n : ℕ
H : IsRelPrime x y
⊢ IsRelPrime x (y ^ n)
state_after: α : Type u_1
I : Type ?u.59381
inst✝¹ : CommMonoid α
inst✝ : DecompositionMonoid α
x y z : α
s : I → α
t : Finset I
m n : ℕ
H : IsRelPrime x y
⊢ IsRelPrime x (∏ _x ∈ Finset.range n, y)

tactic: exact IsRelPrime.prod_right fun _ _ ↦ H
state_before: α : Type u_1
I : Type ?u.59381
inst✝¹ : CommMonoid α
inst✝ : DecompositionMonoid α
x y z : α
s : I → α
t : Finset I
m n : ℕ
H : IsRelPrime x y
⊢ IsRelPrime x (∏ _x ∈ Finset.range n, y)
state_after: no goals
Theorem: intervalIntegral.integral_eq_zero_iff_of_nonneg_ae
File: Mathlib/MeasureTheory/Integral/IntervalIntegral.lean

tactic: rcases le_total a b with hab | hab <;>
  simp only [Ioc_eq_empty hab.not_lt, empty_union, union_empty] at hf ⊢
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
f g : ℝ → ℝ
a b : ℝ
μ : Measure ℝ
hf : 0 ≤ᶠ[ae (μ.restrict (Ioc a b ∪ Ioc b a))] f
hfi : IntervalIntegrable f μ a b
⊢ ∫ (x : ℝ) in a..b, f x ∂μ = 0 ↔ f =ᶠ[ae (μ.restrict (Ioc a b ∪ Ioc b a))] 0
state_after: case inl
ι : 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
f g : ℝ → ℝ
a b : ℝ
μ : Measure ℝ
hfi : IntervalIntegrable f μ a b
hab : a ≤ b
hf : 0 ≤ᶠ[ae (μ.restrict (Ioc a b))] f
⊢ ∫ (x : ℝ) in a..b, f x ∂μ = 0 ↔ f =ᶠ[ae (μ.restrict (Ioc a b))] 0

case inr
ι : 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
f g : ℝ → ℝ
a b : ℝ
μ : Measure ℝ
hfi : IntervalIntegrable f μ a b
hab : b ≤ a
hf : 0 ≤ᶠ[ae (μ.restrict (Ioc b a))] f
⊢ ∫ (x : ℝ) in a..b, f x ∂μ = 0 ↔ f =ᶠ[ae (μ.restrict (Ioc b a))] 0

tactic: exact integral_eq_zero_iff_of_le_of_nonneg_ae hab hf hfi
state_before: case inl
ι : 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
f g : ℝ → ℝ
a b : ℝ
μ : Measure ℝ
hfi : IntervalIntegrable f μ a b
hab : a ≤ b
hf : 0 ≤ᶠ[ae (μ.restrict (Ioc a b))] f
⊢ ∫ (x : ℝ) in a..b, f x ∂μ = 0 ↔ f =ᶠ[ae (μ.restrict (Ioc a b))] 0
state_after: no goals

tactic: rw [integral_symm, neg_eq_zero, integral_eq_zero_iff_of_le_of_nonneg_ae hab hf hfi.symm]
state_before: case inr
ι : 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
f g : ℝ → ℝ
a b : ℝ
μ : Measure ℝ
hfi : IntervalIntegrable f μ a b
hab : b ≤ a
hf : 0 ≤ᶠ[ae (μ.restrict (Ioc b a))] f
⊢ ∫ (x : ℝ) in a..b, f x ∂μ = 0 ↔ f =ᶠ[ae (μ.restrict (Ioc b a))] 0
state_after: no goals
Theorem: Cardinal.nat_succ
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: rw [Nat.cast_succ]
state_before: α β : Type u
n : ℕ
⊢ ↑n.succ = succ ↑n
state_after: α β : Type u
n : ℕ
⊢ ↑n + 1 = succ ↑n

tactic: refine (add_one_le_succ _).antisymm (succ_le_of_lt ?_)
state_before: α β : Type u
n : ℕ
⊢ ↑n + 1 = succ ↑n
state_after: α β : Type u
n : ℕ
⊢ ↑n < ↑n + 1

tactic: rw [← Nat.cast_succ]
state_before: α β : Type u
n : ℕ
⊢ ↑n < ↑n + 1
state_after: α β : Type u
n : ℕ
⊢ ↑n < ↑n.succ

tactic: exact natCast_lt.2 (Nat.lt_succ_self _)
state_before: α β : Type u
n : ℕ
⊢ ↑n < ↑n.succ
state_after: no goals
Theorem: List.get?_set_eq
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

tactic: simp
state_before: α : Type u_1
a : α
n : Nat
l : List α
⊢ (l.set n a).get? n = (fun x => a) <$> l.get? n
state_after: no goals
Theorem: Batteries.RBNode.Balanced.insert
File: .lake/packages/batteries/Batteries/Data/RBMap/WF.lean

tactic: unfold insert
state_before: α : Type u_1
c : RBColor
n : Nat
cmp : α → α → Ordering
v : α
t : RBNode α
h : t.Balanced c n
⊢ ∃ c' n', (RBNode.insert cmp t v).Balanced c' n'
state_after: α : Type u_1
c : RBColor
n : Nat
cmp : α → α → Ordering
v : α
t : RBNode α
h : t.Balanced c n
⊢ ∃ c' n',
    (match t.isRed with
        | red => (ins cmp v t).setBlack
        | black => ins cmp v t).Balanced
      c' n'

tactic: match ins cmp v t, h.ins cmp v with
| _, .balanced h => split <;> [exact ⟨_, h.setBlack⟩; exact ⟨_, _, h⟩]
| _, .redred _ ha hb => have .node red .. := t; exact ⟨_, _, .black ha hb⟩
state_before: α : Type u_1
c : RBColor
n : Nat
cmp : α → α → Ordering
v : α
t : RBNode α
h : t.Balanced c n
⊢ ∃ c' n',
    (match t.isRed with
        | red => (ins cmp v t).setBlack
        | black => ins cmp v t).Balanced
      c' n'
state_after: no goals

tactic: split <;> [exact ⟨_, h.setBlack⟩; exact ⟨_, _, h⟩]
state_before: α : Type u_1
c : RBColor
n : Nat
cmp : α → α → Ordering
v : α
t : RBNode α
h✝ : t.Balanced c n
x✝ : RBNode α
c✝ : RBColor
h : x✝.Balanced c✝ n
⊢ ∃ c' n',
    (match t.isRed with
        | red => x✝.setBlack
        | black => x✝).Balanced
      c' n'
state_after: no goals

tactic: have .node red .. := t
state_before: α : Type u_1
c : RBColor
n : Nat
cmp : α → α → Ordering
v : α
t : RBNode α
h : t.Balanced c n
a✝¹ : RBNode α
c₁✝ : RBColor
b✝ : RBNode α
c₂✝ : RBColor
x✝ : α
a✝ : t.isRed = red
ha : a✝¹.Balanced c₁✝ n
hb : b✝.Balanced c₂✝ n
⊢ ∃ c' n',
    (match t.isRed with
        | red => (node red a✝¹ x✝ b✝).setBlack
        | black => node red a✝¹ x✝ b✝).Balanced
      c' n'
state_after: α : Type u_1
c : RBColor
n : Nat
cmp : α → α → Ordering
v : α
t a✝¹ : RBNode α
c₁✝ : RBColor
b✝ : RBNode α
c₂✝ : RBColor
x✝ : α
ha : a✝¹.Balanced c₁✝ n
hb : b✝.Balanced c₂✝ n
l✝ : RBNode α
v✝ : α
r✝ : RBNode α
h : (node red l✝ v✝ r✝).Balanced c n
a✝ : (node red l✝ v✝ r✝).isRed = red
⊢ ∃ c' n',
    (match (node red l✝ v✝ r✝).isRed with
        | red => (node red a✝¹ x✝ b✝).setBlack
        | black => node red a✝¹ x✝ b✝).Balanced
      c' n'

tactic: exact ⟨_, _, .black ha hb⟩
state_before: α : Type u_1
c : RBColor
n : Nat
cmp : α → α → Ordering
v : α
t a✝¹ : RBNode α
c₁✝ : RBColor
b✝ : RBNode α
c₂✝ : RBColor
x✝ : α
ha : a✝¹.Balanced c₁✝ n
hb : b✝.Balanced c₂✝ n
l✝ : RBNode α
v✝ : α
r✝ : RBNode α
h : (node red l✝ v✝ r✝).Balanced c n
a✝ : (node red l✝ v✝ r✝).isRed = red
⊢ ∃ c' n',
    (match (node red l✝ v✝ r✝).isRed with
        | red => (node red a✝¹ x✝ b✝).setBlack
        | black => node red a✝¹ x✝ b✝).Balanced
      c' n'
state_after: no goals
Theorem: HurwitzZeta.sinZeta_neg
File: Mathlib/NumberTheory/LSeries/HurwitzZetaOdd.lean

tactic: simp_rw [sinZeta, completedSinZeta_neg, neg_div]
state_before: a : UnitAddCircle
s : ℂ
⊢ sinZeta (-a) s = -sinZeta a s
state_after: no goals
Theorem: Finset.one_lt_card_iff
File: Mathlib/Data/Finset/Card.lean

tactic: rw [one_lt_card]
state_before: α : Type u_1
β : Type u_2
R : Type u_3
s t u : Finset α
f : α → β
n : ℕ
⊢ 1 < s.card ↔ ∃ a b, a ∈ s ∧ b ∈ s ∧ a ≠ b
state_after: α : Type u_1
β : Type u_2
R : Type u_3
s t u : Finset α
f : α → β
n : ℕ
⊢ (∃ a ∈ s, ∃ b ∈ s, a ≠ b) ↔ ∃ a b, a ∈ s ∧ b ∈ s ∧ a ≠ b

tactic: simp only [exists_prop, exists_and_left]
state_before: α : Type u_1
β : Type u_2
R : Type u_3
s t u : Finset α
f : α → β
n : ℕ
⊢ (∃ a ∈ s, ∃ b ∈ s, a ≠ b) ↔ ∃ a b, a ∈ s ∧ b ∈ s ∧ a ≠ b
state_after: no goals
Theorem: Matrix.conjTranspose_col
File: Mathlib/Data/Matrix/RowCol.lean

tactic: ext
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
R : Type u_5
α : Type v
β : Type w
ι : Type u_6
inst✝ : Star α
v : m → α
⊢ (col ι v)ᴴ = row ι (star v)
state_after: case a
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
R : Type u_5
α : Type v
β : Type w
ι : Type u_6
inst✝ : Star α
v : m → α
i✝ : ι
j✝ : m
⊢ (col ι v)ᴴ i✝ j✝ = row ι (star v) i✝ j✝

tactic: rfl
state_before: case a
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
R : Type u_5
α : Type v
β : Type w
ι : Type u_6
inst✝ : Star α
v : m → α
i✝ : ι
j✝ : m
⊢ (col ι v)ᴴ i✝ j✝ = row ι (star v) i✝ j✝
state_after: no goals
Theorem: Filter.HasBasis.comap
File: Mathlib/Order/Filter/Bases.lean

tactic: simp only [mem_comap', hl.mem_iff]
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' : ι'
f : β → α
hl : l.HasBasis p s
t : Set β
⊢ t ∈ Filter.comap f l ↔ ∃ i, p i ∧ f ⁻¹' s i ⊆ t
state_after: α : 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' : ι'
f : β → α
hl : l.HasBasis p s
t : Set β
⊢ (∃ i, p i ∧ s i ⊆ {y | ∀ ⦃x : β⦄, f x = y → x ∈ t}) ↔ ∃ i, p i ∧ f ⁻¹' s i ⊆ t

tactic: refine exists_congr (fun i => Iff.rfl.and ?_)
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' : ι'
f : β → α
hl : l.HasBasis p s
t : Set β
⊢ (∃ i, p i ∧ s i ⊆ {y | ∀ ⦃x : β⦄, f x = y → x ∈ t}) ↔ ∃ i, p i ∧ f ⁻¹' s i ⊆ t
state_after: α : 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' : ι'
f : β → α
hl : l.HasBasis p s
t : Set β
i : ι
⊢ s i ⊆ {y | ∀ ⦃x : β⦄, f x = y → x ∈ t} ↔ f ⁻¹' s i ⊆ t

tactic: exact ⟨fun h x hx => h hx rfl, fun h y hy x hx => h <| by rwa [mem_preimage, hx]⟩
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' : ι'
f : β → α
hl : l.HasBasis p s
t : Set β
i : ι
⊢ s i ⊆ {y | ∀ ⦃x : β⦄, f x = y → x ∈ t} ↔ f ⁻¹' s i ⊆ t
state_after: no goals

tactic: rwa [mem_preimage, hx]
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' : ι'
f : β → α
hl : l.HasBasis p s
t : Set β
i : ι
h : f ⁻¹' s i ⊆ t
y : α
hy : y ∈ s i
x : β
hx : f x = y
⊢ x ∈ f ⁻¹' s i
state_after: no goals
Theorem: NNReal.coe_eq_one
File: Mathlib/Data/NNReal/Basic.lean

tactic: rw [← coe_one, coe_inj]
state_before: r r₁ r₂ : ℝ≥0
x y : ℝ
⊢ ↑r = 1 ↔ r = 1
state_after: no goals
Theorem: NonUnitalStarAlgebra.coe_iInf
File: Mathlib/Algebra/Star/NonUnitalSubalgebra.lean

tactic: simp [iInf]
state_before: F : Type v'
R' : Type u'
R : Type u
A : Type v
B : Type w
C : Type w'
inst✝¹⁶ : CommSemiring R
inst✝¹⁵ : StarRing R
inst✝¹⁴ : NonUnitalSemiring A
inst✝¹³ : StarRing A
inst✝¹² : Module R A
inst✝¹¹ : IsScalarTower R A A
inst✝¹⁰ : SMulCommClass R A A
inst✝⁹ : StarModule R A
inst✝⁸ : NonUnitalSemiring B
inst✝⁷ : StarRing B
inst✝⁶ : Module R B
inst✝⁵ : IsScalarTower R B B
inst✝⁴ : SMulCommClass R B B
inst✝³ : StarModule R B
inst✝² : FunLike F A B
inst✝¹ : NonUnitalAlgHomClass F R A B
inst✝ : NonUnitalStarAlgHomClass F R A B
ι : Sort u_1
S : ι → NonUnitalStarSubalgebra R A
⊢ ↑(⨅ i, S i) = ⋂ i, ↑(S i)
state_after: no goals
Theorem: Finset.mulETransformRight_inv
File: Mathlib/Combinatorics/Additive/ETransform.lean

tactic: simp [-op_inv, op_smul_eq_smul, mulETransformLeft, mulETransformRight]
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : CommGroup α
e : α
x : Finset α × Finset α
⊢ mulETransformRight e⁻¹ x = (mulETransformLeft e x.swap).swap
state_after: no goals
Theorem: Ordinal.lt_nadd_iff
File: Mathlib/SetTheory/Ordinal/NaturalOps.lean

tactic: rw [nadd_def]
state_before: a b c : Ordinal.{u}
⊢ a < b ♯ c ↔ (∃ b' < b, a ≤ b' ♯ c) ∨ ∃ c' < c, a ≤ b ♯ c'
state_after: a b c : Ordinal.{u}
⊢ a < max (b.blsub fun a' x => a' ♯ c) (c.blsub fun b' x => b ♯ b') ↔ (∃ b' < b, a ≤ b' ♯ c) ∨ ∃ c' < c, a ≤ b ♯ c'

tactic: simp [lt_blsub_iff]
state_before: a b c : Ordinal.{u}
⊢ a < max (b.blsub fun a' x => a' ♯ c) (c.blsub fun b' x => b ♯ b') ↔ (∃ b' < b, a ≤ b' ♯ c) ∨ ∃ c' < c, a ≤ b ♯ c'
state_after: no goals
Theorem: intervalIntegral.integral_smul
File: Mathlib/MeasureTheory/Integral/IntervalIntegral.lean

tactic: simp only [intervalIntegral, integral_smul, smul_sub]
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 : ℝ
f✝ g : ℝ → E
μ : Measure ℝ
𝕜 : Type u_6
inst✝² : NontriviallyNormedField 𝕜
inst✝¹ : NormedSpace 𝕜 E
inst✝ : SMulCommClass ℝ 𝕜 E
r : 𝕜
f : ℝ → E
⊢ ∫ (x : ℝ) in a..b, r • f x ∂μ = r • ∫ (x : ℝ) in a..b, f x ∂μ
state_after: no goals
Theorem: WeakDual.CharacterSpace.ext_ker
File: Mathlib/Topology/Algebra/Module/CharacterSpace.lean

tactic: ext x
state_before: 𝕜 : Type u_1
A : Type u_2
inst✝⁷ : CommRing 𝕜
inst✝⁶ : NoZeroDivisors 𝕜
inst✝⁵ : TopologicalSpace 𝕜
inst✝⁴ : ContinuousAdd 𝕜
inst✝³ : ContinuousConstSMul 𝕜 𝕜
inst✝² : TopologicalSpace A
inst✝¹ : Ring A
inst✝ : Algebra 𝕜 A
φ ψ : ↑(characterSpace 𝕜 A)
h : RingHom.ker φ = RingHom.ker ψ
⊢ φ = ψ
state_after: case h
𝕜 : Type u_1
A : Type u_2
inst✝⁷ : CommRing 𝕜
inst✝⁶ : NoZeroDivisors 𝕜
inst✝⁵ : TopologicalSpace 𝕜
inst✝⁴ : ContinuousAdd 𝕜
inst✝³ : ContinuousConstSMul 𝕜 𝕜
inst✝² : TopologicalSpace A
inst✝¹ : Ring A
inst✝ : Algebra 𝕜 A
φ ψ : ↑(characterSpace 𝕜 A)
h : RingHom.ker φ = RingHom.ker ψ
x : A
⊢ φ x = ψ x

tactic: have : x - algebraMap 𝕜 A (ψ x) ∈ RingHom.ker φ := by
  simpa only [h, RingHom.mem_ker, map_sub, AlgHomClass.commutes] using sub_self (ψ x)
state_before: case h
𝕜 : Type u_1
A : Type u_2
inst✝⁷ : CommRing 𝕜
inst✝⁶ : NoZeroDivisors 𝕜
inst✝⁵ : TopologicalSpace 𝕜
inst✝⁴ : ContinuousAdd 𝕜
inst✝³ : ContinuousConstSMul 𝕜 𝕜
inst✝² : TopologicalSpace A
inst✝¹ : Ring A
inst✝ : Algebra 𝕜 A
φ ψ : ↑(characterSpace 𝕜 A)
h : RingHom.ker φ = RingHom.ker ψ
x : A
⊢ φ x = ψ x
state_after: case h
𝕜 : Type u_1
A : Type u_2
inst✝⁷ : CommRing 𝕜
inst✝⁶ : NoZeroDivisors 𝕜
inst✝⁵ : TopologicalSpace 𝕜
inst✝⁴ : ContinuousAdd 𝕜
inst✝³ : ContinuousConstSMul 𝕜 𝕜
inst✝² : TopologicalSpace A
inst✝¹ : Ring A
inst✝ : Algebra 𝕜 A
φ ψ : ↑(characterSpace 𝕜 A)
h : RingHom.ker φ = RingHom.ker ψ
x : A
this : x - (algebraMap 𝕜 A) (ψ x) ∈ RingHom.ker φ
⊢ φ x = ψ x

tactic: rwa [RingHom.mem_ker, map_sub, AlgHomClass.commutes, sub_eq_zero] at this
state_before: case h
𝕜 : Type u_1
A : Type u_2
inst✝⁷ : CommRing 𝕜
inst✝⁶ : NoZeroDivisors 𝕜
inst✝⁵ : TopologicalSpace 𝕜
inst✝⁴ : ContinuousAdd 𝕜
inst✝³ : ContinuousConstSMul 𝕜 𝕜
inst✝² : TopologicalSpace A
inst✝¹ : Ring A
inst✝ : Algebra 𝕜 A
φ ψ : ↑(characterSpace 𝕜 A)
h : RingHom.ker φ = RingHom.ker ψ
x : A
this : x - (algebraMap 𝕜 A) (ψ x) ∈ RingHom.ker φ
⊢ φ x = ψ x
state_after: no goals

tactic: simpa only [h, RingHom.mem_ker, map_sub, AlgHomClass.commutes] using sub_self (ψ x)
state_before: 𝕜 : Type u_1
A : Type u_2
inst✝⁷ : CommRing 𝕜
inst✝⁶ : NoZeroDivisors 𝕜
inst✝⁵ : TopologicalSpace 𝕜
inst✝⁴ : ContinuousAdd 𝕜
inst✝³ : ContinuousConstSMul 𝕜 𝕜
inst✝² : TopologicalSpace A
inst✝¹ : Ring A
inst✝ : Algebra 𝕜 A
φ ψ : ↑(characterSpace 𝕜 A)
h : RingHom.ker φ = RingHom.ker ψ
x : A
⊢ x - (algebraMap 𝕜 A) (ψ x) ∈ RingHom.ker φ
state_after: no goals
Theorem: SimpleGraph.deleteEdges_sdiff_eq_of_le
File: Mathlib/Combinatorics/SimpleGraph/Basic.lean

tactic: rw [← edgeSet_sdiff, deleteEdges_edgeSet, sdiff_sdiff_eq_self h]
state_before: ι : Sort u_1
V : Type u
G : SimpleGraph V
a b c u v w : V
e : Sym2 V
H✝ : SimpleGraph V
s s₁ s₂ : Set (Sym2 V)
H : SimpleGraph V
h : H ≤ G
⊢ G.deleteEdges (G.edgeSet \ H.edgeSet) = H
state_after: no goals
Theorem: LieDerivation.IsKilling.ad_mem_ker_killingForm_ad_range_of_mem_orthogonal
File: Mathlib/Algebra/Lie/Derivation/Killing.lean

tactic: rw [← killingForm_restrict_range_ad]
state_before: R : Type u_1
L : Type u_2
inst✝³ : Field R
inst✝² : LieRing L
inst✝¹ : LieAlgebra R L
inst✝ : Module.Finite R L
D : LieDerivation R L L
hD : D ∈ (killingForm R (LieDerivation R L L)).orthogonal (ad R L).range.toSubmodule
x : L
⊢ (ad R L) (D x) ∈ Submodule.map (ad R L).range.subtype (LinearMap.ker (killingForm R ↥(ad R L).range))
state_after: R : Type u_1
L : Type u_2
inst✝³ : Field R
inst✝² : LieRing L
inst✝¹ : LieAlgebra R L
inst✝ : Module.Finite R L
D : LieDerivation R L L
hD : D ∈ (killingForm R (LieDerivation R L L)).orthogonal (ad R L).range.toSubmodule
x : L
⊢ (ad R L) (D x) ∈
    Submodule.map (ad R L).range.subtype
      (LinearMap.ker ((killingForm R (LieDerivation R L L)).restrict (ad R L).range.toSubmodule))

tactic: exact LinearMap.BilinForm.inf_orthogonal_self_le_ker_restrict
  (LieModule.traceForm_isSymm R 𝔻 𝔻).isRefl ⟨by simp, ad_mem_orthogonal_of_mem_orthogonal hD x⟩
state_before: R : Type u_1
L : Type u_2
inst✝³ : Field R
inst✝² : LieRing L
inst✝¹ : LieAlgebra R L
inst✝ : Module.Finite R L
D : LieDerivation R L L
hD : D ∈ (killingForm R (LieDerivation R L L)).orthogonal (ad R L).range.toSubmodule
x : L
⊢ (ad R L) (D x) ∈
    Submodule.map (ad R L).range.subtype
      (LinearMap.ker ((killingForm R (LieDerivation R L L)).restrict (ad R L).range.toSubmodule))
state_after: no goals

tactic: simp
state_before: R : Type u_1
L : Type u_2
inst✝³ : Field R
inst✝² : LieRing L
inst✝¹ : LieAlgebra R L
inst✝ : Module.Finite R L
D : LieDerivation R L L
hD : D ∈ (killingForm R (LieDerivation R L L)).orthogonal (ad R L).range.toSubmodule
x : L
⊢ (ad R L) (D x) ∈ ↑(ad R L).range.toSubmodule
state_after: no goals
Theorem: Polynomial.natSepDegree_map
File: Mathlib/FieldTheory/SeparableDegree.lean

tactic: simp_rw [natSepDegree_eq_of_isAlgClosed (AlgebraicClosure E), aroots_def, map_map,
  ← IsScalarTower.algebraMap_eq]
state_before: F : Type u
E : Type v
inst✝⁴ : Field F
inst✝³ : Field E
inst✝² : Algebra F E
K : Type w
inst✝¹ : Field K
inst✝ : Algebra F K
f : F[X]
⊢ (map (algebraMap F E) f).natSepDegree = f.natSepDegree
state_after: no goals