1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Cardinal.toNat_congr
File: Mathlib/SetTheory/Cardinal/ToNat.lean

tactic: rw [← toNat_lift, (lift_mk_eq.{_,_,v}).mpr ⟨e⟩, toNat_lift]
state_before: α : Type u
c d : Cardinal.{u}
β : Type v
e : α ≃ β
⊢ toNat #α = toNat #β
state_after: no goals
Theorem: Real.log_neg_eq_log
File: Mathlib/Analysis/SpecialFunctions/Log/Basic.lean

tactic: rw [← log_abs x, ← log_abs (-x), abs_neg]
state_before: x✝ y x : ℝ
⊢ log (-x) = log x
state_after: no goals
Theorem: Matrix.fromRows_mulVec
File: Mathlib/Data/Matrix/ColumnRowPartitioned.lean

tactic: ext (_ | _) <;> rfl
state_before: R : Type u_1
m : Type u_2
m₁ : Type u_3
m₂ : Type u_4
n : Type u_5
n₁ : Type u_6
n₂ : Type u_7
inst✝¹² : Fintype m
inst✝¹¹ : Fintype m₁
inst✝¹⁰ : Fintype m₂
inst✝⁹ : Fintype n
inst✝⁸ : Fintype n₁
inst✝⁷ : Fintype n₂
inst✝⁶ : DecidableEq m
inst✝⁵ : DecidableEq m₁
inst✝⁴ : DecidableEq m₂
inst✝³ : DecidableEq n
inst✝² : DecidableEq n₁
inst✝¹ : DecidableEq n₂
inst✝ : Semiring R
A₁ : Matrix m₁ n R
A₂ : Matrix m₂ n R
v : n → R
⊢ A₁.fromRows A₂ *ᵥ v = Sum.elim (A₁ *ᵥ v) (A₂ *ᵥ v)
state_after: no goals
Theorem: LipschitzOnWith.norm_div_le_of_le
File: Mathlib/Analysis/Normed/Group/Uniform.lean

tactic: gcongr
state_before: 𝓕 : Type u_1
α : Type u_2
E : Type u_3
F : Type u_4
inst✝² : SeminormedGroup E
inst✝¹ : SeminormedGroup F
s : Set E
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
inst✝ : FunLike 𝓕 E F
f : E → F
C : ℝ≥0
h : LipschitzOnWith C f s
ha : a ∈ s
hb : b ∈ s
hr : ‖a / b‖ ≤ r
⊢ ↑C * ‖a / b‖ ≤ ↑C * r
state_after: no goals
Theorem: Nat.totient_eq_one_iff
File: Mathlib/Data/Nat/Totient.lean

tactic: simp
state_before: ⊢ φ 0 = 1 ↔ 0 = 1 ∨ 0 = 2
state_after: no goals

tactic: simp
state_before: ⊢ φ 1 = 1 ↔ 1 = 1 ∨ 1 = 2
state_after: no goals

tactic: simp
state_before: ⊢ φ 2 = 1 ↔ 2 = 1 ∨ 2 = 2
state_after: no goals

tactic: have : 3 ≤ n + 3 := le_add_self
state_before: n : ℕ
⊢ φ (n + 3) = 1 ↔ n + 3 = 1 ∨ n + 3 = 2
state_after: n : ℕ
this : 3 ≤ n + 3
⊢ φ (n + 3) = 1 ↔ n + 3 = 1 ∨ n + 3 = 2

tactic: simp only [succ_succ_ne_one, false_or_iff]
state_before: n : ℕ
this : 3 ≤ n + 3
⊢ φ (n + 3) = 1 ↔ n + 3 = 1 ∨ n + 3 = 2
state_after: n : ℕ
this : 3 ≤ n + 3
⊢ φ (n + 3) = 1 ↔ n + 3 = 2

tactic: exact ⟨fun h => not_even_one.elim <| h ▸ totient_even this, by rintro ⟨⟩⟩
state_before: n : ℕ
this : 3 ≤ n + 3
⊢ φ (n + 3) = 1 ↔ n + 3 = 2
state_after: no goals

