tasksource/leandojo huggingface dataset:
Theorem: RatFunc.ofFractionRing_mk'
File: Mathlib/FieldTheory/RatFunc.lean

tactic: rw [IsFractionRing.mk'_eq_div, IsFractionRing.mk'_eq_div, ← mk_eq_div', ← mk_eq_div]
state_before: K : Type u
inst✝¹ : CommRing K
inst✝ : IsDomain K
x : K[X]
y : { x // x ∈ K[X]⁰ }
⊢ { toFractionRing := IsLocalization.mk' (FractionRing K[X]) x y } = IsLocalization.mk' (RatFunc K) x y
Theorem: Set.ordConnected_of_uIcc_subset_left
File: Mathlib/Data/Set/Intervals/OrdConnected.lean

tactic: rw [uIcc_comm]
state_before: α : Type u_1
inst✝ : LinearOrder α
s : Set α
x : α
h : ∀ (y : α), y ∈ s → [[x, y]] ⊆ s
y : α
hy : y ∈ s
z : α
hz : z ∈ s
⊢ [[y, x]] ∪ [[x, z]] = [[x, y]] ∪ [[x, z]]
Theorem: IsCompact.closedBall_one_div
File: Mathlib/Analysis/Normed/Group/Pointwise.lean

tactic: simp [div_eq_mul_inv, mul_comm, hs.inv.mul_closedBall_one hδ]
state_before: E : Type u_1
inst✝ : SeminormedCommGroup E
ε δ : ℝ
s t : Set E
x y : E
hs : IsCompact s
hδ : 0 ≤ δ
⊢ closedBall 1 δ / s = cthickening δ s⁻¹
Theorem: Matrix.BlockTriangular.sub
File: Mathlib/LinearAlgebra/Matrix/Block.lean

tactic: simp_rw [Matrix.sub_apply, hM h, hN h, sub_zero]
state_before: α : Type u_1
β : Type ?u.29890
m : Type u_2
n : Type ?u.29896
o : Type ?u.29899
m' : α → Type ?u.29904
n' : α → Type ?u.29909
R : Type v
inst✝¹ : CommRing R
M N : Matrix m m R
b : m → α
inst✝ : LT α
hM : BlockTriangular M b
hN : BlockTriangular N b
i j : m
h : b j < b i
⊢ (M - N) i j = 0
Theorem: FreeAlgebra.algebraMap_leftInverse
File: Mathlib/Algebra/FreeAlgebra.lean

tactic: simp [algebraMapInv]
state_before: R : Type u_1
inst✝² : CommSemiring R
X : Type u_2
A : Type ?u.547902
inst✝¹ : Semiring A
inst✝ : Algebra R A
x : R
⊢ ↑algebraMapInv (↑(algebraMap R (FreeAlgebra R X)) x) = x
Theorem: FractionalIdeal.mul_div_self_cancel_iff
File: Mathlib/RingTheory/FractionalIdeal.lean

tactic: rwa [← eq_one_div_of_mul_eq_one_right I J hJ]
state_before: R : Type ?u.1228112
inst✝⁶ : CommRing R
S : Submonoid R
P : Type ?u.1228319
inst✝⁵ : CommRing P
inst✝⁴ : Algebra R P
loc : IsLocalization S P
R₁ : Type u_1
inst✝³ : CommRing R₁
K : Type u_2
inst✝² : Field K
inst✝¹ : Algebra R₁ K
frac : IsFractionRing R₁ K
inst✝ : IsDomain R₁
I✝ J✝ I : FractionalIdeal R₁⁰ K
x✝ : ∃ J, I * J = 1
J : FractionalIdeal R₁⁰ K
hJ : I * J = 1
⊢ I * (1 / I) = 1
Theorem: Array.swap_def
File: Std/Data/Array/Lemmas.lean

tactic: simp [j.2]
state_before: α : Type ?u.19719
a : Array α
i j : Fin (size a)
⊢ j.val < size (set a i (get a j))

tactic: simp [swap, fin_cast_val]
state_before: α : Type u_1
a : Array α
i j : Fin (size a)
⊢ swap a i j = set (set a i (get a j)) { val := j.val, isLt := (_ : j.val < size (set a i a[j.val])) } (get a i)
Theorem: Polynomial.derivative_C_mul_X_sq
File: Mathlib/Data/Polynomial/Derivative.lean

tactic: rw [derivative_C_mul_X_pow, Nat.cast_two, pow_one]
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
A : Type z
a✝ b : R
n : ℕ
inst✝ : Semiring R
a : R
⊢ ↑derivative (↑C a * X ^ 2) = ↑C (a * 2) * X
Theorem: MonoidHom.map_pthRoot
File: Mathlib/FieldTheory/PerfectClosure.lean

tactic: rw [← f.map_frobenius, frobenius_pthRoot]
state_before: R : Type u
inst✝⁶ : CommSemiring R
S : Type v
inst✝⁵ : CommSemiring S
f : R →* S
g : R →+* S
p : ℕ
inst✝⁴ : Fact (Nat.Prime p)
inst✝³ : CharP R p
inst✝² : PerfectRing R p
inst✝¹ : CharP S p
inst✝ : PerfectRing S p
x : R
⊢ ↑(frobenius ((fun x => S) (↑(pthRoot R p) x)) p) (↑f (↑(pthRoot R p) x)) = ↑f x
Theorem: Complex.sin_arg
File: Mathlib/Analysis/SpecialFunctions/Complex/Arg.lean

tactic: unfold arg
state_before: x : ℂ
⊢ Real.sin (arg x) = x.im / ↑abs x

tactic: split_ifs <;>
simp [sub_eq_add_neg, arg,
Real.sin_arcsin (abs_le.1 (abs_im_div_abs_le_one x)).1 (abs_le.1 (abs_im_div_abs_le_one x)).2,
Real.sin_add, neg_div, Real.arcsin_neg, Real.sin_neg]
state_before: x : ℂ
⊢ Real.sin
      (if 0 ≤ x.re then arcsin (x.im / ↑abs x)
      else if 0 ≤ x.im then arcsin ((-x).im / ↑abs x) + π else arcsin ((-x).im / ↑abs x) - π) =
    x.im / ↑abs x
Theorem: List.prod_take_succ
File: Mathlib/Data/List/BigOperators/Basic.lean

tactic: cases p
state_before: ι : Type ?u.54458
α : Type ?u.54461
M : Type u_1
N : Type ?u.54467
P : Type ?u.54470
M₀ : Type ?u.54473
G : Type ?u.54476
R : Type ?u.54479
inst✝² : Monoid M
inst✝¹ : Monoid N
inst✝ : Monoid P
l l₁ l₂ : List M
a : M
i : ℕ
p : i < length []
⊢ prod (take (i + 1) []) = prod (take i []) * nthLe [] i p

tactic: dsimp
state_before: ι : Type ?u.54458
α : Type ?u.54461
M : Type u_1
N : Type ?u.54467
P : Type ?u.54470
M₀ : Type ?u.54473
G : Type ?u.54476
R : Type ?u.54479
inst✝² : Monoid M
inst✝¹ : Monoid N
inst✝ : Monoid P
l l₁ l₂ : List M
a h : M
t : List M
n : ℕ
p : n + 1 < length (h :: t)
⊢ prod (take (n + 1 + 1) (h :: t)) = prod (take (n + 1) (h :: t)) * nthLe (h :: t) (n + 1) p

tactic: rw [prod_cons, prod_cons, prod_take_succ t n (Nat.lt_of_succ_lt_succ p), mul_assoc,
  nthLe_cons, dif_neg (Nat.add_one_ne_zero _)]
state_before: ι : Type ?u.54458
α : Type ?u.54461
M : Type u_1
N : Type ?u.54467
P : Type ?u.54470
M₀ : Type ?u.54473
G : Type ?u.54476
R : Type ?u.54479
inst✝² : Monoid M
inst✝¹ : Monoid N
inst✝ : Monoid P
l l₁ l₂ : List M
a h : M
t : List M
n : ℕ
p : n + 1 < length (h :: t)
⊢ prod (h :: take (n + 1) t) = prod (h :: take n t) * nthLe (h :: t) (n + 1) p

tactic: simp
state_before: ι : Type ?u.54458
α : Type ?u.54461
M : Type u_1
N : Type ?u.54467
P : Type ?u.54470
M₀ : Type ?u.54473
G : Type ?u.54476
R : Type ?u.54479
inst✝² : Monoid M
inst✝¹ : Monoid N
inst✝ : Monoid P
l l₁ l₂ : List M
a h : M
t : List M
n : ℕ
p : n + 1 < length (h :: t)
⊢ h * (prod (take n t) * nthLe t n (_ : n < length t)) =
    h * (prod (take n t) * nthLe t (n + 1 - 1) (_ : n + 1 - 1 < length t))
Theorem: isQuasiSeparated_iff_quasiSeparatedSpace
File: Mathlib/Topology/QuasiSeparated.lean

tactic: rw [← isQuasiSeparated_univ_iff]
state_before: α : Type u_1
β : Type ?u.15502
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
f : α → β
s : Set α
hs : IsOpen s
⊢ IsQuasiSeparated s ↔ QuasiSeparatedSpace ↑s

tactic: convert (hs.openEmbedding_subtype_val.isQuasiSeparated_iff (s := Set.univ)).symm
state_before: α : Type u_1
β : Type ?u.15502
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
f : α → β
s : Set α
hs : IsOpen s
⊢ IsQuasiSeparated s ↔ IsQuasiSeparated Set.univ

tactic: simp
state_before: case h.e'_1.h.e'_3
α : Type u_1
β : Type ?u.15502
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
f : α → β
s : Set α
hs : IsOpen s
⊢ s = Subtype.val '' Set.univ
Theorem: List.mem_append_of_mem_left
File: src/lean/Init/Data/List/Basic.lean

tactic: intro h
state_before: α : Type u
β : Type v
γ : Type w
a : α
as bs : List α
⊢ a ∈ as → a ∈ as ++ bs

tactic: induction h with
| head => apply Mem.head
| tail => apply Mem.tail; assumption
state_before: α : Type u
β : Type v
γ : Type w
a : α
as bs : List α
h : a ∈ as
⊢ a ∈ as ++ bs

tactic: apply Mem.head
state_before: case head
α : Type u
β : Type v
γ : Type w
a : α
as bs as✝ : List α
⊢ a ∈ a :: as✝ ++ bs

tactic: apply Mem.tail
state_before: case tail
α : Type u
β : Type v
γ : Type w
a : α
as bs : List α
b✝ : α
as✝ : List α
a✝ : Mem a as✝
a_ih✝ : a ∈ as✝ ++ bs
⊢ a ∈ b✝ :: as✝ ++ bs

tactic: assumption
state_before: case tail.a
α : Type u
β : Type v
γ : Type w
a : α
as bs : List α
b✝ : α
as✝ : List α
a✝ : Mem a as✝
a_ih✝ : a ∈ as✝ ++ bs
⊢ Mem a (List.append as✝ bs)
Theorem: Nat.toPNat'_coe
File: Mathlib/Data/PNat/Defs.lean

tactic: rw [if_pos (succ_pos m)]
state_before: m : ℕ
⊢ ↑(toPNat' (m + 1)) = if 0 < m + 1 then m + 1 else 1

tactic: rfl
state_before: m : ℕ
⊢ ↑(toPNat' (m + 1)) = m + 1
Theorem: MvPolynomial.bind₁_X_left
File: Mathlib/Data/MvPolynomial/Monad.lean

tactic: ext1 i
state_before: σ : Type u_1
τ : Type ?u.78653
R : Type u_2
S : Type ?u.78659
T : Type ?u.78662
inst✝² : CommSemiring R
inst✝¹ : CommSemiring S
inst✝ : CommSemiring T
⊢ bind₁ X = AlgHom.id R (MvPolynomial σ R)

tactic: simp
state_before: case hf
σ : Type u_1
τ : Type ?u.78653
R : Type u_2
S : Type ?u.78659
T : Type ?u.78662
inst✝² : CommSemiring R
inst✝¹ : CommSemiring S
inst✝ : CommSemiring T
i : σ
⊢ ↑(bind₁ X) (X i) = ↑(AlgHom.id R (MvPolynomial σ R)) (X i)
Theorem: Set.inv_mem_centralizer
File: Mathlib/GroupTheory/Subsemigroup/Centralizer.lean

tactic: rw [mul_inv_eq_iff_eq_mul, mul_assoc, eq_inv_mul_iff_mul_eq, ha g hg]
state_before: M : Type u_1
S T : Set M
a b : M
inst✝ : Group M
ha : a ∈ centralizer S
g : M
hg : g ∈ S
⊢ g * a⁻¹ = a⁻¹ * g
Theorem: Finset.IsAntichain.disjoint_slice_shadow_falling
File: Mathlib/Combinatorics/SetFamily/LYM.lean

tactic: simp_rw [mem_shadow_iff, mem_falling] at h₁
state_before: 𝕜 : Type ?u.24481
α : Type u_1
inst✝¹ : LinearOrderedField 𝕜
inst✝ : DecidableEq α
k : ℕ
𝒜 : Finset (Finset α)
s✝ : Finset α
m n : ℕ
h𝒜 : IsAntichain (fun x x_1 => x ⊆ x_1) ↑𝒜
s : Finset α
h₁ : s ∈ (∂ ) (falling n 𝒜)
h₂ : s ∈ 𝒜 # m
⊢ False

tactic: obtain ⟨s, ⟨⟨t, ht, hst⟩, _⟩, a, ha, rfl⟩ := h₁
state_before: 𝕜 : Type ?u.24481
α : Type u_1
inst✝¹ : LinearOrderedField 𝕜
inst✝ : DecidableEq α
k : ℕ
𝒜 : Finset (Finset α)
s✝ : Finset α
m n : ℕ
h𝒜 : IsAntichain (fun x x_1 => x ⊆ x_1) ↑𝒜
s : Finset α
h₂ : s ∈ 𝒜 # m
h₁ : ∃ t, ((∃ t_1, t_1 ∈ 𝒜 ∧ t ⊆ t_1) ∧ card t = n) ∧ ∃ a, a ∈ t ∧ erase t a = s
⊢ False

tactic: refine' h𝒜 (slice_subset h₂) ht _ ((erase_subset _ _).trans hst)
state_before: case intro.intro.intro.intro.intro.intro.intro
𝕜 : Type ?u.24481
α : Type u_1
inst✝¹ : LinearOrderedField 𝕜
inst✝ : DecidableEq α
k : ℕ
𝒜 : Finset (Finset α)
s✝ : Finset α
m n : ℕ
h𝒜 : IsAntichain (fun x x_1 => x ⊆ x_1) ↑𝒜
s : Finset α
right✝ : card s = n
t : Finset α
ht : t ∈ 𝒜
hst : s ⊆ t
a : α
ha : a ∈ s
h₂ : erase s a ∈ 𝒜 # m
⊢ False

tactic: rintro rfl
state_before: case intro.intro.intro.intro.intro.intro.intro
𝕜 : Type ?u.24481
α : Type u_1
inst✝¹ : LinearOrderedField 𝕜
inst✝ : DecidableEq α
k : ℕ
𝒜 : Finset (Finset α)
s✝ : Finset α
m n : ℕ
h𝒜 : IsAntichain (fun x x_1 => x ⊆ x_1) ↑𝒜
s : Finset α
right✝ : card s = n
t : Finset α
ht : t ∈ 𝒜
hst : s ⊆ t
a : α
ha : a ∈ s
h₂ : erase s a ∈ 𝒜 # m
⊢ erase s a ≠ t

tactic: exact not_mem_erase _ _ (hst ha)
state_before: case intro.intro.intro.intro.intro.intro.intro
𝕜 : Type ?u.24481
α : Type u_1
inst✝¹ : LinearOrderedField 𝕜
inst✝ : DecidableEq α
k : ℕ
𝒜 : Finset (Finset α)
s✝ : Finset α
m n : ℕ
h𝒜 : IsAntichain (fun x x_1 => x ⊆ x_1) ↑𝒜
s : Finset α
right✝ : card s = n
a : α
ha : a ∈ s
h₂ : erase s a ∈ 𝒜 # m
ht : erase s a ∈ 𝒜
hst : s ⊆ erase s a
⊢ False
Theorem: Option.pmap_eq_map
File: Mathlib/Data/Option/Basic.lean

tactic: cases x <;> simp only [map_none', map_some', pmap]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.8636
δ : Type ?u.8639
p✝ : α → Prop
f✝ : (a : α) → p✝ a → β
x✝ : Option α
p : α → Prop
f : α → β
x : Option α
H : ∀ (a : α), a ∈ x → p a
⊢ pmap (fun a x => f a) x H = Option.map f x
Theorem: Subring.coe_iSup_of_directed
File: Mathlib/RingTheory/Subring/Basic.lean

tactic: simp [mem_iSup_of_directed hS]
state_before: R : Type u
S✝ : Type v
T : Type w
inst✝² : Ring R
inst✝¹ : Ring S✝
inst✝ : Ring T
ι : Sort u_1
hι : Nonempty ι
S : ι → Subring R
hS : Directed (fun x x_1 => x ≤ x_1) S
x : R
⊢ x ∈ ↑(⨆ (i : ι), S i) ↔ x ∈ ⋃ (i : ι), ↑(S i)
Theorem: Submodule.eq_smul_of_le_smul_of_le_jacobson
File: Mathlib/RingTheory/Nakayama.lean

tactic: refine' le_antisymm _ (Submodule.smul_le.2 fun _ _ _ => Submodule.smul_mem _ _)
state_before: R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
I J : Ideal R
N : Submodule R M
hN : FG N
hIN : N ≤ I • N
hIjac : I ≤ jacobson J
⊢ N = J • N

tactic: intro n hn
state_before: R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
I J : Ideal R
N : Submodule R M
hN : FG N
hIN : N ≤ I • N
hIjac : I ≤ jacobson J
⊢ N ≤ J • N

tactic: cases' Submodule.exists_sub_one_mem_and_smul_eq_zero_of_fg_of_le_smul I N hN hIN with r hr
state_before: R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
I J : Ideal R
N : Submodule R M
hN : FG N
hIN : N ≤ I • N
hIjac : I ≤ jacobson J
n : M
hn : n ∈ N
⊢ n ∈ J • N

tactic: cases' exists_mul_sub_mem_of_sub_one_mem_jacobson r (hIjac hr.1) with s hs
state_before: case intro
R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
I J : Ideal R
N : Submodule R M
hN : FG N
hIN : N ≤ I • N
hIjac : I ≤ jacobson J
n : M
hn : n ∈ N
r : R
hr : r - 1 ∈ I ∧ ∀ (n : M), n ∈ N → r • n = 0
⊢ n ∈ J • N

tactic: have : n = -(s * r - 1) • n := by
  rw [neg_sub, sub_smul, mul_smul, hr.2 n hn, one_smul, smul_zero, sub_zero]
state_before: case intro.intro
R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
I J : Ideal R
N : Submodule R M
hN : FG N
hIN : N ≤ I • N
hIjac : I ≤ jacobson J
n : M
hn : n ∈ N
r : R
hr : r - 1 ∈ I ∧ ∀ (n : M), n ∈ N → r • n = 0
s : R
hs : s * r - 1 ∈ J
⊢ n ∈ J • N

tactic: rw [this]
state_before: case intro.intro
R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
I J : Ideal R
N : Submodule R M
hN : FG N
hIN : N ≤ I • N
hIjac : I ≤ jacobson J
n : M
hn : n ∈ N
r : R
hr : r - 1 ∈ I ∧ ∀ (n : M), n ∈ N → r • n = 0
s : R
hs : s * r - 1 ∈ J
this : n = -(s * r - 1) • n
⊢ n ∈ J • N

tactic: exact Submodule.smul_mem_smul (Submodule.neg_mem _ hs) hn
state_before: case intro.intro
R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
I J : Ideal R
N : Submodule R M
hN : FG N
hIN : N ≤ I • N
hIjac : I ≤ jacobson J
n : M
hn : n ∈ N
r : R
hr : r - 1 ∈ I ∧ ∀ (n : M), n ∈ N → r • n = 0
s : R
hs : s * r - 1 ∈ J
this : n = -(s * r - 1) • n
⊢ -(s * r - 1) • n ∈ J • N

tactic: rw [neg_sub, sub_smul, mul_smul, hr.2 n hn, one_smul, smul_zero, sub_zero]
state_before: R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
I J : Ideal R
N : Submodule R M
hN : FG N
hIN : N ≤ I • N
hIjac : I ≤ jacobson J
n : M
hn : n ∈ N
r : R
hr : r - 1 ∈ I ∧ ∀ (n : M), n ∈ N → r • n = 0
s : R
hs : s * r - 1 ∈ J
⊢ n = -(s * r - 1) • n
Theorem: List.lookupAll_eq_nil
File: Mathlib/Data/List/Sigma.lean

tactic: simp
state_before: α : Type u
β : α → Type v
l l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a : α
⊢ lookupAll a [] = [] ↔ ∀ (b : β a), ¬{ fst := a, snd := b } ∈ []

tactic: by_cases h : a = a'
state_before: α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a a' : α
b : β a'
l : List (Sigma β)
⊢ lookupAll a ({ fst := a', snd := b } :: l) = [] ↔
    ∀ (b_1 : β a), ¬{ fst := a, snd := b_1 } ∈ { fst := a', snd := b } :: l

tactic: subst a'
state_before: case pos
α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a a' : α
b : β a'
l : List (Sigma β)
h : a = a'
⊢ lookupAll a ({ fst := a', snd := b } :: l) = [] ↔
    ∀ (b_1 : β a), ¬{ fst := a, snd := b_1 } ∈ { fst := a', snd := b } :: l

tactic: simp
state_before: case pos
α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a : α
l : List (Sigma β)
b : β a
⊢ lookupAll a ({ fst := a, snd := b } :: l) = [] ↔
    ∀ (b_1 : β a), ¬{ fst := a, snd := b_1 } ∈ { fst := a, snd := b } :: l

tactic: simp [h, lookupAll_eq_nil]
state_before: case neg
α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a a' : α
b : β a'
l : List (Sigma β)
h : ¬a = a'
⊢ lookupAll a ({ fst := a', snd := b } :: l) = [] ↔
    ∀ (b_1 : β a), ¬{ fst := a, snd := b_1 } ∈ { fst := a', snd := b } :: l
Theorem: MeasureTheory.HasFiniteIntegral.smul_measure
File: Mathlib/MeasureTheory/Function/L1Space.lean

tactic: simp only [HasFiniteIntegral, lintegral_smul_measure] at *
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.720070
δ : Type ?u.720073
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → β
h : HasFiniteIntegral f
c : ℝ≥0∞
hc : c ≠ ⊤
⊢ HasFiniteIntegral f

tactic: exact mul_lt_top hc h.ne
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.720070
δ : Type ?u.720073
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → β
c : ℝ≥0∞
hc : c ≠ ⊤
h : (∫⁻ (a : α), ↑‖f a‖₊ ∂μ) < ⊤
⊢ (c * ∫⁻ (a : α), ↑‖f a‖₊ ∂μ) < ⊤
Theorem: EMetric.mem_ball_self
File: Mathlib/Topology/MetricSpace/EMetricSpace.lean

tactic: rwa [mem_ball, edist_self]
state_before: α : Type u
β : Type v
X : Type ?u.188592
inst✝ : PseudoEMetricSpace α
x y z : α
ε ε₁ ε₂ : ℝ≥0∞
s t : Set α
h : 0 < ε
⊢ x ∈ ball x ε
Theorem: MeasureTheory.OuterMeasure.coe_fn_injective
File: Mathlib/MeasureTheory/Measure/OuterMeasure.lean

tactic: cases μ₁
state_before: α : Type u_1
β : Type ?u.23243
R : Type ?u.23246
R' : Type ?u.23249
ms : Set (OuterMeasure α)
m μ₁ μ₂ : OuterMeasure α
h : (fun μ s => ↑μ s) μ₁ = (fun μ s => ↑μ s) μ₂
⊢ μ₁ = μ₂

tactic: cases μ₂
state_before: case mk
α : Type u_1
β : Type ?u.23243
R : Type ?u.23246
R' : Type ?u.23249
ms : Set (OuterMeasure α)
m μ₂ : OuterMeasure α
measureOf✝ : Set α → ℝ≥0∞
empty✝ : measureOf✝ ∅ = 0
mono✝ : ∀ {s₁ s₂ : Set α}, s₁ ⊆ s₂ → measureOf✝ s₁ ≤ measureOf✝ s₂
iUnion_nat✝ : ∀ (s : ℕ → Set α), measureOf✝ (⋃ (i : ℕ), s i) ≤ ∑' (i : ℕ), measureOf✝ (s i)
h :
  (fun μ s => ↑μ s) { measureOf := measureOf✝, empty := empty✝, mono := mono✝, iUnion_nat := iUnion_nat✝ } =
    (fun μ s => ↑μ s) μ₂
⊢ { measureOf := measureOf✝, empty := empty✝, mono := mono✝, iUnion_nat := iUnion_nat✝ } = μ₂

tactic: congr
state_before: case mk.mk
α : Type u_1
β : Type ?u.23243
R : Type ?u.23246
R' : Type ?u.23249
ms : Set (OuterMeasure α)
m : OuterMeasure α
measureOf✝¹ : Set α → ℝ≥0∞
empty✝¹ : measureOf✝¹ ∅ = 0
mono✝¹ : ∀ {s₁ s₂ : Set α}, s₁ ⊆ s₂ → measureOf✝¹ s₁ ≤ measureOf✝¹ s₂
iUnion_nat✝¹ : ∀ (s : ℕ → Set α), measureOf✝¹ (⋃ (i : ℕ), s i) ≤ ∑' (i : ℕ), measureOf✝¹ (s i)
measureOf✝ : Set α → ℝ≥0∞
empty✝ : measureOf✝ ∅ = 0
mono✝ : ∀ {s₁ s₂ : Set α}, s₁ ⊆ s₂ → measureOf✝ s₁ ≤ measureOf✝ s₂
iUnion_nat✝ : ∀ (s : ℕ → Set α), measureOf✝ (⋃ (i : ℕ), s i) ≤ ∑' (i : ℕ), measureOf✝ (s i)
h :
  (fun μ s => ↑μ s) { measureOf := measureOf✝¹, empty := empty✝¹, mono := mono✝¹, iUnion_nat := iUnion_nat✝¹ } =
    (fun μ s => ↑μ s) { measureOf := measureOf✝, empty := empty✝, mono := mono✝, iUnion_nat := iUnion_nat✝ }
⊢ { measureOf := measureOf✝¹, empty := empty✝¹, mono := mono✝¹, iUnion_nat := iUnion_nat✝¹ } =
    { measureOf := measureOf✝, empty := empty✝, mono := mono✝, iUnion_nat := iUnion_nat✝ }
Theorem: Option.map₂_left_comm
File: Mathlib/Data/Option/NAry.lean

tactic: cases a <;> cases b <;> cases c <;> simp [h_left_comm]
state_before: α : Type u_4
β : Type u_5
γ : Type u_6
f✝ : α → β → γ
a : Option α
b : Option β
c : Option γ
δ : Type u_1
ε : Type u_2
δ' : Type u_3
f : α → δ → ε
g : β → γ → δ
f' : α → γ → δ'
g' : β → δ' → ε
h_left_comm : ∀ (a : α) (b : β) (c : γ), f a (g b c) = g' b (f' a c)
⊢ map₂ f a (map₂ g b c) = map₂ g' b (map₂ f' a c)
Theorem: Subgroup.mk_eq_one_iff
File: Mathlib/GroupTheory/Subgroup/Basic.lean

tactic: simp
state_before: G : Type u_1
G' : Type ?u.147239
inst✝² : Group G
inst✝¹ : Group G'
A : Type ?u.147248
inst✝ : AddGroup A
H K : Subgroup G
g : G
h : g ∈ H
⊢ { val := g, property := h } = { val := 1, property := (_ : 1 ∈ H) } ↔ g = 1
Theorem: Submodule.IsOrtho.map
File: Mathlib/Analysis/InnerProductSpace/Orthogonal.lean

tactic: rw [isOrtho_iff_inner_eq] at *
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace 𝕜 F
f : E →ₗᵢ[𝕜] F
U V : Submodule 𝕜 E
h : U ⟂ V
⊢ Submodule.map f U ⟂ Submodule.map f V

tactic: simp_rw [mem_map, forall_exists_index, and_imp, forall_apply_eq_imp_iff₂,
  LinearIsometry.inner_map_map]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace 𝕜 F
f : E →ₗᵢ[𝕜] F
U V : Submodule 𝕜 E
h : ∀ (u : E), u ∈ U → ∀ (v : E), v ∈ V → inner u v = 0
⊢ ∀ (u : F), u ∈ Submodule.map f U → ∀ (v : F), v ∈ Submodule.map f V → inner u v = 0

tactic: exact h
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace 𝕜 F
f : E →ₗᵢ[𝕜] F
U V : Submodule 𝕜 E
h : ∀ (u : E), u ∈ U → ∀ (v : E), v ∈ V → inner u v = 0
⊢ ∀ (a : E), a ∈ U → ∀ (a_2 : E), a_2 ∈ V → inner a a_2 = 0
Theorem: Equiv.Perm.card_support_prod_list_of_pairwise_disjoint
File: Mathlib/GroupTheory/Perm/Support.lean

tactic: induction' l with a t ih
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
l : List (Perm α)
h : List.Pairwise Disjoint l
⊢ card (support (List.prod l)) = List.sum (List.map (card ∘ support) l)

tactic: exact card_support_eq_zero.mpr rfl
state_before: case nil
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
l : List (Perm α)
h✝ : List.Pairwise Disjoint l
h : List.Pairwise Disjoint []
⊢ card (support (List.prod [])) = List.sum (List.map (card ∘ support) [])

tactic: obtain ⟨ha, ht⟩ := List.pairwise_cons.1 h
state_before: case cons
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
l : List (Perm α)
h✝ : List.Pairwise Disjoint l
a : Perm α
t : List (Perm α)
ih : List.Pairwise Disjoint t → card (support (List.prod t)) = List.sum (List.map (card ∘ support) t)
h : List.Pairwise Disjoint (a :: t)
⊢ card (support (List.prod (a :: t))) = List.sum (List.map (card ∘ support) (a :: t))

tactic: rw [List.prod_cons, List.map_cons, List.sum_cons, ← ih ht]
state_before: case cons.intro
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
l : List (Perm α)
h✝ : List.Pairwise Disjoint l
a : Perm α
t : List (Perm α)
ih : List.Pairwise Disjoint t → card (support (List.prod t)) = List.sum (List.map (card ∘ support) t)
h : List.Pairwise Disjoint (a :: t)
ha : ∀ (a' : Perm α), a' ∈ t → Disjoint a a'
ht : List.Pairwise Disjoint t
⊢ card (support (List.prod (a :: t))) = List.sum (List.map (card ∘ support) (a :: t))

tactic: exact (disjoint_prod_right _ ha).card_support_mul
state_before: case cons.intro
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
l : List (Perm α)
h✝ : List.Pairwise Disjoint l
a : Perm α
t : List (Perm α)
ih : List.Pairwise Disjoint t → card (support (List.prod t)) = List.sum (List.map (card ∘ support) t)
h : List.Pairwise Disjoint (a :: t)
ha : ∀ (a' : Perm α), a' ∈ t → Disjoint a a'
ht : List.Pairwise Disjoint t
⊢ card (support (a * List.prod t)) = (card ∘ support) a + card (support (List.prod t))
Theorem: Matrix.row_smul
File: Mathlib/Data/Matrix/Basic.lean

tactic: ext
state_before: l : Type ?u.1213482
m : Type u_2
n : Type ?u.1213488
o : Type ?u.1213491
m' : o → Type ?u.1213496
n' : o → Type ?u.1213501
R : Type u_1
S : Type ?u.1213507
α : Type v
β : Type w
γ : Type ?u.1213514
inst✝ : SMul R α
x : R
v : m → α
⊢ row (x • v) = x • row v

tactic: rfl
state_before: case a.h
l : Type ?u.1213482
m : Type u_2
n : Type ?u.1213488
o : Type ?u.1213491
m' : o → Type ?u.1213496
n' : o → Type ?u.1213501
R : Type u_1
S : Type ?u.1213507
α : Type v
β : Type w
γ : Type ?u.1213514
inst✝ : SMul R α
x : R
v : m → α
i✝ : Unit
x✝ : m
⊢ row (x • v) i✝ x✝ = (x • row v) i✝ x✝
Theorem: PiLp.nnnorm_eq_ciSup
File: Mathlib/Analysis/NormedSpace/PiLp.lean

tactic: ext
state_before: p : ℝ≥0∞
𝕜 : Type ?u.236805
𝕜' : Type ?u.236808
ι : Type u_2
α : ι → Type ?u.236816
β✝ : ι → Type ?u.236821
inst✝² : Fintype ι
inst✝¹ : Fact (1 ≤ p)
β : ι → Type u_1
inst✝ : (i : ι) → SeminormedAddCommGroup (β i)
f : PiLp ⊤ β
⊢ ‖f‖₊ = ⨆ (i : ι), ‖f i‖₊

tactic: simp [NNReal.coe_iSup, norm_eq_ciSup]
state_before: case a
p : ℝ≥0∞
𝕜 : Type ?u.236805
𝕜' : Type ?u.236808
ι : Type u_2
α : ι → Type ?u.236816
β✝ : ι → Type ?u.236821
inst✝² : Fintype ι
inst✝¹ : Fact (1 ≤ p)
β : ι → Type u_1
inst✝ : (i : ι) → SeminormedAddCommGroup (β i)
f : PiLp ⊤ β
⊢ ↑‖f‖₊ = ↑(⨆ (i : ι), ‖f i‖₊)
Theorem: List.indexesValues_eq_filter_enum
File: Mathlib/Data/List/Indexes.lean

tactic: simp [indexesValues, foldrIdx_eq_foldr_enum, uncurry, filter_eq_foldr]
state_before: α : Type u
β : Type v
p : α → Prop
inst✝ : DecidablePred p
as : List α
⊢ indexesValues (fun b => decide (p b)) as = filter ((fun b => decide (p b)) ∘ Prod.snd) (enum as)