tasksource/leandojo huggingface dataset:
Theorem: Int.add_assoc
File: Std/Data/Int/Lemmas.lean

tactic: rw [Int.add_comm, ← aux1, Int.add_comm k, aux1, Int.add_comm b]
state_before: m : Nat
b : Int
k : Nat
⊢ ↑m + b + ↑k = ↑m + (b + ↑k)

tactic: rw [Int.add_comm, Int.add_comm a, ← aux1, Int.add_comm a, Int.add_comm k]
state_before: a : Int
n k : Nat
⊢ a + ↑n + ↑k = a + (↑n + ↑k)

tactic: rw [Int.add_comm, ← aux2, Int.add_comm n, ← aux2, Int.add_comm -[m+1]]
state_before: m n k : Nat
⊢ -[m+1] + ↑n + -[k+1] = -[m+1] + (↑n + -[k+1])

tactic: rw [Int.add_comm, Int.add_comm m, Int.add_comm m, ← aux2, Int.add_comm -[k+1]]
state_before: m n k : Nat
⊢ ↑m + -[n+1] + -[k+1] = ↑m + (-[n+1] + -[k+1])

tactic: simp [add_succ, Nat.add_comm, Nat.add_left_comm, neg_ofNat_succ]
state_before: m n k : Nat
⊢ -[m+1] + -[n+1] + -[k+1] = -[m+1] + (-[n+1] + -[k+1])

tactic: simp [Nat.add_assoc]
state_before: x✝² x✝¹ x✝ : Int
m n k : Nat
⊢ ↑m + ↑n + ↑k = ↑m + (↑n + ↑k)

tactic: simp [subNatNat_add]
state_before: x✝² x✝¹ x✝ : Int
m n k : Nat
⊢ ↑m + ↑n + -[k+1] = ↑m + (↑n + -[k+1])

tactic: simp [add_succ]
state_before: x✝² x✝¹ x✝ : Int
m n k : Nat
⊢ -[m+1] + -[n+1] + ↑k = -[m+1] + (-[n+1] + ↑k)

tactic: rw [Int.add_comm, subNatNat_add_negSucc]
state_before: x✝² x✝¹ x✝ : Int
m n k : Nat
⊢ subNatNat k (succ (succ (m + n))) = -[m+1] + subNatNat k (succ n)

tactic: simp [add_succ, succ_add, Nat.add_comm]
state_before: x✝² x✝¹ x✝ : Int
m n k : Nat
⊢ subNatNat k (succ (succ (m + n))) = subNatNat k (succ n + succ m)
Theorem: not_small_type
File: Mathlib/Logic/Small/Basic.lean

tactic: dsimp at e
state_before: S : Type u
e✝ : Type (max u v) ≃ S
a b : Set ((α : S) × ↑e✝.symm α)
e :
  (fun a =>
        { fst := Equiv.toFun e✝ (Set ((α : S) × ↑e✝.symm α)),
          snd :=
            cast (_ : Set ((α : S) × ↑e✝.symm α) = Equiv.invFun e✝ (Equiv.toFun e✝ (Set ((α : S) × ↑e✝.symm α)))) a })
      a =
    (fun a =>
        { fst := Equiv.toFun e✝ (Set ((α : S) × ↑e✝.symm α)),
          snd :=
            cast (_ : Set ((α : S) × ↑e✝.symm α) = Equiv.invFun e✝ (Equiv.toFun e✝ (Set ((α : S) × ↑e✝.symm α)))) a })
      b
⊢ a = b

tactic: injection e with h₁ h₂
state_before: S : Type u
e✝ : Type (max u v) ≃ S
a b : Set ((α : S) × ↑e✝.symm α)
e :
  { fst := ↑e✝ (Set ((α : S) × ↑e✝.symm α)),
      snd := cast (_ : Set ((α : S) × ↑e✝.symm α) = ↑e✝.symm (↑e✝ (Set ((α : S) × ↑e✝.symm α)))) a } =
    { fst := ↑e✝ (Set ((α : S) × ↑e✝.symm α)),
      snd := cast (_ : Set ((α : S) × ↑e✝.symm α) = ↑e✝.symm (↑e✝ (Set ((α : S) × ↑e✝.symm α)))) b }
⊢ a = b