tactic: rintro ⟨⟩
state_before: n : ℕ
this : 3 ≤ n + 3
⊢ n + 3 = 2 → φ (n + 3) = 1
state_after: no goals
Theorem: MulAction.smul_mem_fixedBy_iff_mem_fixedBy
File: Mathlib/GroupTheory/GroupAction/FixedPoints.lean

tactic: rw [mem_fixedBy, smul_left_cancel_iff]
state_before: α : Type u_1
G : Type u_2
inst✝³ : Group G
inst✝² : MulAction G α
M : Type u_3
inst✝¹ : Monoid M
inst✝ : MulAction M α
a : α
g : G
⊢ g • a ∈ fixedBy α g ↔ a ∈ fixedBy α g
state_after: α : Type u_1
G : Type u_2
inst✝³ : Group G
inst✝² : MulAction G α
M : Type u_3
inst✝¹ : Monoid M
inst✝ : MulAction M α
a : α
g : G
⊢ g • a = a ↔ a ∈ fixedBy α g

tactic: rfl
state_before: α : Type u_1
G : Type u_2
inst✝³ : Group G
inst✝² : MulAction G α
M : Type u_3
inst✝¹ : Monoid M
inst✝ : MulAction M α
a : α
g : G
⊢ g • a = a ↔ a ∈ fixedBy α g
state_after: no goals
Theorem: Set.inter_singleton_nonempty
File: Mathlib/Data/Set/Basic.lean

tactic: rw [inter_comm, singleton_inter_nonempty]
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s s₁ s₂ t t₁ t₂ u : Set α
⊢ (s ∩ {a}).Nonempty ↔ a ∈ s
state_after: no goals
Theorem: QuadraticForm.posDef_of_toMatrix'
File: Mathlib/LinearAlgebra/Matrix/PosDef.lean

tactic: rw [← toQuadraticForm_associated ℝ Q,
  ← LinearMap.toMatrix₂'.left_inv ((associatedHom (R := ℝ) ℝ) Q)]
state_before: n : Type u_1
inst✝¹ : Fintype n
inst✝ : DecidableEq n
Q : QuadraticForm ℝ (n → ℝ)
hQ : Q.toMatrix'.PosDef
⊢ Q.PosDef
state_after: n : Type u_1
inst✝¹ : Fintype n
inst✝ : DecidableEq n
Q : QuadraticForm ℝ (n → ℝ)
hQ : Q.toMatrix'.PosDef
⊢ (LinearMap.BilinForm.toQuadraticForm
      (LinearMap.toMatrix₂'.invFun ((↑LinearMap.toMatrix₂').toFun ((associatedHom ℝ) Q)))).PosDef

tactic: exact hQ.toQuadraticForm'
state_before: n : Type u_1
inst✝¹ : Fintype n
inst✝ : DecidableEq n
Q : QuadraticForm ℝ (n → ℝ)
hQ : Q.toMatrix'.PosDef
⊢ (LinearMap.BilinForm.toQuadraticForm
      (LinearMap.toMatrix₂'.invFun ((↑LinearMap.toMatrix₂').toFun ((associatedHom ℝ) Q)))).PosDef
state_after: no goals
Theorem: Multiset.filter_eq'
File: Mathlib/Data/Multiset/Basic.lean

tactic: simp only [quot_mk_to_coe, filter_coe, mem_coe, coe_count]
state_before: α : Type u_1
β : Type v
γ : Type u_2
inst✝ : DecidableEq α
s✝ s : Multiset α
b : α
l : List α
⊢ filter (fun x => x = b) ⟦l⟧ = replicate (count b ⟦l⟧) b
state_after: α : Type u_1
β : Type v
γ : Type u_2
inst✝ : DecidableEq α
s✝ s : Multiset α
b : α
l : List α
⊢ ↑(List.filter (fun b_1 => decide (b_1 = b)) l) = replicate (List.count b l) b

tactic: rw [List.filter_eq l b, coe_replicate]
state_before: α : Type u_1
β : Type v
γ : Type u_2
inst✝ : DecidableEq α
s✝ s : Multiset α
b : α
l : List α
⊢ ↑(List.filter (fun b_1 => decide (b_1 = b)) l) = replicate (List.count b l) b
state_after: no goals
Theorem: measurableAtom_of_measurableSingletonClass
File: Mathlib/MeasureTheory/MeasurableSpace/Basic.lean

