tasksource/leandojo huggingface dataset:
Theorem: Polynomial.toFinsupp_add
File: Mathlib/Data/Polynomial/Basic.lean

tactic: cases a
state_before: R : Type u
a✝ b✝ : R
m n : ℕ
inst✝ : Semiring R
p q a b : R[X]
⊢ (a + b).toFinsupp = a.toFinsupp + b.toFinsupp

tactic: cases b
state_before: case ofFinsupp
R : Type u
a b✝ : R
m n : ℕ
inst✝ : Semiring R
p q b : R[X]
toFinsupp✝ : AddMonoidAlgebra R ℕ
⊢ ({ toFinsupp := toFinsupp✝ } + b).toFinsupp = { toFinsupp := toFinsupp✝ }.toFinsupp + b.toFinsupp

tactic: rw [← ofFinsupp_add]
state_before: case ofFinsupp.ofFinsupp
R : Type u
a b : R
m n : ℕ
inst✝ : Semiring R
p q : R[X]
toFinsupp✝¹ toFinsupp✝ : AddMonoidAlgebra R ℕ
⊢ ({ toFinsupp := toFinsupp✝¹ } + { toFinsupp := toFinsupp✝ }).toFinsupp =
    { toFinsupp := toFinsupp✝¹ }.toFinsupp + { toFinsupp := toFinsupp✝ }.toFinsupp
Theorem: lie_jacobi
File: Mathlib/Algebra/Lie/Basic.lean

tactic: rw [← neg_neg ⁅x, y⁆, lie_neg z, lie_skew y x, ← lie_skew, lie_lie]
state_before: R : Type u
L : Type v
M : Type w
N : 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
inst✝³ : AddCommGroup N
inst✝² : Module R N
inst✝¹ : LieRingModule L N
inst✝ : LieModule R L N
t : R
x y z : L
m n : M
⊢ ⁅x, ⁅y, z⁆⁆ + ⁅y, ⁅z, x⁆⁆ + ⁅z, ⁅x, y⁆⁆ = 0

tactic: abel
state_before: R : Type u
L : Type v
M : Type w
N : 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
inst✝³ : AddCommGroup N
inst✝² : Module R N
inst✝¹ : LieRingModule L N
inst✝ : LieModule R L N
t : R
x y z : L
m n : M
⊢ -(⁅y, ⁅z, x⁆⁆ - ⁅z, ⁅y, x⁆⁆) + ⁅y, ⁅z, x⁆⁆ + -⁅z, ⁅y, x⁆⁆ = 0
Theorem: List.one_le_prod_of_one_le
File: Mathlib/Data/List/BigOperators/Basic.lean