tactic: simpa using h₂
state_before: S : Type u
e : Type (max u v) ≃ S
a b : Set ((α : S) × ↑e.symm α)
h₁ : ↑e (Set ((α : S) × ↑e.symm α)) = ↑e (Set ((α : S) × ↑e.symm α))
h₂ :
  cast (_ : Set ((α : S) × ↑e.symm α) = ↑e.symm (↑e (Set ((α : S) × ↑e.symm α)))) a =
    cast (_ : Set ((α : S) × ↑e.symm α) = ↑e.symm (↑e (Set ((α : S) × ↑e.symm α)))) b
⊢ a = b
Theorem: Equiv.Perm.orderOf_cycleOf_dvd_orderOf
File: Mathlib/GroupTheory/Perm/Cycle/Type.lean

tactic: by_cases hx : f x = x
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
f : Perm α
x : α
⊢ orderOf (cycleOf f x) ∣ orderOf f

tactic: rw [← cycleOf_eq_one_iff] at hx
state_before: case pos
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
f : Perm α
x : α
hx : ↑f x = x
⊢ orderOf (cycleOf f x) ∣ orderOf f

tactic: simp [hx]
state_before: case pos
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
f : Perm α
x : α
hx✝ : ↑f x = x
hx : cycleOf f x = 1
⊢ orderOf (cycleOf f x) ∣ orderOf f

tactic: refine dvd_of_mem_cycleType ?_
state_before: case neg
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
f : Perm α
x : α
hx : ¬↑f x = x
⊢ orderOf (cycleOf f x) ∣ orderOf f

tactic: rw [cycleType, Multiset.mem_map]
state_before: case neg
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
f : Perm α
x : α
hx : ¬↑f x = x
⊢ orderOf (cycleOf f x) ∈ cycleType f

tactic: refine' ⟨f.cycleOf x, _, _⟩
state_before: case neg
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
f : Perm α
x : α
hx : ¬↑f x = x
⊢ ∃ a, a ∈ (cycleFactorsFinset f).val ∧ (Finset.card ∘ support) a = orderOf (cycleOf f x)

tactic: rwa [← Finset.mem_def, cycleOf_mem_cycleFactorsFinset_iff, mem_support]
state_before: case neg.refine'_1
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
f : Perm α
x : α
hx : ¬↑f x = x
⊢ cycleOf f x ∈ (cycleFactorsFinset f).val

tactic: simp [(isCycle_cycleOf _ hx).orderOf]
state_before: case neg.refine'_2
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
f : Perm α
x : α
hx : ¬↑f x = x
⊢ (Finset.card ∘ support) (cycleOf f x) = orderOf (cycleOf f x)
Theorem: MeasureTheory.Integrable.exists_boundedContinuous_lintegral_sub_le
File: Mathlib/MeasureTheory/Function/ContinuousMapDense.lean

tactic: simp only [← memℒp_one_iff_integrable, ← snorm_one_eq_lintegral_nnnorm] at hf ⊢
state_before: α : Type u_1
inst✝⁶ : MeasurableSpace α
inst✝⁵ : TopologicalSpace α
inst✝⁴ : NormalSpace α
inst✝³ : BorelSpace α
E : Type u_2
inst✝² : NormedAddCommGroup E
μ : Measure α
p : ℝ≥0∞
inst✝¹ : NormedSpace ℝ E
inst✝ : Measure.WeaklyRegular μ
f : α → E
hf : Integrable f
ε : ℝ≥0∞
hε : ε ≠ 0
⊢ ∃ g, (∫⁻ (x : α), ↑‖f x - ↑g x‖₊ ∂μ) ≤ ε ∧ Integrable ↑g

tactic: exact hf.exists_boundedContinuous_snorm_sub_le ENNReal.one_ne_top hε
state_before: α : Type u_1
inst✝⁶ : MeasurableSpace α
inst✝⁵ : TopologicalSpace α
inst✝⁴ : NormalSpace α
inst✝³ : BorelSpace α
E : Type u_2
inst✝² : NormedAddCommGroup E
μ : Measure α
p : ℝ≥0∞
inst✝¹ : NormedSpace ℝ E
inst✝ : Measure.WeaklyRegular μ
f : α → E
ε : ℝ≥0∞
hε : ε ≠ 0
hf : Memℒp f 1
⊢ ∃ g, snorm (fun x => f x - ↑g x) 1 μ ≤ ε ∧ Memℒp (↑g) 1
Theorem: LinearMap.span_singleton_sup_orthogonal_eq_top
File: Mathlib/LinearAlgebra/SesquilinearForm.lean