tactic: simp
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort uι
s t u : Set α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSingletonClass β
x : β
⊢ {x} ⊆ measurableAtom x
state_after: no goals
Theorem: Set.mulIndicator_const_preimage_eq_union
File: Mathlib/Algebra/Group/Indicator.lean

tactic: rw [mulIndicator_preimage, preimage_one, preimage_const]
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
M : Type u_4
N : Type u_5
inst✝³ : One M
inst✝² : One N
s✝ t : Set α
f g : α → M
a✝ : α
U : Set α
s : Set M
a : M
inst✝¹ : Decidable (a ∈ s)
inst✝ : Decidable (1 ∈ s)
⊢ (U.mulIndicator fun x => a) ⁻¹' s = (if a ∈ s then U else ∅) ∪ if 1 ∈ s then Uᶜ else ∅
state_after: α : Type u_1
β : Type u_2
ι : Type u_3
M : Type u_4
N : Type u_5
inst✝³ : One M
inst✝² : One N
s✝ t : Set α
f g : α → M
a✝ : α
U : Set α
s : Set M
a : M
inst✝¹ : Decidable (a ∈ s)
inst✝ : Decidable (1 ∈ s)
⊢ U.ite (if a ∈ s then univ else ∅) (if 1 ∈ s then univ else ∅) = (if a ∈ s then U else ∅) ∪ if 1 ∈ s then Uᶜ else ∅

tactic: split_ifs <;> simp [← compl_eq_univ_diff]
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
M : Type u_4
N : Type u_5
inst✝³ : One M
inst✝² : One N
s✝ t : Set α
f g : α → M
a✝ : α
U : Set α
s : Set M
a : M
inst✝¹ : Decidable (a ∈ s)
inst✝ : Decidable (1 ∈ s)
⊢ U.ite (if a ∈ s then univ else ∅) (if 1 ∈ s then univ else ∅) = (if a ∈ s then U else ∅) ∪ if 1 ∈ s then Uᶜ else ∅
state_after: no goals
Theorem: ArithmeticFunction.ppow_succ'
File: Mathlib/NumberTheory/ArithmeticFunction.lean

tactic: ext x
state_before: R : Type u_1
inst✝ : Semiring R
f : ArithmeticFunction R
k : ℕ
⊢ f.ppow (k + 1) = f.pmul (f.ppow k)
state_after: case h
R : Type u_1
inst✝ : Semiring R
f : ArithmeticFunction R
k x : ℕ
⊢ (f.ppow (k + 1)) x = (f.pmul (f.ppow k)) x