tactic: induction' l with hd tl ih
state_before: ι : Type ?u.105808
α : Type ?u.105811
M : Type u_1
N : Type ?u.105817
P : Type ?u.105820
M₀ : Type ?u.105823
G : Type ?u.105826
R : Type ?u.105829
inst✝⁴ : Monoid M
inst✝³ : Monoid N
inst✝² : Monoid P
l✝ l₁ l₂ : List M
a : M
inst✝¹ : Preorder M
inst✝ : CovariantClass M M (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
l : List M
hl₁ : ∀ (x : M), x ∈ l → 1 ≤ x
⊢ 1 ≤ prod l

tactic: rw [prod_cons]
state_before: case cons
ι : Type ?u.105808
α : Type ?u.105811
M : Type u_1
N : Type ?u.105817
P : Type ?u.105820
M₀ : Type ?u.105823
G : Type ?u.105826
R : Type ?u.105829
inst✝⁴ : Monoid M
inst✝³ : Monoid N
inst✝² : Monoid P
l✝ l₁ l₂ : List M
a : M
inst✝¹ : Preorder M
inst✝ : CovariantClass M M (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
l : List M
hl₁✝ : ∀ (x : M), x ∈ l → 1 ≤ x
hd : M
tl : List M
ih : (∀ (x : M), x ∈ tl → 1 ≤ x) → 1 ≤ prod tl
hl₁ : ∀ (x : M), x ∈ hd :: tl → 1 ≤ x
⊢ 1 ≤ prod (hd :: tl)

tactic: exact one_le_mul (hl₁ hd (mem_cons_self hd tl)) (ih fun x h => hl₁ x (mem_cons_of_mem hd h))
state_before: case cons
ι : Type ?u.105808
α : Type ?u.105811
M : Type u_1
N : Type ?u.105817
P : Type ?u.105820
M₀ : Type ?u.105823
G : Type ?u.105826
R : Type ?u.105829
inst✝⁴ : Monoid M
inst✝³ : Monoid N
inst✝² : Monoid P
l✝ l₁ l₂ : List M
a : M
inst✝¹ : Preorder M
inst✝ : CovariantClass M M (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
l : List M
hl₁✝ : ∀ (x : M), x ∈ l → 1 ≤ x
hd : M
tl : List M
ih : (∀ (x : M), x ∈ tl → 1 ≤ x) → 1 ≤ prod tl
hl₁ : ∀ (x : M), x ∈ hd :: tl → 1 ≤ x
⊢ 1 ≤ hd * prod tl

tactic: rfl
state_before: case nil
ι : Type ?u.105808
α : Type ?u.105811
M : Type u_1
N : Type ?u.105817
P : Type ?u.105820
M₀ : Type ?u.105823
G : Type ?u.105826
R : Type ?u.105829
inst✝⁴ : Monoid M
inst✝³ : Monoid N
inst✝² : Monoid P
l✝ l₁ l₂ : List M
a : M
inst✝¹ : Preorder M
inst✝ : CovariantClass M M (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
l : List M
hl₁✝ : ∀ (x : M), x ∈ l → 1 ≤ x
hl₁ : ∀ (x : M), x ∈ [] → 1 ≤ x
⊢ 1 ≤ prod []
Theorem: ball_mul
File: Mathlib/Analysis/Normed/Group/Pointwise.lean

tactic: rw [mul_comm, mul_ball]
state_before: E : Type u_1
inst✝ : SeminormedCommGroup E
ε δ : ℝ
s t : Set E
x y : E
⊢ ball x δ * s = x • thickening δ s
Theorem: Finset.card_pow_le
File: Mathlib/Combinatorics/Additive/PluenneckeRuzsa.lean

tactic: simpa only [_root_.pow_zero, div_one] using card_pow_div_pow_le hA _ _ 0
state_before: α : Type u_1
inst✝¹ : CommGroup α
inst✝ : DecidableEq α
A B✝ C : Finset α
hA : Finset.Nonempty A
B : Finset α
n : ℕ
⊢ ↑(card (B ^ n)) ≤ (↑(card (A * B)) / ↑(card A)) ^ n * ↑(card A)
Theorem: Real.exp_one_lt_d9
File: Mathlib/Data/Complex/ExponentialBounds.lean

tactic: norm_num
state_before: ⊢ 1 / 10 ^ 10 + 2244083 / 825552 < 2.7182818286
Theorem: map_pow
File: Mathlib/Algebra/Hom/Group.lean

tactic: rw [pow_zero, pow_zero, map_one]
state_before: α : Type ?u.50695
β : Type ?u.50698
M : Type ?u.50701
N : Type ?u.50704
P : Type ?u.50707
G : Type u_1
H : Type u_2
F : Type u_3
inst✝⁴ : MulOneClass M
inst✝³ : MulOneClass N
inst✝² : Monoid G
inst✝¹ : Monoid H
inst✝ : MonoidHomClass F G H
f : F
a : G
⊢ ↑f (a ^ 0) = ↑f a ^ 0

tactic: rw [pow_succ, pow_succ, map_mul, map_pow f a n]
state_before: α : Type ?u.50695
β : Type ?u.50698
M : Type ?u.50701
N : Type ?u.50704
P : Type ?u.50707
G : Type u_1
H : Type u_2
F : Type u_3
inst✝⁴ : MulOneClass M
inst✝³ : MulOneClass N
inst✝² : Monoid G
inst✝¹ : Monoid H
inst✝ : MonoidHomClass F G H
f : F
a : G
n : ℕ
⊢ ↑f (a ^ (n + 1)) = ↑f a ^ (n + 1)
Theorem: IsROrC.mul_self_norm
File: Mathlib/Data/IsROrC/Basic.lean

tactic: rw [normSq_eq_def', sq]
state_before: K : Type u_1
E : Type ?u.6573042
inst✝ : IsROrC K
z : K
⊢ ‖z‖ * ‖z‖ = ↑normSq z
Theorem: Matrix.TransvectionStruct.reverse_inv_prod_mul_prod
File: Mathlib/LinearAlgebra/Matrix/Transvection.lean

tactic: induction' L with t L IH
state_before: n : Type u_1
p : Type ?u.35992
R : Type u₂
𝕜 : Type ?u.35997
inst✝⁴ : Field 𝕜
inst✝³ : DecidableEq n
inst✝² : DecidableEq p
inst✝¹ : CommRing R
i j : n
inst✝ : Fintype n
L : List (TransvectionStruct n R)
⊢ List.prod (List.map (toMatrix ∘ TransvectionStruct.inv) (List.reverse L)) ⬝ List.prod (List.map toMatrix L) = 1

tactic: simp
state_before: case nil
n : Type u_1
p : Type ?u.35992
R : Type u₂
𝕜 : Type ?u.35997
inst✝⁴ : Field 𝕜
inst✝³ : DecidableEq n
inst✝² : DecidableEq p
inst✝¹ : CommRing R
i j : n
inst✝ : Fintype n
⊢ List.prod (List.map (toMatrix ∘ TransvectionStruct.inv) (List.reverse [])) ⬝ List.prod (List.map toMatrix []) = 1

tactic: suffices
  (L.reverse.map (toMatrix ∘ TransvectionStruct.inv)).prod ⬝ (t.inv.toMatrix ⬝ t.toMatrix) ⬝
      (L.map toMatrix).prod = 1
  by simpa [Matrix.mul_assoc]
state_before: case cons
n : Type u_1
p : Type ?u.35992
R : Type u₂
𝕜 : Type ?u.35997
inst✝⁴ : Field 𝕜
inst✝³ : DecidableEq n
inst✝² : DecidableEq p
inst✝¹ : CommRing R
i j : n
inst✝ : Fintype n
t : TransvectionStruct n R
L : List (TransvectionStruct n R)
IH : List.prod (List.map (toMatrix ∘ TransvectionStruct.inv) (List.reverse L)) ⬝ List.prod (List.map toMatrix L) = 1
⊢ List.prod (List.map (toMatrix ∘ TransvectionStruct.inv) (List.reverse (t :: L))) ⬝
      List.prod (List.map toMatrix (t :: L)) =
    1

tactic: simpa [inv_mul] using IH
state_before: case cons
n : Type u_1
p : Type ?u.35992
R : Type u₂
𝕜 : Type ?u.35997
inst✝⁴ : Field 𝕜
inst✝³ : DecidableEq n
inst✝² : DecidableEq p
inst✝¹ : CommRing R
i j : n
inst✝ : Fintype n
t : TransvectionStruct n R
L : List (TransvectionStruct n R)
IH : List.prod (List.map (toMatrix ∘ TransvectionStruct.inv) (List.reverse L)) ⬝ List.prod (List.map toMatrix L) = 1
⊢ List.prod (List.map (toMatrix ∘ TransvectionStruct.inv) (List.reverse L)) ⬝
        (toMatrix (TransvectionStruct.inv t) ⬝ toMatrix t) ⬝
      List.prod (List.map toMatrix L) =
    1

tactic: simpa [Matrix.mul_assoc]
state_before: n : Type u_1
p : Type ?u.35992
R : Type u₂
𝕜 : Type ?u.35997
inst✝⁴ : Field 𝕜
inst✝³ : DecidableEq n
inst✝² : DecidableEq p
inst✝¹ : CommRing R
i j : n
inst✝ : Fintype n
t : TransvectionStruct n R
L : List (TransvectionStruct n R)
IH : List.prod (List.map (toMatrix ∘ TransvectionStruct.inv) (List.reverse L)) ⬝ List.prod (List.map toMatrix L) = 1
this :
  List.prod (List.map (toMatrix ∘ TransvectionStruct.inv) (List.reverse L)) ⬝
        (toMatrix (TransvectionStruct.inv t) ⬝ toMatrix t) ⬝
      List.prod (List.map toMatrix L) =
    1
⊢ List.prod (List.map (toMatrix ∘ TransvectionStruct.inv) (List.reverse (t :: L))) ⬝
      List.prod (List.map toMatrix (t :: L)) =
    1
Theorem: Filter.lift_principal2
File: Mathlib/Order/Filter/Lift.lean

tactic: simp only [hs, le_principal_iff]
state_before: α : Type u_1
β : Type ?u.22457
γ : Type ?u.22460
ι : Sort ?u.22463
f✝ f₁ f₂ : Filter α
g g₁ g₂ : Set α → Filter β
f : Filter α
s : Set α
hs : s ∈ f
⊢ f ≤ 𝓟 s
Theorem: Nat.succ_eq_one_add
File: Std/Data/Nat/Lemmas.lean

tactic: rw [Nat.succ_eq_add_one, Nat.add_comm]
state_before: n : Nat
⊢ succ n = 1 + n
Theorem: ProjectiveSpectrum.gc_homogeneousIdeal
File: Mathlib/AlgebraicGeometry/ProjectiveSpectrum/Topology.lean

tactic: simpa [show I.toIdeal ≤ (vanishingIdeal t).toIdeal ↔ I ≤ vanishingIdeal t from Iff.rfl] using
  subset_zeroLocus_iff_le_vanishingIdeal t I.toIdeal
state_before: R : Type u_2
A : Type u_1
inst✝³ : CommSemiring R
inst✝² : CommRing A
inst✝¹ : Algebra R A
𝒜 : ℕ → Submodule R A
inst✝ : GradedAlgebra 𝒜
I : HomogeneousIdeal 𝒜
t : (Set (ProjectiveSpectrum 𝒜))ᵒᵈ
⊢ (fun I => zeroLocus 𝒜 ↑I) I ≤ t ↔ I ≤ (fun t => vanishingIdeal t) t
Theorem: Complex.abs_exp
File: Mathlib/Data/Complex/Exponential.lean

tactic: rw [exp_eq_exp_re_mul_sin_add_cos, map_mul, abs_exp_ofReal, abs_cos_add_sin_mul_I, mul_one]
state_before: z : ℂ
⊢ ↑abs (exp z) = Real.exp z.re
Theorem: Polynomial.cyclotomic'_splits
File: Mathlib/RingTheory/Polynomial/Cyclotomic/Basic.lean

tactic: apply splits_prod (RingHom.id K)
state_before: K : Type u_1
inst✝ : Field K
n : ℕ
⊢ Splits (RingHom.id K) (cyclotomic' n K)

tactic: intro z _
state_before: K : Type u_1
inst✝ : Field K
n : ℕ
⊢ ∀ (j : K), j ∈ primitiveRoots n K → Splits (RingHom.id K) (X - ↑C j)

tactic: simp only [splits_X_sub_C (RingHom.id K)]
state_before: K : Type u_1
inst✝ : Field K
n : ℕ
z : K
a✝ : z ∈ primitiveRoots n K
⊢ Splits (RingHom.id K) (X - ↑C z)
Theorem: Real.one_sub_le_exp_minus_of_nonneg
File: Mathlib/Data/Complex/Exponential.lean

tactic: rcases eq_or_lt_of_le h with (rfl | h)
state_before: y : ℝ
h : 0 ≤ y
⊢ 1 - y ≤ exp (-y)

tactic: simp
state_before: case inl
h : 0 ≤ 0
⊢ 1 - 0 ≤ exp (-0)

tactic: exact (one_sub_lt_exp_minus_of_pos h).le
state_before: case inr
y : ℝ
h✝ : 0 ≤ y
h : 0 < y
⊢ 1 - y ≤ exp (-y)
Theorem: Left.one_lt_inv_iff
File: Mathlib/Algebra/Order/Group/Defs.lean

tactic: rw [← mul_lt_mul_iff_left a, mul_inv_self, mul_one]
state_before: α : Type u
inst✝² : Group α
inst✝¹ : LT α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
a b c : α
⊢ 1 < a⁻¹ ↔ a < 1
Theorem: Nat.choose_self
File: Mathlib/Data/Nat/Choose/Basic.lean

tactic: induction n <;> simp [*, choose, choose_eq_zero_of_lt (lt_succ_self _)]
state_before: n : ℕ
⊢ choose n n = 1
Theorem: List.length_permutationsAux2
File: Mathlib/Data/List/Permutation.lean

tactic: induction ys generalizing f <;> simp [*]
state_before: α : Type u_1
β : Type u_2
t : α
ts ys : List α
f : List α → β
⊢ length (permutationsAux2 t ts [] ys f).snd = length ys
Theorem: Mathlib.Tactic.Ring.zero_mul
File: Mathlib/Tactic/Ring/Basic.lean

tactic: simp
state_before: u : Lean.Level
R : Type u_1
α : Q(Type u)
sα : Q(CommSemiring «$α»)
inst✝ : CommSemiring R
b : R
⊢ 0 * b = 0
Theorem: Sym.filter_ne_fill
File: Mathlib/Data/Sym/Basic.lean

tactic: rw [filterNe, ← val_eq_coe, Subtype.coe_mk, val_eq_coe, coe_fill]
state_before: α : Type u_1
β : Type ?u.55875
n n' m✝ : ℕ
s : Sym α n
a✝ b : α
inst✝ : DecidableEq α
a : α
m : (i : Fin (n + 1)) × Sym α (n - ↑i)
h : ¬a ∈ m.snd
⊢ ↑(filterNe a (fill a m.fst m.snd)).snd = ↑m.snd

tactic: rw [filter_add, filter_eq_self.2, add_right_eq_self, eq_zero_iff_forall_not_mem]
state_before: α : Type u_1
β : Type ?u.55875
n n' m✝ : ℕ
s : Sym α n
a✝ b : α
inst✝ : DecidableEq α
a : α
m : (i : Fin (n + 1)) × Sym α (n - ↑i)
h : ¬a ∈ m.snd
⊢ filter ((fun x x_1 => x ≠ x_1) a) (↑m.snd + ↑(replicate (↑m.fst) a)) = ↑m.snd

tactic: intro b hb
state_before: α : Type u_1
β : Type ?u.55875
n n' m✝ : ℕ
s : Sym α n
a✝ b : α
inst✝ : DecidableEq α
a : α
m : (i : Fin (n + 1)) × Sym α (n - ↑i)
h : ¬a ∈ m.snd
⊢ ∀ (a_1 : α), ¬a_1 ∈ filter ((fun x x_1 => x ≠ x_1) a) ↑(replicate (↑m.fst) a)

tactic: rw [mem_filter, Sym.mem_coe, mem_replicate] at hb
state_before: α : Type u_1
β : Type ?u.55875
n n' m✝ : ℕ
s : Sym α n
a✝ b✝ : α
inst✝ : DecidableEq α
a : α
m : (i : Fin (n + 1)) × Sym α (n - ↑i)
h : ¬a ∈ m.snd
b : α
hb : b ∈ filter ((fun x x_1 => x ≠ x_1) a) ↑(replicate (↑m.fst) a)
⊢ False

tactic: exact hb.2 hb.1.2.symm
state_before: α : Type u_1
β : Type ?u.55875
n n' m✝ : ℕ
s : Sym α n
a✝ b✝ : α
inst✝ : DecidableEq α
a : α
m : (i : Fin (n + 1)) × Sym α (n - ↑i)
h : ¬a ∈ m.snd
b : α
hb : (↑m.fst ≠ 0 ∧ b = a) ∧ (fun x x_1 => x ≠ x_1) a b
⊢ False

tactic: exact fun a ha ha' => h <| ha'.symm ▸ ha
state_before: α : Type u_1
β : Type ?u.55875
n n' m✝ : ℕ
s : Sym α n
a✝ b : α
inst✝ : DecidableEq α
a : α
m : (i : Fin (n + 1)) × Sym α (n - ↑i)
h : ¬a ∈ m.snd
⊢ ∀ (a_1 : α), a_1 ∈ ↑m.snd → (fun x x_1 => x ≠ x_1) a a_1
Theorem: WithSeminorms.isOpen_iff_mem_balls
File: Mathlib/Analysis/LocallyConvex/WithSeminorms.lean

tactic: simp_rw [← WithSeminorms.mem_nhds_iff hp _ U, isOpen_iff_mem_nhds]
state_before: 𝕜 : Type u_1
𝕜₂ : Type ?u.210790
𝕝 : Type ?u.210793
𝕝₂ : Type ?u.210796
E : Type u_2
F : Type ?u.210802
G : Type ?u.210805
ι : Type u_3
ι' : Type ?u.210811
inst✝⁴ : NormedField 𝕜
inst✝³ : AddCommGroup E
inst✝² : Module 𝕜 E
inst✝¹ : Nonempty ι
inst✝ : TopologicalSpace E
p : SeminormFamily 𝕜 E ι
hp : WithSeminorms p
U : Set E
⊢ IsOpen U ↔ ∀ (x : E), x ∈ U → ∃ s r, r > 0 ∧ ball (Finset.sup s p) x r ⊆ U
Theorem: MeasureTheory.MeasurePreserving.set_lintegral_comp_preimage_emb
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

tactic: rw [← hg.map_eq, hge.restrict_map, hge.lintegral_map]
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.1687696
δ : Type ?u.1687699
m : MeasurableSpace α
μ ν✝ : Measure α
mb : MeasurableSpace β
ν : Measure β
g : α → β
hg : MeasurePreserving g
hge : MeasurableEmbedding g
f : β → ℝ≥0∞
s : Set β
⊢ (∫⁻ (a : α) in g ⁻¹' s, f (g a) ∂μ) = ∫⁻ (b : β) in s, f b ∂ν
Theorem: mul_inv_lt_inv_mul_iff
File: Mathlib/Algebra/Order/Group/Defs.lean

tactic: rw [← mul_lt_mul_iff_left d, ← mul_lt_mul_iff_right b, mul_inv_cancel_left, mul_assoc,
  inv_mul_cancel_right]
state_before: α : Type u
inst✝³ : Group α
inst✝² : LT α
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x < x_1
a b c d : α
⊢ a * b⁻¹ < d⁻¹ * c ↔ d * a < c * b
Theorem: MeasureTheory.QuasiMeasurePreserving.prod_of_left
File: Mathlib/MeasureTheory/Constructions/Prod/Basic.lean

tactic: rw [← prod_swap]
state_before: α✝ : Type ?u.4535638
α' : Type ?u.4535641
β✝ : Type ?u.4535644
β' : Type ?u.4535647
γ✝ : Type ?u.4535650
E : Type ?u.4535653
inst✝¹⁰ : MeasurableSpace α✝
inst✝⁹ : MeasurableSpace α'
inst✝⁸ : MeasurableSpace β✝
inst✝⁷ : MeasurableSpace β'
inst✝⁶ : MeasurableSpace γ✝
μ✝ μ' : Measure α✝
ν✝ ν' : Measure β✝
τ✝ : Measure γ✝
inst✝⁵ : NormedAddCommGroup E
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝⁴ : MeasurableSpace α
inst✝³ : MeasurableSpace β
inst✝² : MeasurableSpace γ
f : α × β → γ
μ : Measure α
ν : Measure β
τ : Measure γ
hf : Measurable f
inst✝¹ : SigmaFinite μ
inst✝ : SigmaFinite ν
h2f : ∀ᵐ (y : β) ∂ν, QuasiMeasurePreserving fun x => f (x, y)
⊢ QuasiMeasurePreserving f

tactic: convert (QuasiMeasurePreserving.prod_of_right (hf.comp measurable_swap) h2f).comp
    ((measurable_swap.measurePreserving (ν.prod μ)).symm
        MeasurableEquiv.prodComm).quasiMeasurePreserving
state_before: α✝ : Type ?u.4535638
α' : Type ?u.4535641
β✝ : Type ?u.4535644
β' : Type ?u.4535647
γ✝ : Type ?u.4535650
E : Type ?u.4535653
inst✝¹⁰ : MeasurableSpace α✝
inst✝⁹ : MeasurableSpace α'
inst✝⁸ : MeasurableSpace β✝
inst✝⁷ : MeasurableSpace β'
inst✝⁶ : MeasurableSpace γ✝
μ✝ μ' : Measure α✝
ν✝ ν' : Measure β✝
τ✝ : Measure γ✝
inst✝⁵ : NormedAddCommGroup E
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝⁴ : MeasurableSpace α
inst✝³ : MeasurableSpace β
inst✝² : MeasurableSpace γ
f : α × β → γ
μ : Measure α
ν : Measure β
τ : Measure γ
hf : Measurable f
inst✝¹ : SigmaFinite μ
inst✝ : SigmaFinite ν
h2f : ∀ᵐ (y : β) ∂ν, QuasiMeasurePreserving fun x => f (x, y)
⊢ QuasiMeasurePreserving f
Theorem: Complex.abs_exp_sub_one_le
File: Mathlib/Data/Complex/Exponential.lean

tactic: simp [sum_range_succ]
state_before: x : ℂ
hx : ↑abs x ≤ 1
⊢ ↑abs (exp x - 1) = ↑abs (exp x - ∑ m in range 1, x ^ m / ↑(Nat.factorial m))

tactic: decide
state_before: x : ℂ
hx : ↑abs x ≤ 1
⊢ 0 < 1

tactic: simp [two_mul, mul_two, mul_add, mul_comm, add_mul]
state_before: x : ℂ
hx : ↑abs x ≤ 1
⊢ ↑abs x ^ 1 * (↑(Nat.succ 1) * (↑(Nat.factorial 1) * ↑1)⁻¹) = 2 * ↑abs x
Theorem: iff_self_and
File: Std/Logic.lean

tactic: rw [@Iff.comm p, and_iff_left_iff_imp]
state_before: p q : Prop
⊢ (p ↔ p ∧ q) ↔ p → q
Theorem: Set.image2_union_inter_subset
File: Mathlib/Data/Set/NAry.lean

tactic: rw [image2_comm hf]
state_before: α : Type u_1
α' : Type ?u.51060
β : Type u_2
β' : Type ?u.51066
γ : Type ?u.51069
γ' : Type ?u.51072
δ : Type ?u.51075
δ' : Type ?u.51078
ε : Type ?u.51081
ε' : Type ?u.51084
ζ : Type ?u.51087
ζ' : Type ?u.51090
ν : Type ?u.51093
f✝ f' : α → β → γ
g g' : α → β → γ → δ
s✝ s' : Set α
t✝ t' : Set β
u u' : Set γ
v : Set δ
a a' : α
b b' : β
c c' : γ
d d' : δ
f : α → α → β
s t : Set α
hf : ∀ (a b : α), f a b = f b a
⊢ image2 f (s ∪ t) (s ∩ t) ⊆ image2 f s t

tactic: exact image2_inter_union_subset hf
state_before: α : Type u_1
α' : Type ?u.51060
β : Type u_2
β' : Type ?u.51066
γ : Type ?u.51069
γ' : Type ?u.51072
δ : Type ?u.51075
δ' : Type ?u.51078
ε : Type ?u.51081
ε' : Type ?u.51084
ζ : Type ?u.51087
ζ' : Type ?u.51090
ν : Type ?u.51093
f✝ f' : α → β → γ
g g' : α → β → γ → δ
s✝ s' : Set α
t✝ t' : Set β
u u' : Set γ
v : Set δ
a a' : α
b b' : β
c c' : γ
d d' : δ
f : α → α → β
s t : Set α
hf : ∀ (a b : α), f a b = f b a
⊢ image2 (fun b a => f b a) (s ∩ t) (s ∪ t) ⊆ image2 f s t
Theorem: iSup_sum
File: Mathlib/Order/CompleteLattice.lean

tactic: simp only [sup_le_iff, iSup_le_iff, Sum.forall]
state_before: α : Type u_3
β : Type u_1
β₂ : Type ?u.168938
γ : Type u_2
ι : Sort ?u.168944
ι' : Sort ?u.168947
κ : ι → Sort ?u.168952
κ' : ι' → Sort ?u.168957
inst✝ : CompleteLattice α
f✝ g s t : ι → α
a b : α
f : β ⊕ γ → α
c : α
⊢ (⨆ (x : β ⊕ γ), f x) ≤ c ↔ ((⨆ (i : β), f (Sum.inl i)) ⊔ ⨆ (j : γ), f (Sum.inr j)) ≤ c
Theorem: List.nthLe_of_eq
File: Mathlib/Data/List/Basic.lean

tactic: congr
state_before: ι : Type ?u.87083
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ L L' : List α
h : L = L'
i : ℕ
hi : i < length L
⊢ nthLe L i hi = nthLe L' i (_ : i < length L')
Theorem: CategoryTheory.CostructuredArrow.map_id
File: Mathlib/CategoryTheory/StructuredArrow.lean

tactic: rw [eq_mk f]
state_before: C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
T T' T'' : D
Y Y' : C
S : C ⥤ D
f : CostructuredArrow S T
⊢ (map (𝟙 T)).obj f = f

tactic: simp
state_before: C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
T T' T'' : D
Y Y' : C
S : C ⥤ D
f : CostructuredArrow S T
⊢ (map (𝟙 T)).obj (mk f.hom) = mk f.hom
Theorem: Multiset.lt_replicate_succ
File: Mathlib/Data/Multiset/Basic.lean

tactic: rw [lt_iff_cons_le]
state_before: α : Type u_1
β : Type ?u.93086
γ : Type ?u.93089
m : Multiset α
x : α
n : ℕ
⊢ m < replicate (n + 1) x ↔ m ≤ replicate n x

tactic: constructor
state_before: α : Type u_1
β : Type ?u.93086
γ : Type ?u.93089
m : Multiset α
x : α
n : ℕ
⊢ (∃ a, a ::ₘ m ≤ replicate (n + 1) x) ↔ m ≤ replicate n x

tactic: rintro ⟨x', hx'⟩
state_before: case mp
α : Type u_1
β : Type ?u.93086
γ : Type ?u.93089
m : Multiset α
x : α
n : ℕ
⊢ (∃ a, a ::ₘ m ≤ replicate (n + 1) x) → m ≤ replicate n x

tactic: have := eq_of_mem_replicate (mem_of_le hx' (mem_cons_self _ _))
state_before: case mp.intro
α : Type u_1
β : Type ?u.93086
γ : Type ?u.93089
m : Multiset α
x : α
n : ℕ
x' : α
hx' : x' ::ₘ m ≤ replicate (n + 1) x
⊢ m ≤ replicate n x

tactic: rwa [this, replicate_succ, cons_le_cons_iff] at hx'
state_before: case mp.intro
α : Type u_1
β : Type ?u.93086
γ : Type ?u.93089
m : Multiset α
x : α
n : ℕ
x' : α
hx' : x' ::ₘ m ≤ replicate (n + 1) x
this : x' = x
⊢ m ≤ replicate n x

tactic: intro h
state_before: case mpr
α : Type u_1
β : Type ?u.93086
γ : Type ?u.93089
m : Multiset α
x : α
n : ℕ
⊢ m ≤ replicate n x → ∃ a, a ::ₘ m ≤ replicate (n + 1) x

tactic: rw [replicate_succ]
state_before: case mpr
α : Type u_1
β : Type ?u.93086
γ : Type ?u.93089
m : Multiset α
x : α
n : ℕ
h : m ≤ replicate n x
⊢ ∃ a, a ::ₘ m ≤ replicate (n + 1) x

tactic: exact ⟨x, cons_le_cons _ h⟩
state_before: case mpr
α : Type u_1
β : Type ?u.93086
γ : Type ?u.93089
m : Multiset α
x : α
n : ℕ
h : m ≤ replicate n x
⊢ ∃ a, a ::ₘ m ≤ x ::ₘ replicate n x
Theorem: Real.deriv_log
File: Mathlib/Analysis/SpecialFunctions/Log/Deriv.lean

tactic: rw [deriv_zero_of_not_differentiableAt (differentiableAt_log_iff.not_left.2 hx), hx, inv_zero]
state_before: x✝ x : ℝ
hx : x = 0
⊢ deriv log x = x⁻¹
Theorem: MeasureTheory.mul_meas_ge_le_pow_snorm
File: Mathlib/MeasureTheory/Function/LpSeminorm.lean

tactic: have : 1 / p.toReal * p.toReal = 1 := by
  refine' one_div_mul_cancel _
  rw [Ne, ENNReal.toReal_eq_zero_iff]
  exact not_or_of_not hp_ne_zero hp_ne_top
state_before: α : Type u_1
E : Type u_2
F : Type ?u.4415601
G : Type ?u.4415604
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f : α → E
hp_ne_zero : p ≠ 0
hp_ne_top : p ≠ ⊤
hf : AEStronglyMeasurable f μ
ε : ℝ≥0∞
⊢ ε * ↑↑μ {x | ε ≤ ↑‖f x‖₊ ^ ENNReal.toReal p} ≤ snorm f p μ ^ ENNReal.toReal p

tactic: rw [← ENNReal.rpow_one (ε * μ { x | ε ≤ (‖f x‖₊ : ℝ≥0∞) ^ p.toReal }), ← this, ENNReal.rpow_mul]
state_before: α : Type u_1
E : Type u_2
F : Type ?u.4415601
G : Type ?u.4415604
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f : α → E
hp_ne_zero : p ≠ 0
hp_ne_top : p ≠ ⊤
hf : AEStronglyMeasurable f μ
ε : ℝ≥0∞
this : 1 / ENNReal.toReal p * ENNReal.toReal p = 1
⊢ ε * ↑↑μ {x | ε ≤ ↑‖f x‖₊ ^ ENNReal.toReal p} ≤ snorm f p μ ^ ENNReal.toReal p

tactic: exact
  ENNReal.rpow_le_rpow (pow_mul_meas_ge_le_snorm μ hp_ne_zero hp_ne_top hf ε)
    ENNReal.toReal_nonneg
state_before: α : Type u_1
E : Type u_2
F : Type ?u.4415601
G : Type ?u.4415604
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f : α → E
hp_ne_zero : p ≠ 0
hp_ne_top : p ≠ ⊤
hf : AEStronglyMeasurable f μ
ε : ℝ≥0∞
this : 1 / ENNReal.toReal p * ENNReal.toReal p = 1
⊢ ((ε * ↑↑μ {x | ε ≤ ↑‖f x‖₊ ^ ENNReal.toReal p}) ^ (1 / ENNReal.toReal p)) ^ ENNReal.toReal p ≤
    snorm f p μ ^ ENNReal.toReal p

tactic: refine' one_div_mul_cancel _
state_before: α : Type u_1
E : Type u_2
F : Type ?u.4415601
G : Type ?u.4415604
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f : α → E
hp_ne_zero : p ≠ 0
hp_ne_top : p ≠ ⊤
hf : AEStronglyMeasurable f μ
ε : ℝ≥0∞
⊢ 1 / ENNReal.toReal p * ENNReal.toReal p = 1

tactic: rw [Ne, ENNReal.toReal_eq_zero_iff]
state_before: α : Type u_1
E : Type u_2
F : Type ?u.4415601
G : Type ?u.4415604
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f : α → E
hp_ne_zero : p ≠ 0
hp_ne_top : p ≠ ⊤
hf : AEStronglyMeasurable f μ
ε : ℝ≥0∞
⊢ ENNReal.toReal p ≠ 0

tactic: exact not_or_of_not hp_ne_zero hp_ne_top
state_before: α : Type u_1
E : Type u_2
F : Type ?u.4415601
G : Type ?u.4415604
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f : α → E
hp_ne_zero : p ≠ 0
hp_ne_top : p ≠ ⊤
hf : AEStronglyMeasurable f μ
ε : ℝ≥0∞
⊢ ¬(p = 0 ∨ p = ⊤)
Theorem: Real.cos_nat_mul_two_pi_add_pi
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

tactic: simpa only [cos_zero] using (cos_periodic.nat_mul n).add_antiperiod_eq cos_antiperiodic
state_before: n : ℕ
⊢ cos (↑n * (2 * π) + π) = -1