tactic: rw [orthogonal_span_singleton_eq_to_lin_ker]
state_before: R : Type ?u.260339
R₁ : Type ?u.260342
R₂ : Type ?u.260345
R₃ : Type ?u.260348
M : Type ?u.260351
M₁ : Type ?u.260354
M₂ : Type ?u.260357
Mₗ₁ : Type ?u.260360
Mₗ₁' : Type ?u.260363
Mₗ₂ : Type ?u.260366
Mₗ₂' : Type ?u.260369
K : Type u_1
K₁ : Type ?u.260375
K₂ : Type ?u.260378
V : Type u_2
V₁ : Type ?u.260384
V₂ : Type ?u.260387
n : Type ?u.260390
inst✝⁵ : Field K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
inst✝² : Field K₁
inst✝¹ : AddCommGroup V₁
inst✝ : Module K₁ V₁
J : K →+* K
J₁ J₁' : K₁ →+* K
B : V →ₗ[K] V →ₗ[K] K
x : V
hx : ¬IsOrtho B x x
⊢ Submodule.span K {x} ⊔ Submodule.orthogonalBilin (Submodule.span K {x}) B = ⊤

tactic: exact (B x).span_singleton_sup_ker_eq_top hx
state_before: R : Type ?u.260339
R₁ : Type ?u.260342
R₂ : Type ?u.260345
R₃ : Type ?u.260348
M : Type ?u.260351
M₁ : Type ?u.260354
M₂ : Type ?u.260357
Mₗ₁ : Type ?u.260360
Mₗ₁' : Type ?u.260363
Mₗ₂ : Type ?u.260366
Mₗ₂' : Type ?u.260369
K : Type u_1
K₁ : Type ?u.260375
K₂ : Type ?u.260378
V : Type u_2
V₁ : Type ?u.260384
V₂ : Type ?u.260387
n : Type ?u.260390
inst✝⁵ : Field K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
inst✝² : Field K₁
inst✝¹ : AddCommGroup V₁
inst✝ : Module K₁ V₁
J : K →+* K
J₁ J₁' : K₁ →+* K
B : V →ₗ[K] V →ₗ[K] K
x : V
hx : ¬IsOrtho B x x
⊢ Submodule.span K {x} ⊔ ker (↑B x) = ⊤
Theorem: integral_sin_sq
File: Mathlib/Analysis/SpecialFunctions/Integrals.lean

tactic: field_simp [integral_sin_pow, add_sub_assoc]
state_before: a b : ℝ
n : ℕ
⊢ (∫ (x : ℝ) in a..b, sin x ^ 2) = (sin a * cos a - sin b * cos b + b - a) / 2
Theorem: IsROrC.re_eq_add_conj
File: Mathlib/Data/IsROrC/Basic.lean

tactic: rw [add_conj, mul_div_cancel_left (re z : K) two_ne_zero]
state_before: K : Type u_1
E : Type ?u.3487608
inst✝ : IsROrC K
z : K
⊢ ↑(↑re z) = (z + ↑(starRingEnd K) z) / 2
Theorem: Submonoid.LocalizationMap.map_right_cancel
File: Mathlib/GroupTheory/MonoidLocalization.lean