tactic: rw [ppow_apply (Nat.succ_pos k), _root_.pow_succ']
state_before: case h
R : Type u_1
inst✝ : Semiring R
f : ArithmeticFunction R
k x : ℕ
⊢ (f.ppow (k + 1)) x = (f.pmul (f.ppow k)) x
state_after: case h
R : Type u_1
inst✝ : Semiring R
f : ArithmeticFunction R
k x : ℕ
⊢ f x * f x ^ k = (f.pmul (f.ppow k)) x

tactic: induction k <;> simp
state_before: case h
R : Type u_1
inst✝ : Semiring R
f : ArithmeticFunction R
k x : ℕ
⊢ f x * f x ^ k = (f.pmul (f.ppow k)) x
state_after: no goals
Theorem: Function.support_div
File: Mathlib/Algebra/GroupWithZero/Indicator.lean

tactic: simp [div_eq_mul_inv]
state_before: ι : Type u_1
κ : Type u_2
G₀ : Type u_3
M₀ : Type u_4
R : Type u_5
inst✝ : GroupWithZero G₀
f g : ι → G₀
⊢ (support fun a => f a / g a) = support f ∩ support g
state_after: no goals
Theorem: Multiset.sub_add_inter
File: Mathlib/Data/Multiset/Basic.lean

tactic: rw [inter_comm]
state_before: α : Type u_1
β : Type v
γ : Type u_2
inst✝ : DecidableEq α
s✝ t✝ u : Multiset α
a b : α
s t : Multiset α
⊢ s - t + s ∩ t = s
state_after: α : Type u_1
β : Type v
γ : Type u_2
inst✝ : DecidableEq α
s✝ t✝ u : Multiset α
a b : α
s t : Multiset α
⊢ s - t + t ∩ s = s

tactic: revert s
state_before: α : Type u_1
β : Type v
γ : Type u_2
inst✝ : DecidableEq α
s✝ t✝ u : Multiset α
a b : α
s t : Multiset α
⊢ s - t + t ∩ s = s
state_after: α : Type u_1
β : Type v
γ : Type u_2
inst✝ : DecidableEq α
s t✝ u : Multiset α
a b : α
t : Multiset α
⊢ ∀ (s : Multiset α), s - t + t ∩ s = s

tactic: refine Multiset.induction_on t (by simp) fun a t IH s => ?_
state_before: α : Type u_1
β : Type v
γ : Type u_2
inst✝ : DecidableEq α
s t✝ u : Multiset α
a b : α
t : Multiset α
⊢ ∀ (s : Multiset α), s - t + t ∩ s = s
state_after: α : Type u_1
β : Type v
γ : Type u_2
inst✝ : DecidableEq α
s✝ t✝¹ u : Multiset α
a✝ b : α
t✝ : Multiset α
a : α
t : Multiset α
IH : ∀ (s : Multiset α), s - t + t ∩ s = s
s : Multiset α
⊢ s - a ::ₘ t + (a ::ₘ t) ∩ s = s

tactic: by_cases h : a ∈ s
state_before: α : Type u_1
β : Type v
γ : Type u_2
inst✝ : DecidableEq α
s✝ t✝¹ u : Multiset α
a✝ b : α
t✝ : Multiset α
a : α
t : Multiset α
IH : ∀ (s : Multiset α), s - t + t ∩ s = s
s : Multiset α
⊢ s - a ::ₘ t + (a ::ₘ t) ∩ s = s
state_after: case pos
α : Type u_1
β : Type v
γ : Type u_2
inst✝ : DecidableEq α
s✝ t✝¹ u : Multiset α
a✝ b : α
t✝ : Multiset α
a : α
t : Multiset α
IH : ∀ (s : Multiset α), s - t + t ∩ s = s
s : Multiset α
h : a ∈ s
⊢ s - a ::ₘ t + (a ::ₘ t) ∩ s = s

case neg
α : Type u_1
β : Type v
γ : Type u_2
inst✝ : DecidableEq α
s✝ t✝¹ u : Multiset α
a✝ b : α
t✝ : Multiset α
a : α
t : Multiset α
IH : ∀ (s : Multiset α), s - t + t ∩ s = s
s : Multiset α
h : a ∉ s
⊢ s - a ::ₘ t + (a ::ₘ t) ∩ s = s

tactic: simp
state_before: α : Type u_1
β : Type v
γ : Type u_2
inst✝ : DecidableEq α
s t✝ u : Multiset α
a b : α
t : Multiset α
⊢ ∀ (s : Multiset α), s - 0 + 0 ∩ s = s
state_after: no goals

tactic: rw [cons_inter_of_pos _ h, sub_cons, add_cons, IH, cons_erase h]
state_before: case pos
α : Type u_1
β : Type v
γ : Type u_2
inst✝ : DecidableEq α
s✝ t✝¹ u : Multiset α
a✝ b : α
t✝ : Multiset α
a : α
t : Multiset α
IH : ∀ (s : Multiset α), s - t + t ∩ s = s
s : Multiset α
h : a ∈ s
⊢ s - a ::ₘ t + (a ::ₘ t) ∩ s = s
state_after: no goals

tactic: rw [cons_inter_of_neg _ h, sub_cons, erase_of_not_mem h, IH]
state_before: case neg
α : Type u_1
β : Type v
γ : Type u_2
inst✝ : DecidableEq α
s✝ t✝¹ u : Multiset α
a✝ b : α
t✝ : Multiset α
a : α
t : Multiset α
IH : ∀ (s : Multiset α), s - t + t ∩ s = s
s : Multiset α
h : a ∉ s
⊢ s - a ::ₘ t + (a ::ₘ t) ∩ s = s
state_after: no goals
Theorem: WeierstrassCurve.Affine.CoordinateRing.mk_φ
File: Mathlib/AlgebraicGeometry/EllipticCurve/DivisionPolynomial/Basic.lean

tactic: simp_rw [φ, Φ, map_sub, map_mul, map_pow, mk_ψ, mk_Ψ_sq, Ψ, map_mul,
  mul_mul_mul_comm _ <| mk W <| ite .., Int.even_add_one, Int.even_sub_one, ← sq, ite_not,
  apply_ite C, apply_ite <| mk W, ite_pow, map_one, one_pow, mk_ψ₂_sq]
state_before: R : Type r
S : Type s
inst✝¹ : CommRing R
inst✝ : CommRing S
W : WeierstrassCurve R
n : ℤ
⊢ (mk W) (W.φ n) = (mk W) (C (W.Φ n))
state_after: no goals
Theorem: mem_aux
File: Mathlib/Geometry/Manifold/VectorBundle/FiberwiseLinear.lean

tactic: simp only [mem_iUnion, mem_setOf_eq]
state_before: 𝕜 : Type u_1
B : Type u_2
F : Type u_3
inst✝⁷ : TopologicalSpace B
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
EB : Type u_4
inst✝³ : NormedAddCommGroup EB
inst✝² : NormedSpace 𝕜 EB
HB : Type u_5
inst✝¹ : TopologicalSpace HB
inst✝ : ChartedSpace HB B
IB : ModelWithCorners 𝕜 EB HB
e : PartialHomeomorph (B × F) (B × F)
⊢ e ∈
      ⋃ φ,
        ⋃ U,
          ⋃ (hU : IsOpen U),
            ⋃ (hφ : SmoothOn IB 𝓘(𝕜, F →L[𝕜] F) (fun x => ↑(φ x)) U),
              ⋃ (h2φ : SmoothOn IB 𝓘(𝕜, F →L[𝕜] F) (fun x => ↑(φ x).symm) U),
                {e | e.EqOnSource (FiberwiseLinear.partialHomeomorph φ hU ⋯ ⋯)} ↔
    ∃ φ U,
      ∃ (hU : IsOpen U) (hφ : SmoothOn IB 𝓘(𝕜, F →L[𝕜] F) (fun x => ↑(φ x)) U) (h2φ :
        SmoothOn IB 𝓘(𝕜, F →L[𝕜] F) (fun x => ↑(φ x).symm) U), e.EqOnSource (FiberwiseLinear.partialHomeomorph φ hU ⋯ ⋯)
state_after: no goals
Theorem: Relation.reflTransGen_minimal
File: Mathlib/Logic/Relation.lean

tactic: simpa [reflTransGen_eq_self hr₁ hr₂] using ReflTransGen.mono h hxy
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
a b c d : α
r' : α → α → Prop
hr₁ : Reflexive r'
hr₂ : Transitive r'
h : ∀ (x y : α), r x y → r' x y
x y : α
hxy : ReflTransGen r x y
⊢ r' x y
state_after: no goals
Theorem: list_casesOn'
File: Mathlib/Computability/Primrec.lean

tactic: cases' f a with b l <;> simp [encodek]
state_before: α : Type u_1
β : Type u_2
σ : Type u_3
inst✝² : Primcodable α
inst✝¹ : Primcodable β
inst✝ : Primcodable σ
H : Nat.Primrec fun n => encode (decode n)
f : α → List β
g : α → σ
h : α → β × List β → σ
hf : Primrec f
hg : Primrec g
hh : Primrec₂ h
this✝ : Primcodable (List β) := prim H
this : Primrec fun a => Option.map (fun o => Option.casesOn o (g a) (h a)) (decode (encode (f a)))
a : α
⊢ Option.map (fun o => Option.casesOn o (g a) (h a)) (decode (encode (f a))) =
    some (List.casesOn (f a) (g a) fun b l => h a (b, l))
state_after: no goals
Theorem: Valuation.IsEquiv.map
File: Mathlib/RingTheory/Valuation/Basic.lean

tactic: rw [H.le_iff_le]
state_before: K : Type u_1
F : Type u_2
R : Type u_3
inst✝⁴ : DivisionRing K
Γ₀ : Type u_4
Γ'₀ : Type u_5
Γ''₀ : Type u_6
inst✝³ : LinearOrderedCommMonoidWithZero Γ''₀
inst✝² : Ring R
inst✝¹ : LinearOrderedCommMonoidWithZero Γ₀
inst✝ : LinearOrderedCommMonoidWithZero Γ'₀
v v₁ : Valuation R Γ₀
v₂ : Valuation R Γ'₀
v₃ : Valuation R Γ''₀
v' : Valuation R Γ₀
f : Γ₀ →*₀ Γ'₀
hf : Monotone ⇑f
inf : Injective ⇑f
h : v.IsEquiv v'
H : StrictMono ⇑f := Monotone.strictMono_of_injective hf inf
r s : R
⊢ f (v r) ≤ f (v s) ↔ v r ≤ v s
state_after: no goals

tactic: rw [H.le_iff_le]
state_before: K : Type u_1
F : Type u_2
R : Type u_3
inst✝⁴ : DivisionRing K
Γ₀ : Type u_4
Γ'₀ : Type u_5
Γ''₀ : Type u_6
inst✝³ : LinearOrderedCommMonoidWithZero Γ''₀
inst✝² : Ring R
inst✝¹ : LinearOrderedCommMonoidWithZero Γ₀
inst✝ : LinearOrderedCommMonoidWithZero Γ'₀
v v₁ : Valuation R Γ₀
v₂ : Valuation R Γ'₀
v₃ : Valuation R Γ''₀
v' : Valuation R Γ₀
f : Γ₀ →*₀ Γ'₀
hf : Monotone ⇑f
inf : Injective ⇑f
h : v.IsEquiv v'
H : StrictMono ⇑f := Monotone.strictMono_of_injective hf inf
r s : R
⊢ v' r ≤ v' s ↔ f (v' r) ≤ f (v' s)
state_after: no goals
Theorem: Submodule.exists_lieSubmodule_coe_eq_iff
File: Mathlib/Algebra/Lie/Submodule.lean

tactic: constructor
state_before: R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
p : Submodule R M
⊢ (∃ N, ↑N = p) ↔ ∀ (x : L), ∀ m ∈ p, ⁅x, m⁆ ∈ p
state_after: case mp
R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
p : Submodule R M
⊢ (∃ N, ↑N = p) → ∀ (x : L), ∀ m ∈ p, ⁅x, m⁆ ∈ p

case mpr
R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
p : Submodule R M
⊢ (∀ (x : L), ∀ m ∈ p, ⁅x, m⁆ ∈ p) → ∃ N, ↑N = p

tactic: rintro ⟨N, rfl⟩ _ _
state_before: case mp
R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
p : Submodule R M
⊢ (∃ N, ↑N = p) → ∀ (x : L), ∀ m ∈ p, ⁅x, m⁆ ∈ p
state_after: case mp.intro
R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
N : LieSubmodule R L M
x✝ : L
m✝ : M
⊢ m✝ ∈ ↑N → ⁅x✝, m✝⁆ ∈ ↑N

tactic: exact N.lie_mem
state_before: case mp.intro
R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
N : LieSubmodule R L M
x✝ : L
m✝ : M
⊢ m✝ ∈ ↑N → ⁅x✝, m✝⁆ ∈ ↑N
state_after: no goals

tactic: intro h
state_before: case mpr
R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
p : Submodule R M
⊢ (∀ (x : L), ∀ m ∈ p, ⁅x, m⁆ ∈ p) → ∃ N, ↑N = p
state_after: case mpr
R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
p : Submodule R M
h : ∀ (x : L), ∀ m ∈ p, ⁅x, m⁆ ∈ p
⊢ ∃ N, ↑N = p

tactic: use { p with lie_mem := @h }
state_before: case mpr
R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
p : Submodule R M
h : ∀ (x : L), ∀ m ∈ p, ⁅x, m⁆ ∈ p
⊢ ∃ N, ↑N = p
state_after: no goals
Theorem: LieIdeal.map_mono
File: Mathlib/Algebra/Lie/Submodule.lean

tactic: rw [SetLike.le_def] at h
state_before: R : Type u
L : Type v
L' : Type w₂
M : Type w
M' : Type w₁
inst✝¹² : CommRing R
inst✝¹¹ : LieRing L
inst✝¹⁰ : LieAlgebra R L
inst✝⁹ : LieRing L'
inst✝⁸ : LieAlgebra R L'
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
f : L →ₗ⁅R⁆ L'
I I₂✝ : LieIdeal R L
J : LieIdeal R L'
I₁ I₂ : LieIdeal R L
h : I₁ ≤ I₂
⊢ map f I₁ ≤ map f I₂
state_after: R : Type u
L : Type v
L' : Type w₂
M : Type w
M' : Type w₁
inst✝¹² : CommRing R
inst✝¹¹ : LieRing L
inst✝¹⁰ : LieAlgebra R L
inst✝⁹ : LieRing L'
inst✝⁸ : LieAlgebra R L'
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
f : L →ₗ⁅R⁆ L'
I I₂✝ : LieIdeal R L
J : LieIdeal R L'
I₁ I₂ : LieIdeal R L
h : ∀ ⦃x : L⦄, x ∈ I₁ → x ∈ I₂
⊢ map f I₁ ≤ map f I₂

tactic: apply LieSubmodule.lieSpan_mono (Set.image_subset (⇑f) h)
state_before: R : Type u
L : Type v
L' : Type w₂
M : Type w
M' : Type w₁
inst✝¹² : CommRing R
inst✝¹¹ : LieRing L
inst✝¹⁰ : LieAlgebra R L
inst✝⁹ : LieRing L'
inst✝⁸ : LieAlgebra R L'
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
f : L →ₗ⁅R⁆ L'
I I₂✝ : LieIdeal R L
J : LieIdeal R L'
I₁ I₂ : LieIdeal R L
h : ∀ ⦃x : L⦄, x ∈ I₁ → x ∈ I₂
⊢ map f I₁ ≤ map f I₂
state_after: no goals
Theorem: DFinsupp.filter_apply_neg
File: Mathlib/Data/DFinsupp/Basic.lean

tactic: simp only [filter_apply, if_neg h]
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝¹ : (i : ι) → Zero (β i)
p : ι → Prop
inst✝ : DecidablePred p
f : Π₀ (i : ι), β i
i : ι
h : ¬p i
⊢ (filter p f) i = 0
state_after: no goals
Theorem: Filter.frequently_or_distrib
File: Mathlib/Order/Filter/Basic.lean

tactic: simp only [Filter.Frequently, ← not_and_or, not_or, eventually_and]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f : Filter α
p q : α → Prop
⊢ (∃ᶠ (x : α) in f, p x ∨ q x) ↔ (∃ᶠ (x : α) in f, p x) ∨ ∃ᶠ (x : α) in f, q x
state_after: no goals
Theorem: IsAdjoinRootMonic.coeff_root
File: Mathlib/RingTheory/IsAdjoinRoot.lean

tactic: rw [← h.coeff_root_pow hdeg, pow_one]
state_before: R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRootMonic S f
hdeg : 1 < f.natDegree
⊢ h.coeff h.root = Pi.single 1 1
state_after: no goals
Theorem: minimalPrimes_eq_minimals
File: Mathlib/RingTheory/Ideal/MinimalPrime.lean

tactic: simp
state_before: R : Type u_1
S : Type u_2
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
I J : Ideal R
⊢ {p | p.IsPrime ∧ ⊥ ≤ p} = setOf Ideal.IsPrime
state_after: no goals
Theorem: MeasureTheory.LocallyIntegrableOn.continuousOn_smul
File: Mathlib/MeasureTheory/Function/LocallyIntegrable.lean

tactic: rw [MeasureTheory.locallyIntegrableOn_iff (Or.inr hs)] at hf ⊢
state_before: X : Type u_1
Y : Type u_2
E : Type u_3
F : Type u_4
R : Type u_5
inst✝¹¹ : MeasurableSpace X
inst✝¹⁰ : TopologicalSpace X
inst✝⁹ : MeasurableSpace Y
inst✝⁸ : TopologicalSpace Y
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedAddCommGroup F
f✝ g✝ : X → E
μ : Measure X
s✝ : Set X
inst✝⁵ : OpensMeasurableSpace X
A K : Set X
inst✝⁴ : LocallyCompactSpace X
inst✝³ : T2Space X
𝕜 : Type u_6
inst✝² : NormedField 𝕜
inst✝¹ : SecondCountableTopologyEither X 𝕜
inst✝ : NormedSpace 𝕜 E
f : X → E
g : X → 𝕜
s : Set X
hs : IsOpen s
hf : LocallyIntegrableOn f s μ
hg : ContinuousOn g s
⊢ LocallyIntegrableOn (fun x => g x • f x) s μ
state_after: X : Type u_1
Y : Type u_2
E : Type u_3
F : Type u_4
R : Type u_5
inst✝¹¹ : MeasurableSpace X
inst✝¹⁰ : TopologicalSpace X
inst✝⁹ : MeasurableSpace Y
inst✝⁸ : TopologicalSpace Y
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedAddCommGroup F
f✝ g✝ : X → E
μ : Measure X
s✝ : Set X
inst✝⁵ : OpensMeasurableSpace X
A K : Set X
inst✝⁴ : LocallyCompactSpace X
inst✝³ : T2Space X
𝕜 : Type u_6
inst✝² : NormedField 𝕜
inst✝¹ : SecondCountableTopologyEither X 𝕜
inst✝ : NormedSpace 𝕜 E
f : X → E
g : X → 𝕜
s : Set X
hs : IsOpen s
hf : ∀ k ⊆ s, IsCompact k → IntegrableOn f k μ
hg : ContinuousOn g s
⊢ ∀ k ⊆ s, IsCompact k → IntegrableOn (fun x => g x • f x) k μ

tactic: exact fun k hk_sub hk_c => (hf k hk_sub hk_c).continuousOn_smul (hg.mono hk_sub) hk_c
state_before: X : Type u_1
Y : Type u_2
E : Type u_3
F : Type u_4
R : Type u_5
inst✝¹¹ : MeasurableSpace X
inst✝¹⁰ : TopologicalSpace X
inst✝⁹ : MeasurableSpace Y
inst✝⁸ : TopologicalSpace Y
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedAddCommGroup F
f✝ g✝ : X → E
μ : Measure X
s✝ : Set X
inst✝⁵ : OpensMeasurableSpace X
A K : Set X
inst✝⁴ : LocallyCompactSpace X
inst✝³ : T2Space X
𝕜 : Type u_6
inst✝² : NormedField 𝕜
inst✝¹ : SecondCountableTopologyEither X 𝕜
inst✝ : NormedSpace 𝕜 E
f : X → E
g : X → 𝕜
s : Set X
hs : IsOpen s
hf : ∀ k ⊆ s, IsCompact k → IntegrableOn f k μ
hg : ContinuousOn g s
⊢ ∀ k ⊆ s, IsCompact k → IntegrableOn (fun x => g x • f x) k μ
state_after: no goals
Theorem: MeasureTheory.L1.continuous_integral
File: Mathlib/MeasureTheory/Integral/Bochner.lean

tactic: simp only [integral]
state_before: α : Type u_1
E : Type u_2
F : Type u_3
𝕜 : Type u_4
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedAddCommGroup F
m : MeasurableSpace α
μ : Measure α
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : NontriviallyNormedField 𝕜
inst✝³ : NormedSpace 𝕜 E
inst✝² : SMulCommClass ℝ 𝕜 E
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace E
⊢ Continuous fun f => integral f
state_after: α : Type u_1
E : Type u_2
F : Type u_3
𝕜 : Type u_4
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedAddCommGroup F
m : MeasurableSpace α
μ : Measure α
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : NontriviallyNormedField 𝕜
inst✝³ : NormedSpace 𝕜 E
inst✝² : SMulCommClass ℝ 𝕜 E
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace E
⊢ Continuous fun f => integralCLM f

tactic: exact L1.integralCLM.continuous
state_before: α : Type u_1
E : Type u_2
F : Type u_3
𝕜 : Type u_4
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedAddCommGroup F
m : MeasurableSpace α
μ : Measure α
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : NontriviallyNormedField 𝕜
inst✝³ : NormedSpace 𝕜 E
inst✝² : SMulCommClass ℝ 𝕜 E
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace E
⊢ Continuous fun f => integralCLM f
state_after: no goals