tactic: rw [f.toMap.map_mul, f.toMap.map_mul] at h
state_before: M : Type u_1
inst✝² : CommMonoid M
S : Submonoid M
N : Type u_2
inst✝¹ : CommMonoid N
P : Type ?u.626659
inst✝ : CommMonoid P
f : LocalizationMap S N
x y : M
c : { x // x ∈ S }
h : ↑(toMap f) (↑c * x) = ↑(toMap f) (↑c * y)
⊢ ↑(toMap f) x = ↑(toMap f) y

tactic: cases' f.map_units c with u hu
state_before: M : Type u_1
inst✝² : CommMonoid M
S : Submonoid M
N : Type u_2
inst✝¹ : CommMonoid N
P : Type ?u.626659
inst✝ : CommMonoid P
f : LocalizationMap S N
x y : M
c : { x // x ∈ S }
h : ↑(toMap f) ↑c * ↑(toMap f) x = ↑(toMap f) ↑c * ↑(toMap f) y
⊢ ↑(toMap f) x = ↑(toMap f) y

tactic: rw [← hu] at h
state_before: case intro
M : Type u_1
inst✝² : CommMonoid M
S : Submonoid M
N : Type u_2
inst✝¹ : CommMonoid N
P : Type ?u.626659
inst✝ : CommMonoid P
f : LocalizationMap S N
x y : M
c : { x // x ∈ S }
h : ↑(toMap f) ↑c * ↑(toMap f) x = ↑(toMap f) ↑c * ↑(toMap f) y
u : ((fun x => N) ↑c)ˣ
hu : ↑u = ↑(toMap f) ↑c
⊢ ↑(toMap f) x = ↑(toMap f) y

tactic: exact (Units.mul_right_inj u).1 h
state_before: case intro
M : Type u_1
inst✝² : CommMonoid M
S : Submonoid M
N : Type u_2
inst✝¹ : CommMonoid N
P : Type ?u.626659
inst✝ : CommMonoid P
f : LocalizationMap S N
x y : M
c : { x // x ∈ S }
u : ((fun x => N) ↑c)ˣ
h : ↑u * ↑(toMap f) x = ↑u * ↑(toMap f) y
hu : ↑u = ↑(toMap f) ↑c
⊢ ↑(toMap f) x = ↑(toMap f) y
Theorem: Filter.Eventually.atTop_of_arithmetic
File: Mathlib/Order/Filter/AtTopBot.lean

tactic: simp only [eventually_atTop] at hp ⊢
state_before: ι : Type ?u.63705
ι' : Type ?u.63708
α : Type ?u.63711
β : Type ?u.63714
γ : Type ?u.63717
p : ℕ → Prop
n : ℕ
hn : n ≠ 0
hp : ∀ (k : ℕ), k < n → ∀ᶠ (a : ℕ) in atTop, p (n * a + k)
⊢ ∀ᶠ (a : ℕ) in atTop, p a

tactic: choose! N hN using hp
state_before: ι : Type ?u.63705
ι' : Type ?u.63708
α : Type ?u.63711
β : Type ?u.63714
γ : Type ?u.63717
p : ℕ → Prop
n : ℕ
hn : n ≠ 0
hp : ∀ (k : ℕ), k < n → ∃ a, ∀ (b : ℕ), b ≥ a → p (n * b + k)
⊢ ∃ a, ∀ (b : ℕ), b ≥ a → p b

tactic: rw [← Nat.div_add_mod b n]
state_before: ι : Type ?u.63705
ι' : Type ?u.63708
α : Type ?u.63711
β : Type ?u.63714
γ : Type ?u.63717
p : ℕ → Prop
n : ℕ
hn : n ≠ 0
N : ℕ → ℕ
hN : ∀ (k : ℕ), k < n → ∀ (b : ℕ), b ≥ N k → p (n * b + k)
b : ℕ
hb : b ≥ Finset.sup (Finset.range n) fun x => n * N x
⊢ p b

tactic: have hlt := Nat.mod_lt b hn.bot_lt
state_before: ι : Type ?u.63705
ι' : Type ?u.63708
α : Type ?u.63711
β : Type ?u.63714
γ : Type ?u.63717
p : ℕ → Prop
n : ℕ
hn : n ≠ 0
N : ℕ → ℕ
hN : ∀ (k : ℕ), k < n → ∀ (b : ℕ), b ≥ N k → p (n * b + k)
b : ℕ
hb : b ≥ Finset.sup (Finset.range n) fun x => n * N x
⊢ p (n * (b / n) + b % n)

tactic: refine hN _ hlt _ ?_
state_before: ι : Type ?u.63705
ι' : Type ?u.63708
α : Type ?u.63711
β : Type ?u.63714
γ : Type ?u.63717
p : ℕ → Prop
n : ℕ
hn : n ≠ 0
N : ℕ → ℕ
hN : ∀ (k : ℕ), k < n → ∀ (b : ℕ), b ≥ N k → p (n * b + k)
b : ℕ
hb : b ≥ Finset.sup (Finset.range n) fun x => n * N x
hlt : b % n < n
⊢ p (n * (b / n) + b % n)

tactic: rw [ge_iff_le, Nat.le_div_iff_mul_le hn.bot_lt, mul_comm]
state_before: ι : Type ?u.63705
ι' : Type ?u.63708
α : Type ?u.63711
β : Type ?u.63714
γ : Type ?u.63717
p : ℕ → Prop
n : ℕ
hn : n ≠ 0
N : ℕ → ℕ
hN : ∀ (k : ℕ), k < n → ∀ (b : ℕ), b ≥ N k → p (n * b + k)
b : ℕ
hb : b ≥ Finset.sup (Finset.range n) fun x => n * N x
hlt : b % n < n
⊢ b / n ≥ N (b % n)
Theorem: Complex.cosh_sub_sinh
File: Mathlib/Data/Complex/Exponential.lean

tactic: rw [← mul_right_inj' (two_ne_zero' ℂ), mul_sub, two_cosh, two_sinh, add_sub_sub_cancel, two_mul]
state_before: x y : ℂ
⊢ cosh x - sinh x = exp (-x)
Theorem: CategoryTheory.Limits.imageMonoIsoSource_hom_self
File: Mathlib/CategoryTheory/Limits/Shapes/Images.lean

tactic: simp only [← imageMonoIsoSource_inv_ι f]
state_before: C : Type u
inst✝¹ : Category C
X Y : C
f : X ⟶ Y
inst✝ : Mono f
⊢ (imageMonoIsoSource f).hom ≫ f = image.ι f

tactic: rw [← Category.assoc, Iso.hom_inv_id, Category.id_comp]
state_before: C : Type u
inst✝¹ : Category C
X Y : C
f : X ⟶ Y
inst✝ : Mono f
⊢ (imageMonoIsoSource f).hom ≫ (imageMonoIsoSource f).inv ≫ image.ι f = image.ι f
Theorem: NormedSpace.isVonNBounded_iff'
File: Mathlib/Analysis/LocallyConvex/Bounded.lean

tactic: rw [NormedSpace.isVonNBounded_iff, ← Metric.bounded_iff_isBounded, bounded_iff_forall_norm_le]
state_before: 𝕜 : Type u_2
𝕜' : Type ?u.254043
E : Type u_1
E' : Type ?u.254049
F : Type ?u.254052
ι : Type ?u.254055
inst✝² : NontriviallyNormedField 𝕜
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
s : Set E
⊢ Bornology.IsVonNBounded 𝕜 s ↔ ∃ r, ∀ (x : E), x ∈ s → ‖x‖ ≤ r
Theorem: Set.image_const_sub_Ioo
File: Mathlib/Data/Set/Pointwise/Interval.lean

tactic: have := image_comp (fun x => a + x) fun x => -x
state_before: α : Type u_1
inst✝ : OrderedAddCommGroup α
a b c : α
⊢ (fun x => a - x) '' Ioo b c = Ioo (a - c) (a - b)

tactic: dsimp [Function.comp] at this
state_before: α : Type u_1
inst✝ : OrderedAddCommGroup α
a b c : α
this : ∀ (a_1 : Set α), ((fun x => a + x) ∘ fun x => -x) '' a_1 = (fun x => a + x) '' ((fun x => -x) '' a_1)
⊢ (fun x => a - x) '' Ioo b c = Ioo (a - c) (a - b)

tactic: simp [sub_eq_add_neg, this, add_comm]
state_before: α : Type u_1
inst✝ : OrderedAddCommGroup α
a b c : α
this : ∀ (a_1 : Set α), (fun x => a + -x) '' a_1 = (fun x => a + x) '' ((fun x => -x) '' a_1)
⊢ (fun x => a - x) '' Ioo b c = Ioo (a - c) (a - b)
Theorem: Multiset.bind_map
File: Mathlib/Data/Multiset/Bind.lean

tactic: simp
state_before: α : Type u_1
β : Type u_3
γ : Type u_2
δ : Type ?u.31281
a : α
s t : Multiset α
f✝ g : α → Multiset β
m : Multiset α
n : β → Multiset γ
f : α → β
⊢ bind (map f 0) n = bind 0 fun a => n (f a)

tactic: simp (config := { contextual := true })
state_before: α : Type u_1
β : Type u_3
γ : Type u_2
δ : Type ?u.31281
a : α
s t : Multiset α
f✝ g : α → Multiset β
m : Multiset α
n : β → Multiset γ
f : α → β
⊢ ∀ ⦃a : α⦄ {s : Multiset α},
    (bind (map f s) n = bind s fun a => n (f a)) → bind (map f (a ::ₘ s)) n = bind (a ::ₘ s) fun a => n (f a)
Theorem: CategoryTheory.Preadditive.isCoseparator_iff
File: Mathlib/CategoryTheory/Preadditive/Generator.lean

tactic: simpa only [Limits.zero_comp] using hf
state_before: C : Type u
inst✝¹ : Category C
inst✝ : Preadditive C
G : C
hG : IsCoseparator G
X Y : C
f : X ⟶ Y
hf : ∀ (h : Y ⟶ G), f ≫ h = 0
⊢ ∀ (h : Y ⟶ G), f ≫ h = 0 ≫ h

tactic: simpa only [Preadditive.sub_comp, sub_eq_zero] using hfg
state_before: C : Type u
inst✝¹ : Category C
inst✝ : Preadditive C
G : C
hG : ∀ ⦃X Y : C⦄ (f : X ⟶ Y), (∀ (h : Y ⟶ G), f ≫ h = 0) → f = 0
X Y : C
f g : X ⟶ Y
hfg : ∀ (h : Y ⟶ G), f ≫ h = g ≫ h
⊢ ∀ (h : Y ⟶ G), (f - g) ≫ h = 0
Theorem: Nat.factorization_le_factorization_mul_right
File: Mathlib/Data/Nat/Factorization/Basic.lean

tactic: rw [mul_comm]
state_before: a b : ℕ
ha : a ≠ 0
⊢ factorization b ≤ factorization (a * b)

tactic: apply factorization_le_factorization_mul_left ha
state_before: a b : ℕ
ha : a ≠ 0
⊢ factorization b ≤ factorization (b * a)
Theorem: CategoryTheory.Grpd.piIsoPi_hom_π
File: Mathlib/CategoryTheory/Category/Grpd.lean

tactic: simp [piIsoPi]
state_before: J : Type u
f : J → Grpd
j : J
⊢ (piIsoPi J f).hom ≫ Limits.Pi.π f j = Pi.eval (fun i => ↑(f i)) j

tactic: rfl
state_before: J : Type u
f : J → Grpd
j : J
⊢ (piLimitFan f).π.app { as := j } = Pi.eval (fun i => ↑(f i)) j
Theorem: MeasureTheory.integrable_prod_iff'
File: Mathlib/MeasureTheory/Constructions/Prod/Integral.lean

tactic: convert integrable_prod_iff h1f.prod_swap using 1
state_before: α : Type u_1
α' : Type ?u.2403525
β : Type u_2
β' : Type ?u.2403531
γ : Type ?u.2403534
E : Type u_3
inst✝⁷ : MeasurableSpace α
inst✝⁶ : MeasurableSpace α'
inst✝⁵ : MeasurableSpace β
inst✝⁴ : MeasurableSpace β'
inst✝³ : MeasurableSpace γ
μ μ' : Measure α
ν ν' : Measure β
τ : Measure γ
inst✝² : NormedAddCommGroup E
inst✝¹ : SigmaFinite ν
inst✝ : SigmaFinite μ
f : α × β → E
h1f : AEStronglyMeasurable f (Measure.prod μ ν)
⊢ Integrable f ↔ (∀ᵐ (y : β) ∂ν, Integrable fun x => f (x, y)) ∧ Integrable fun y => ∫ (x : α), ‖f (x, y)‖ ∂μ

tactic: rw [funext fun _ => Function.comp_apply.symm, integrable_swap_iff]
state_before: case h.e'_1.a
α : Type u_1
α' : Type ?u.2403525
β : Type u_2
β' : Type ?u.2403531
γ : Type ?u.2403534
E : Type u_3
inst✝⁷ : MeasurableSpace α
inst✝⁶ : MeasurableSpace α'
inst✝⁵ : MeasurableSpace β
inst✝⁴ : MeasurableSpace β'
inst✝³ : MeasurableSpace γ
μ μ' : Measure α
ν ν' : Measure β
τ : Measure γ
inst✝² : NormedAddCommGroup E
inst✝¹ : SigmaFinite ν
inst✝ : SigmaFinite μ
f : α × β → E
h1f : AEStronglyMeasurable f (Measure.prod μ ν)
⊢ Integrable f ↔ Integrable fun z => f (Prod.swap z)
Theorem: mul_left_surjective₀
File: Mathlib/Algebra/GroupWithZero/Basic.lean

tactic: simp [← mul_assoc, mul_inv_cancel h]
state_before: α : Type ?u.29573
M₀ : Type ?u.29576
G₀ : Type u_1
M₀' : Type ?u.29582
G₀' : Type ?u.29585
F : Type ?u.29588
F' : Type ?u.29591
inst✝ : GroupWithZero G₀
a✝ b c a : G₀
h : a ≠ 0
g : G₀
⊢ (fun g => a * g) (a⁻¹ * g) = g
Theorem: Lagrange.eq_interpolate_iff
File: Mathlib/LinearAlgebra/Lagrange.lean

tactic: constructor <;> intro h
state_before: F : Type u_1
inst✝¹ : Field F
ι : Type u_2
inst✝ : DecidableEq ι
s t : Finset ι
i j : ι
v r r' : ι → F
f : F[X]
hvs : Set.InjOn v ↑s
⊢ (degree f < ↑(card s) ∧ ∀ (i : ι), i ∈ s → eval (v i) f = r i) ↔ f = ↑(interpolate s v) r

tactic: exact eq_interpolate_of_eval_eq _ hvs h.1 h.2
state_before: case mp
F : Type u_1
inst✝¹ : Field F
ι : Type u_2
inst✝ : DecidableEq ι
s t : Finset ι
i j : ι
v r r' : ι → F
f : F[X]
hvs : Set.InjOn v ↑s
h : degree f < ↑(card s) ∧ ∀ (i : ι), i ∈ s → eval (v i) f = r i
⊢ f = ↑(interpolate s v) r

tactic: rw [h]
state_before: case mpr
F : Type u_1
inst✝¹ : Field F
ι : Type u_2
inst✝ : DecidableEq ι
s t : Finset ι
i j : ι
v r r' : ι → F
f : F[X]
hvs : Set.InjOn v ↑s
h : f = ↑(interpolate s v) r
⊢ degree f < ↑(card s) ∧ ∀ (i : ι), i ∈ s → eval (v i) f = r i

tactic: exact ⟨degree_interpolate_lt _ hvs, fun _ hi => eval_interpolate_at_node _ hvs hi⟩
state_before: case mpr
F : Type u_1
inst✝¹ : Field F
ι : Type u_2
inst✝ : DecidableEq ι
s t : Finset ι
i j : ι
v r r' : ι → F
f : F[X]
hvs : Set.InjOn v ↑s
h : f = ↑(interpolate s v) r
⊢ degree (↑(interpolate s v) r) < ↑(card s) ∧ ∀ (i : ι), i ∈ s → eval (v i) (↑(interpolate s v) r) = r i
Theorem: LinearMap.ker_eq_bot_of_cancel
File: Mathlib/LinearAlgebra/Basic.lean

tactic: have h₁ : f.comp (0 : ker f →ₗ[R] M) = 0 := comp_zero _
state_before: R : Type u_1
R₁ : Type ?u.1573042
R₂ : Type u_2
R₃ : Type ?u.1573048
R₄ : Type ?u.1573051
S : Type ?u.1573054
K : Type ?u.1573057
K₂ : Type ?u.1573060
M : Type u_3
M' : Type ?u.1573066
M₁ : Type ?u.1573069
M₂ : Type u_4
M₃ : Type ?u.1573075
M₄ : Type ?u.1573078
N : Type ?u.1573081
N₂ : Type ?u.1573084
ι : Type ?u.1573087
V : Type ?u.1573090
V₂ : Type ?u.1573093
inst✝⁹ : Semiring R
inst✝⁸ : Semiring R₂
inst✝⁷ : Semiring R₃
inst✝⁶ : AddCommMonoid M
inst✝⁵ : AddCommMonoid M₂
inst✝⁴ : AddCommMonoid M₃
inst✝³ : Module R M
inst✝² : Module R₂ M₂
inst✝¹ : Module R₃ M₃
τ₁₂ : R →+* R₂
τ₂₃ : R₂ →+* R₃
τ₁₃ : R →+* R₃
inst✝ : RingHomCompTriple τ₁₂ τ₂₃ τ₁₃
f : M →ₛₗ[τ₁₂] M₂
h : ∀ (u v : { x // x ∈ ker f } →ₗ[R] M), comp f u = comp f v → u = v
⊢ ker f = ⊥

tactic: rw [← Submodule.range_subtype (ker f),
  ← h 0 f.ker.subtype (Eq.trans h₁ (comp_ker_subtype f).symm)]
state_before: R : Type u_1
R₁ : Type ?u.1573042
R₂ : Type u_2
R₃ : Type ?u.1573048
R₄ : Type ?u.1573051
S : Type ?u.1573054
K : Type ?u.1573057
K₂ : Type ?u.1573060
M : Type u_3
M' : Type ?u.1573066
M₁ : Type ?u.1573069
M₂ : Type u_4
M₃ : Type ?u.1573075
M₄ : Type ?u.1573078
N : Type ?u.1573081
N₂ : Type ?u.1573084
ι : Type ?u.1573087
V : Type ?u.1573090
V₂ : Type ?u.1573093
inst✝⁹ : Semiring R
inst✝⁸ : Semiring R₂
inst✝⁷ : Semiring R₃
inst✝⁶ : AddCommMonoid M
inst✝⁵ : AddCommMonoid M₂
inst✝⁴ : AddCommMonoid M₃
inst✝³ : Module R M
inst✝² : Module R₂ M₂
inst✝¹ : Module R₃ M₃
τ₁₂ : R →+* R₂
τ₂₃ : R₂ →+* R₃
τ₁₃ : R →+* R₃
inst✝ : RingHomCompTriple τ₁₂ τ₂₃ τ₁₃
f : M →ₛₗ[τ₁₂] M₂
h : ∀ (u v : { x // x ∈ ker f } →ₗ[R] M), comp f u = comp f v → u = v
h₁ : comp f 0 = 0
⊢ ker f = ⊥

tactic: exact range_zero
state_before: R : Type u_1
R₁ : Type ?u.1573042
R₂ : Type u_2
R₃ : Type ?u.1573048
R₄ : Type ?u.1573051
S : Type ?u.1573054
K : Type ?u.1573057
K₂ : Type ?u.1573060
M : Type u_3
M' : Type ?u.1573066
M₁ : Type ?u.1573069
M₂ : Type u_4
M₃ : Type ?u.1573075
M₄ : Type ?u.1573078
N : Type ?u.1573081
N₂ : Type ?u.1573084
ι : Type ?u.1573087
V : Type ?u.1573090
V₂ : Type ?u.1573093
inst✝⁹ : Semiring R
inst✝⁸ : Semiring R₂
inst✝⁷ : Semiring R₃
inst✝⁶ : AddCommMonoid M
inst✝⁵ : AddCommMonoid M₂
inst✝⁴ : AddCommMonoid M₃
inst✝³ : Module R M
inst✝² : Module R₂ M₂
inst✝¹ : Module R₃ M₃
τ₁₂ : R →+* R₂
τ₂₃ : R₂ →+* R₃
τ₁₃ : R →+* R₃
inst✝ : RingHomCompTriple τ₁₂ τ₂₃ τ₁₃
f : M →ₛₗ[τ₁₂] M₂
h : ∀ (u v : { x // x ∈ ker f } →ₗ[R] M), comp f u = comp f v → u = v
h₁ : comp f 0 = 0
⊢ range 0 = ⊥
Theorem: ContinuousLinearMap.smul_compLpL
File: Mathlib/MeasureTheory/Function/LpSpace.lean

tactic: ext1 f
state_before: α : Type u_5
E : Type u_4
F : Type u_2
G : Type ?u.7594842
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : MeasureTheory.Measure α
inst✝¹⁰ : NormedAddCommGroup E
inst✝⁹ : NormedAddCommGroup F
inst✝⁸ : NormedAddCommGroup G
g : E → F
c✝ : ℝ≥0
𝕜 : Type u_3
inst✝⁷ : NontriviallyNormedField 𝕜
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : NormedSpace 𝕜 F
inst✝⁴ : Fact (1 ≤ p)
𝕜' : Type u_1
inst✝³ : NormedRing 𝕜'
inst✝² : Module 𝕜' F
inst✝¹ : BoundedSMul 𝕜' F
inst✝ : SMulCommClass 𝕜 𝕜' F
c : 𝕜'
L : E →L[𝕜] F
⊢ compLpL p μ (c • L) = c • compLpL p μ L

tactic: exact smul_compLp c L f
state_before: case h
α : Type u_5
E : Type u_4
F : Type u_2
G : Type ?u.7594842
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : MeasureTheory.Measure α
inst✝¹⁰ : NormedAddCommGroup E
inst✝⁹ : NormedAddCommGroup F
inst✝⁸ : NormedAddCommGroup G
g : E → F
c✝ : ℝ≥0
𝕜 : Type u_3
inst✝⁷ : NontriviallyNormedField 𝕜
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : NormedSpace 𝕜 F
inst✝⁴ : Fact (1 ≤ p)
𝕜' : Type u_1
inst✝³ : NormedRing 𝕜'
inst✝² : Module 𝕜' F
inst✝¹ : BoundedSMul 𝕜' F
inst✝ : SMulCommClass 𝕜 𝕜' F
c : 𝕜'
L : E →L[𝕜] F
f : { x // x ∈ Lp E p }
⊢ ↑(compLpL p μ (c • L)) f = ↑(c • compLpL p μ L) f