tasksource/leandojo huggingface dataset:
Theorem: AddEquiv.toIntLinearEquiv_toAddEquiv
File: Mathlib/Algebra/Module/Equiv.lean

tactic: ext
state_before: R : Type ?u.399758
R₁ : Type ?u.399761
R₂ : Type ?u.399764
R₃ : Type ?u.399767
k : Type ?u.399770
S : Type ?u.399773
M : Type u_1
M₁ : Type ?u.399779
M₂ : Type u_2
M₃ : Type ?u.399785
N₁ : Type ?u.399788
N₂ : Type ?u.399791
N₃ : Type ?u.399794
N₄ : Type ?u.399797
ι : Type ?u.399800
inst✝² : AddCommGroup M
inst✝¹ : AddCommGroup M₂
inst✝ : AddCommGroup M₃
e : M ≃+ M₂
⊢ ↑(toIntLinearEquiv e) = e

tactic: rfl
state_before: case h
R : Type ?u.399758
R₁ : Type ?u.399761
R₂ : Type ?u.399764
R₃ : Type ?u.399767
k : Type ?u.399770
S : Type ?u.399773
M : Type u_1
M₁ : Type ?u.399779
M₂ : Type u_2
M₃ : Type ?u.399785
N₁ : Type ?u.399788
N₂ : Type ?u.399791
N₃ : Type ?u.399794
N₄ : Type ?u.399797
ι : Type ?u.399800
inst✝² : AddCommGroup M
inst✝¹ : AddCommGroup M₂
inst✝ : AddCommGroup M₃
e : M ≃+ M₂
x✝ : M
⊢ ↑↑(toIntLinearEquiv e) x✝ = ↑e x✝
Theorem: Real.fourierIntegral_eq_integral_exp_smul
File: Mathlib/Analysis/Fourier/FourierTransform.lean

tactic: simp_rw [fourierIntegral_def, Real.fourierChar_apply, mul_neg, neg_mul, mul_assoc]
state_before: E✝ : Type ?u.2407652
inst✝⁵ : NormedAddCommGroup E✝
inst✝⁴ : CompleteSpace E✝
inst✝³ : NormedSpace ℂ E✝
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℂ E
f : ℝ → E
w : ℝ
⊢ 𝓕 f w = ∫ (v : ℝ), Complex.exp (↑(-2 * π * v * w) * Complex.I) • f v
Theorem: MvPowerSeries.coeff_mul_monomial
File: Mathlib/RingTheory/PowerSeries/Basic.lean

tactic: have :
  ∀ p ∈ antidiagonal m,
    coeff R (p : (σ →₀ ℕ) × (σ →₀ ℕ)).1 φ * coeff R p.2 (monomial R n a) ≠ 0 → p.2 = n :=
  fun p _ hp => eq_of_coeff_monomial_ne_zero (right_ne_zero_of_mul hp)
state_before: σ : Type u_2
R : Type u_1
inst✝ : Semiring R
m n : σ →₀ ℕ
φ ψ : MvPowerSeries σ R
a : R
⊢ ↑(coeff R m) (φ * ↑(monomial R n) a) = if n ≤ m then ↑(coeff R (m - n)) φ * a else 0

tactic: rw [coeff_mul, ← Finset.sum_filter_of_ne this, antidiagonal_filter_snd_eq, Finset.sum_ite_index]
state_before: σ : Type u_2
R : Type u_1
inst✝ : Semiring R
m n : σ →₀ ℕ
φ ψ : MvPowerSeries σ R
a : R
this :
  ∀ (p : (σ →₀ ℕ) × (σ →₀ ℕ)),
    p ∈ antidiagonal m → ↑(coeff R p.fst) φ * ↑(coeff R p.snd) (↑(monomial R n) a) ≠ 0 → p.snd = n
⊢ ↑(coeff R m) (φ * ↑(monomial R n) a) = if n ≤ m then ↑(coeff R (m - n)) φ * a else 0

tactic: simp only [Finset.sum_singleton, coeff_monomial_same, Finset.sum_empty]
state_before: σ : Type u_2
R : Type u_1
inst✝ : Semiring R
m n : σ →₀ ℕ
φ ψ : MvPowerSeries σ R
a : R
this :
  ∀ (p : (σ →₀ ℕ) × (σ →₀ ℕ)),
    p ∈ antidiagonal m → ↑(coeff R p.fst) φ * ↑(coeff R p.snd) (↑(monomial R n) a) ≠ 0 → p.snd = n
⊢ (if n ≤ m then ∑ x in {(m - n, n)}, ↑(coeff R x.fst) φ * ↑(coeff R x.snd) (↑(monomial R n) a)
    else ∑ x in ∅, ↑(coeff R x.fst) φ * ↑(coeff R x.snd) (↑(monomial R n) a)) =
    if n ≤ m then ↑(coeff R (m - n)) φ * a else 0
Theorem: Con.induction_on_units
File: Mathlib/GroupTheory/Congruence.lean

tactic: rcases u with ⟨⟨x⟩, ⟨y⟩, h₁, h₂⟩
state_before: M : Type u_1
N : Type ?u.116933
P : Type ?u.116936
α : Type ?u.116939
inst✝ : Monoid M
c : Con M
p : (Con.Quotient c)ˣ → Prop
u : (Con.Quotient c)ˣ
H :
  ∀ (x y : M) (hxy : ↑c (x * y) 1) (hyx : ↑c (y * x) 1),
    p
      { val := ↑x, inv := ↑y, val_inv := (_ : ↑((fun x x_1 => x * x_1) x y) = ↑1),
        inv_val := (_ : ↑((fun x x_1 => x * x_1) y x) = ↑1) }
⊢ p u

tactic: exact H x y (c.eq.1 h₁) (c.eq.1 h₂)
state_before: case mk.mk.mk
M : Type u_1
N : Type ?u.116933
P : Type ?u.116936
α : Type ?u.116939
inst✝ : Monoid M
c : Con M
p : (Con.Quotient c)ˣ → Prop
H :
  ∀ (x y : M) (hxy : ↑c (x * y) 1) (hyx : ↑c (y * x) 1),
    p
      { val := ↑x, inv := ↑y, val_inv := (_ : ↑((fun x x_1 => x * x_1) x y) = ↑1),
        inv_val := (_ : ↑((fun x x_1 => x * x_1) y x) = ↑1) }
val✝ inv✝ : Con.Quotient c
x y : M
h₁ : Quot.mk r x * Quot.mk r y = 1
h₂ : Quot.mk r y * Quot.mk r x = 1
⊢ p { val := Quot.mk r x, inv := Quot.mk r y, val_inv := h₁, inv_val := h₂ }
Theorem: Set.piecewise_mem_pi
File: Mathlib/Data/Set/Function.lean

tactic: intro i ht
state_before: α : Type u_2
β : Type ?u.97038
γ : Type ?u.97041
ι : Sort ?u.97044
π : α → Type ?u.97049
δ✝ : α → Sort ?u.97054
s : Set α
f✝ g✝ : (i : α) → δ✝ i
inst✝ : (j : α) → Decidable (j ∈ s)
δ : α → Type u_1
t : Set α
t' : (i : α) → Set (δ i)
f g : (i : α) → δ i
hf : f ∈ pi t t'
hg : g ∈ pi t t'
⊢ piecewise s f g ∈ pi t t'

tactic: by_cases hs : i ∈ s <;> simp [hf i ht, hg i ht, hs]
state_before: α : Type u_2
β : Type ?u.97038
γ : Type ?u.97041
ι : Sort ?u.97044
π : α → Type ?u.97049
δ✝ : α → Sort ?u.97054
s : Set α
f✝ g✝ : (i : α) → δ✝ i
inst✝ : (j : α) → Decidable (j ∈ s)
δ : α → Type u_1
t : Set α
t' : (i : α) → Set (δ i)
f g : (i : α) → δ i
hf : f ∈ pi t t'
hg : g ∈ pi t t'
i : α
ht : i ∈ t
⊢ piecewise s f g i ∈ t' i
Theorem: Complex.exp_eq_one_iff
File: Mathlib/Analysis/SpecialFunctions/Complex/Log.lean

tactic: constructor
state_before: x : ℂ
⊢ exp x = 1 ↔ ∃ n, x = ↑n * (2 * ↑π * I)

tactic: intro h
state_before: case mp
x : ℂ
⊢ exp x = 1 → ∃ n, x = ↑n * (2 * ↑π * I)

tactic: rcases existsUnique_add_zsmul_mem_Ioc Real.two_pi_pos x.im (-π) with ⟨n, hn, -⟩
state_before: case mp
x : ℂ
h : exp x = 1
⊢ ∃ n, x = ↑n * (2 * ↑π * I)

tactic: use -n
state_before: case mp.intro.intro
x : ℂ
h : exp x = 1
n : ℤ
hn : x.im + n • (2 * π) ∈ Set.Ioc (-π) (-π + 2 * π)
⊢ ∃ n, x = ↑n * (2 * ↑π * I)

tactic: rw [Int.cast_neg, neg_mul, eq_neg_iff_add_eq_zero]
state_before: case mp.intro.intro
x : ℂ
h : exp x = 1
n : ℤ
hn : x.im + n • (2 * π) ∈ Set.Ioc (-π) (-π + 2 * π)
⊢ x = ↑(-n) * (2 * ↑π * I)

tactic: have : (x + n * (2 * π * I)).im ∈ Set.Ioc (-π) π := by simpa [two_mul, mul_add] using hn
state_before: case mp.intro.intro
x : ℂ
h : exp x = 1
n : ℤ
hn : x.im + n • (2 * π) ∈ Set.Ioc (-π) (-π + 2 * π)
⊢ x + ↑n * (2 * ↑π * I) = 0

tactic: rw [← log_exp this.1 this.2, exp_periodic.int_mul n, h, log_one]
state_before: case mp.intro.intro
x : ℂ
h : exp x = 1
n : ℤ
hn : x.im + n • (2 * π) ∈ Set.Ioc (-π) (-π + 2 * π)
this : (x + ↑n * (2 * ↑π * I)).im ∈ Set.Ioc (-π) π
⊢ x + ↑n * (2 * ↑π * I) = 0

tactic: simpa [two_mul, mul_add] using hn
state_before: x : ℂ
h : exp x = 1
n : ℤ
hn : x.im + n • (2 * π) ∈ Set.Ioc (-π) (-π + 2 * π)
⊢ (x + ↑n * (2 * ↑π * I)).im ∈ Set.Ioc (-π) π

tactic: rintro ⟨n, rfl⟩
state_before: case mpr
x : ℂ
⊢ (∃ n, x = ↑n * (2 * ↑π * I)) → exp x = 1

tactic: exact (exp_periodic.int_mul n).eq.trans exp_zero
state_before: case mpr.intro
n : ℤ
⊢ exp (↑n * (2 * ↑π * I)) = 1
Theorem: List.argmax_mem
File: Mathlib/Data/List/MinMax.lean

tactic: simp
state_before: α : Type u_1
β : Type u_2
inst✝¹ : Preorder β
inst✝ : DecidableRel fun x x_1 => x < x_1
f : α → β
l : List α
o : Option α
a m✝ m : α
⊢ m ∈ argmax f [] → m ∈ []

tactic: simpa [argmax, argAux] using foldl_argAux_mem _ tl hd m
state_before: α : Type u_1
β : Type u_2
inst✝¹ : Preorder β
inst✝ : DecidableRel fun x x_1 => x < x_1
f : α → β
l : List α
o : Option α
a m✝ hd : α
tl : List α
m : α
⊢ m ∈ argmax f (hd :: tl) → m ∈ hd :: tl
Theorem: Matrix.coe_det_isEmpty
File: Mathlib/LinearAlgebra/Matrix/Determinant.lean

tactic: ext
state_before: m : Type ?u.177310
n : Type u_1
inst✝⁵ : DecidableEq n
inst✝⁴ : Fintype n
inst✝³ : DecidableEq m
inst✝² : Fintype m
R : Type v
inst✝¹ : CommRing R
inst✝ : IsEmpty n
⊢ det = const (Matrix n n R) 1

tactic: exact det_isEmpty
state_before: case h
m : Type ?u.177310
n : Type u_1
inst✝⁵ : DecidableEq n
inst✝⁴ : Fintype n
inst✝³ : DecidableEq m
inst✝² : Fintype m
R : Type v
inst✝¹ : CommRing R
inst✝ : IsEmpty n
x✝ : Matrix n n R
⊢ det x✝ = const (Matrix n n R) 1 x✝
Theorem: Finset.sup_lt_iff
File: Mathlib/Data/Finset/Lattice.lean

tactic: simpa only [sup_cons, sup_lt_iff, mem_cons, forall_eq_or_imp] using And.imp_right
state_before: F : Type ?u.215549
α : Type u_1
β : Type ?u.215555
γ : Type ?u.215558
ι : Type u_2
κ : Type ?u.215564
inst✝¹ : LinearOrder α
inst✝ : OrderBot α
s : Finset ι
f : ι → α
a : α
ha : ⊥ < a
c : ι
t : Finset ι
hc : ¬c ∈ t
⊢ ((∀ (b : ι), b ∈ t → f b < a) → sup t f < a) → (∀ (b : ι), b ∈ cons c t hc → f b < a) → sup (cons c t hc) f < a
Theorem: lcm_eq_one_iff
File: Mathlib/Algebra/GCDMonoid/Basic.lean

tactic: rw [lcm_units_coe_left, normalize_coe_units]
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : NormalizedGCDMonoid α
a b : α
x✝ : a ∣ 1 ∧ b ∣ 1
c : α
hc : 1 = a * c
d : α
hd : 1 = b * d
⊢ lcm ↑(Units.mkOfMulEqOne a c (_ : a * c = 1)) ↑(Units.mkOfMulEqOne b d (_ : b * d = 1)) = 1
Theorem: Nat.zero_sub
File: src/lean/Init/Data/Nat/Basic.lean

tactic: induction n with
| zero => rfl
| succ n ih => simp [ih, Nat.sub_succ]
state_before: n : Nat
⊢ 0 - n = 0

tactic: rfl
state_before: case zero

⊢ 0 - zero = 0

tactic: simp [ih, Nat.sub_succ]
state_before: case succ
n : Nat
ih : 0 - n = 0
⊢ 0 - succ n = 0
Theorem: Real.logb_neg_eq_logb
File: Mathlib/Analysis/SpecialFunctions/Log/Base.lean

tactic: rw [← logb_abs x, ← logb_abs (-x), abs_neg]
state_before: b x✝ y x : ℝ
⊢ logb b (-x) = logb b x
Theorem: MeasureTheory.isProbabilityMeasureSmul
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: constructor
state_before: α : Type u_1
β : Type ?u.654181
γ : Type ?u.654184
δ : Type ?u.654187
ι : Type ?u.654190
R : Type ?u.654193
R' : Type ?u.654196
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
inst✝ : IsFiniteMeasure μ
h : μ ≠ 0
⊢ IsProbabilityMeasure ((↑↑μ univ)⁻¹ • μ)

tactic: rw [smul_apply, smul_eq_mul, ENNReal.inv_mul_cancel]
state_before: case measure_univ
α : Type u_1
β : Type ?u.654181
γ : Type ?u.654184
δ : Type ?u.654187
ι : Type ?u.654190
R : Type ?u.654193
R' : Type ?u.654196
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
inst✝ : IsFiniteMeasure μ
h : μ ≠ 0
⊢ ↑↑((↑↑μ univ)⁻¹ • μ) univ = 1

tactic: rwa [Ne, measure_univ_eq_zero]
state_before: case measure_univ.h0
α : Type u_1
β : Type ?u.654181
γ : Type ?u.654184
δ : Type ?u.654187
ι : Type ?u.654190
R : Type ?u.654193
R' : Type ?u.654196
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
inst✝ : IsFiniteMeasure μ
h : μ ≠ 0
⊢ ↑↑μ univ ≠ 0

tactic: exact measure_ne_top _ _
state_before: case measure_univ.ht
α : Type u_1
β : Type ?u.654181
γ : Type ?u.654184
δ : Type ?u.654187
ι : Type ?u.654190
R : Type ?u.654193
R' : Type ?u.654196
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
inst✝ : IsFiniteMeasure μ
h : μ ≠ 0
⊢ ↑↑μ univ ≠ ⊤
Theorem: ContinuousLinearEquiv.contDiffAt_comp_iff
File: Mathlib/Analysis/Calculus/ContDiff.lean

tactic: rw [← contDiffWithinAt_univ, ← contDiffWithinAt_univ, ← preimage_univ]
state_before: 𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type ?u.567704
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
b : E × F → G
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
e : G ≃L[𝕜] E
⊢ ContDiffAt 𝕜 n (f ∘ ↑e) (↑(ContinuousLinearEquiv.symm e) x) ↔ ContDiffAt 𝕜 n f x

tactic: exact e.contDiffWithinAt_comp_iff
state_before: 𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type ?u.567704
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
b : E × F → G
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
e : G ≃L[𝕜] E
⊢ ContDiffWithinAt 𝕜 n (f ∘ ↑e) (?m.574994 ⁻¹' univ) (↑(ContinuousLinearEquiv.symm e) x) ↔ ContDiffWithinAt 𝕜 n f univ x

𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type ?u.567704
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
b : E × F → G
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
e : G ≃L[𝕜] E
⊢ Type ?u.574991

𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type ?u.567704
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
b : E × F → G
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
e : G ≃L[𝕜] E
⊢ G → ?m.574993
Theorem: OreLocalization.inv_zero
File: Mathlib/RingTheory/OreLocalization/Basic.lean

tactic: rw [OreLocalization.zero_def, OreLocalization.inv_def]
state_before: R : Type u_1
inst✝³ : Ring R
inst✝² : Nontrivial R
inst✝¹ : OreSet R⁰
inst✝ : NoZeroDivisors R
⊢ 0⁻¹ = 0

tactic: simp
state_before: R : Type u_1
inst✝³ : Ring R
inst✝² : Nontrivial R
inst✝¹ : OreSet R⁰
inst✝ : NoZeroDivisors R
⊢ (if hr : 0 = 0 then 0 else ↑1 /ₒ { val := 0, property := (_ : ∀ (x : R), x * 0 = 0 → x = 0) }) = 0 /ₒ 1
Theorem: Multiset.rel_map_left
File: Mathlib/Data/Multiset/Basic.lean

tactic: simp
state_before: α : Type u_3
β : Type u_2
γ : Type u_1
δ : Type ?u.456244
r : α → β → Prop
p : γ → δ → Prop
s : Multiset γ
f : γ → α
⊢ ∀ {t : Multiset β}, Rel r (map f 0) t ↔ Rel (fun a b => r (f a) b) 0 t

tactic: simp (config := { contextual := true }) [rel_cons_left]
state_before: α : Type u_3
β : Type u_2
γ : Type u_1
δ : Type ?u.456244
r : α → β → Prop
p : γ → δ → Prop
s : Multiset γ
f : γ → α
⊢ ∀ ⦃a : γ⦄ {s : Multiset γ},
    (∀ {t : Multiset β}, Rel r (map f s) t ↔ Rel (fun a b => r (f a) b) s t) →
      ∀ {t : Multiset β}, Rel r (map f (a ::ₘ s)) t ↔ Rel (fun a b => r (f a) b) (a ::ₘ s) t
Theorem: AddSubmonoid.mul_mem_mul
File: Mathlib/GroupTheory/Submonoid/Pointwise.lean

tactic: rfl
state_before: α : Type ?u.239358
G : Type ?u.239361
M✝ : Type ?u.239364
R : Type u_1
A : Type ?u.239370
inst✝² : Monoid M✝
inst✝¹ : AddMonoid A
inst✝ : NonUnitalNonAssocSemiring R
M N : AddSubmonoid R
m n : R
hm : m ∈ M
hn : n ∈ N
⊢ ↑(↑AddMonoidHom.mul ↑{ val := m, property := hm }) n = m * n
Theorem: inf_covby_of_covby_sup_right
File: Mathlib/Order/ModularLattice.lean

tactic: rw [inf_comm, sup_comm]
state_before: α : Type u_1
inst✝¹ : Lattice α
inst✝ : IsLowerModularLattice α
a b : α
⊢ b ⋖ a ⊔ b → a ⊓ b ⋖ a

tactic: exact inf_covby_of_covby_sup_left
state_before: α : Type u_1
inst✝¹ : Lattice α
inst✝ : IsLowerModularLattice α
a b : α
⊢ b ⋖ b ⊔ a → b ⊓ a ⋖ a
Theorem: CategoryTheory.Abelian.exact_iff_exact_image_ι
File: Mathlib/CategoryTheory/Abelian/Exact.lean

tactic: conv_lhs => rw [← Abelian.image.fac f]
state_before: C : Type u₁
inst✝¹ : Category C
inst✝ : Abelian C
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
⊢ Exact f g ↔ Exact (image.ι f) g

tactic: rw [exact_epi_comp_iff]
state_before: C : Type u₁
inst✝¹ : Category C
inst✝ : Abelian C
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
⊢ Exact (Abelian.factorThruImage f ≫ image.ι f) g ↔ Exact (image.ι f) g
Theorem: Std.RBNode.zoom_toList
File: Std/Data/RBMap/Lemmas.lean

tactic: rw [← fill_toList, ← zoom_fill eq]
state_before: α : Type u_1
cut : α → Ordering
t' : RBNode α
p' : Path α
t : RBNode α
eq : zoom cut t root = (t', p')
⊢ withList p' (toList t') = toList t

tactic: rfl
state_before: α : Type u_1
cut : α → Ordering
t' : RBNode α
p' : Path α
t : RBNode α
eq : zoom cut t root = (t', p')
⊢ toList (fill root t) = toList t
Theorem: HasFPowerSeriesOnBall.image_sub_sub_deriv_le
File: Mathlib/Analysis/Analytic/Basic.lean

tactic: simpa only [isBigO_principal, mul_assoc, norm_mul, norm_norm, Prod.forall, EMetric.mem_ball,
  Prod.edist_eq, max_lt_iff, and_imp, @forall_swap (_ < _) E] using
  hf.isBigO_image_sub_image_sub_deriv_principal hr
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type ?u.932002
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
f g : E → F
p pf pg : FormalMultilinearSeries 𝕜 E F
x : E
r r' : ℝ≥0∞
hf : HasFPowerSeriesOnBall f p x r
hr : r' < r
⊢ ∃ C,
    ∀ (y : E),
      y ∈ EMetric.ball x r' →
        ∀ (z : E), z ∈ EMetric.ball x r' → ‖f y - f z - ↑(p 1) fun x => y - z‖ ≤ C * max ‖y - x‖ ‖z - x‖ * ‖y - z‖
Theorem: List.Forall₂.imp
File: Mathlib/Data/List/Forall2.lean

tactic: induction h <;> constructor <;> solve_by_elim
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.1154
δ : Type ?u.1157
R S : α → β → Prop
P : γ → δ → Prop
Rₐ : α → α → Prop
H : ∀ (a : α) (b : β), R a b → S a b
l₁ : List α
l₂ : List β
h : Forall₂ R l₁ l₂
⊢ Forall₂ S l₁ l₂
Theorem: ContinuousLinearMap.op_norm_prod
File: Mathlib/Analysis/NormedSpace/OperatorNorm.lean

tactic: simpa only [prod_apply, Prod.norm_def, max_mul_of_nonneg, norm_nonneg] using
  max_le_max (le_op_norm f x) (le_op_norm g x)
state_before: 𝕜 : Type u_1
𝕜₂ : Type ?u.871859
𝕜₃ : Type ?u.871862
E : Type u_2
Eₗ : Type ?u.871868
F : Type ?u.871871
Fₗ : Type u_3
G : Type ?u.871877
Gₗ : Type u_4
𝓕 : Type ?u.871883
inst✝¹⁵ : SeminormedAddCommGroup E
inst✝¹⁴ : SeminormedAddCommGroup Eₗ
inst✝¹³ : SeminormedAddCommGroup F
inst✝¹² : SeminormedAddCommGroup Fₗ
inst✝¹¹ : SeminormedAddCommGroup G
inst✝¹⁰ : SeminormedAddCommGroup Gₗ
inst✝⁹ : NontriviallyNormedField 𝕜
inst✝⁸ : NontriviallyNormedField 𝕜₂
inst✝⁷ : NontriviallyNormedField 𝕜₃
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : NormedSpace 𝕜 Eₗ
inst✝⁴ : NormedSpace 𝕜₂ F
inst✝³ : NormedSpace 𝕜 Fₗ
inst✝² : NormedSpace 𝕜₃ G
inst✝¹ : NormedSpace 𝕜 Gₗ
σ₁₂ : 𝕜 →+* 𝕜₂
σ₂₃ : 𝕜₂ →+* 𝕜₃
σ₁₃ : 𝕜 →+* 𝕜₃
inst✝ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
f : E →L[𝕜] Fₗ
g : E →L[𝕜] Gₗ
x : E
⊢ ‖↑(ContinuousLinearMap.prod f g) x‖ ≤ ‖(f, g)‖ * ‖x‖
Theorem: NormedField.exists_norm_lt
File: Mathlib/Analysis/Normed/Field/Basic.lean

tactic: rwa [← Set.mem_Ioo, norm_inv, ← Set.mem_inv, Set.inv_Ioo_0_left hr]
state_before: α : Type u_1
β : Type ?u.373469
γ : Type ?u.373472
ι : Type ?u.373475
inst✝ : NontriviallyNormedField α
r : ℝ
hr : 0 < r
w : α
hw : r⁻¹ < ‖w‖
⊢ 0 < ‖w⁻¹‖ ∧ ‖w⁻¹‖ < r
Theorem: derivWithin_of_open
File: Mathlib/Analysis/Calculus/Deriv/Basic.lean

tactic: unfold derivWithin
state_before: 𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type v
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type w
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
hs : IsOpen s
hx : x ∈ s
⊢ derivWithin f s x = deriv f x

tactic: rw [fderivWithin_of_open hs hx]
state_before: 𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type v
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type w
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
hs : IsOpen s
hx : x ∈ s
⊢ ↑(fderivWithin 𝕜 f s x) 1 = deriv f x

tactic: rfl
state_before: 𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type v
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type w
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
hs : IsOpen s
hx : x ∈ s
⊢ ↑(fderiv 𝕜 f x) 1 = deriv f x
Theorem: IsMin.withTop
File: Mathlib/Order/WithBot.lean

tactic: intro _ hb
state_before: α : Type u_1
β : Type ?u.76189
γ : Type ?u.76192
δ : Type ?u.76195
a b : α
inst✝ : LE α
h : IsMin a
⊢ IsMin ↑a

tactic: rw [← toDual_le_toDual_iff] at hb
state_before: α : Type u_1
β : Type ?u.76189
γ : Type ?u.76192
δ : Type ?u.76195
a b : α
inst✝ : LE α
h : IsMin a
b✝ : WithTop α
hb : b✝ ≤ ↑a
⊢ ↑a ≤ b✝

tactic: simpa [toDual_le_iff] using (IsMax.withBot h : IsMax (toDual a : WithBot αᵒᵈ)) hb
state_before: α : Type u_1
β : Type ?u.76189
γ : Type ?u.76192
δ : Type ?u.76195
a b : α
inst✝ : LE α
h : IsMin a
b✝ : WithTop α
hb : ↑WithTop.toDual ↑a ≤ ↑WithTop.toDual b✝
⊢ ↑a ≤ b✝
Theorem: Nat.factorization_eq_zero_iff'
File: Mathlib/Data/Nat/Factorization/Basic.lean

tactic: rw [factorization_eq_factors_multiset n]
state_before: n : ℕ
⊢ factorization n = 0 ↔ n = 0 ∨ n = 1

tactic: simp [factorization, AddEquiv.map_eq_zero_iff, Multiset.coe_eq_zero]
state_before: n : ℕ
⊢ ↑Multiset.toFinsupp ↑(factors n) = 0 ↔ n = 0 ∨ n = 1
Theorem: OreLocalization.universalMulHom_commutes
File: Mathlib/RingTheory/OreLocalization/Basic.lean

tactic: simp [numeratorHom_apply, universalMulHom_apply]
state_before: R : Type u_2
inst✝² : Monoid R
S : Submonoid R
inst✝¹ : OreSet S
T : Type u_1
inst✝ : Monoid T
f : R →* T
fS : { x // x ∈ S } →* Tˣ
hf : ∀ (s : { x // x ∈ S }), ↑f ↑s = ↑(↑fS s)
r : R
⊢ ↑(universalMulHom f fS hf) (↑numeratorHom r) = ↑f r
Theorem: MeasureTheory.FiniteMeasure.coeFn_add
File: Mathlib/MeasureTheory/Measure/FiniteMeasure.lean

tactic: funext
state_before: Ω : Type u_1
inst✝⁴ : MeasurableSpace Ω
R : Type ?u.11466
inst✝³ : SMul R ℝ≥0
inst✝² : SMul R ℝ≥0∞
inst✝¹ : IsScalarTower R ℝ≥0 ℝ≥0∞
inst✝ : IsScalarTower R ℝ≥0∞ ℝ≥0∞
μ ν : FiniteMeasure Ω
⊢ (fun s => ENNReal.toNNReal (↑↑↑(μ + ν) s)) = (fun s => ENNReal.toNNReal (↑↑↑μ s)) + fun s => ENNReal.toNNReal (↑↑↑ν s)

tactic: simp [← ENNReal.coe_eq_coe]
state_before: case h
Ω : Type u_1
inst✝⁴ : MeasurableSpace Ω
R : Type ?u.11466
inst✝³ : SMul R ℝ≥0
inst✝² : SMul R ℝ≥0∞
inst✝¹ : IsScalarTower R ℝ≥0 ℝ≥0∞
inst✝ : IsScalarTower R ℝ≥0∞ ℝ≥0∞
μ ν : FiniteMeasure Ω
x✝ : Set Ω
⊢ ENNReal.toNNReal (↑↑↑(μ + ν) x✝) = ((fun s => ENNReal.toNNReal (↑↑↑μ s)) + fun s => ENNReal.toNNReal (↑↑↑ν s)) x✝

tactic: norm_cast
state_before: case h
Ω : Type u_1
inst✝⁴ : MeasurableSpace Ω
R : Type ?u.11466
inst✝³ : SMul R ℝ≥0
inst✝² : SMul R ℝ≥0∞
inst✝¹ : IsScalarTower R ℝ≥0 ℝ≥0∞
inst✝ : IsScalarTower R ℝ≥0∞ ℝ≥0∞
μ ν : FiniteMeasure Ω
x✝ : Set Ω
⊢ ↑↑↑(μ + ν) x✝ = ↑↑↑μ x✝ + ↑↑↑ν x✝
Theorem: Nat.prime_of_coprime
File: Mathlib/Data/Nat/Prime.lean

tactic: refine' prime_def_lt.mpr ⟨h1, fun m mlt mdvd => _⟩
state_before: n : ℕ
h1 : 1 < n
h : ∀ (m : ℕ), m < n → m ≠ 0 → coprime n m
⊢ Prime n

tactic: have hm : m ≠ 0 := by
  rintro rfl
  rw [zero_dvd_iff] at mdvd
  exact mlt.ne' mdvd
state_before: n : ℕ
h1 : 1 < n
h : ∀ (m : ℕ), m < n → m ≠ 0 → coprime n m
m : ℕ
mlt : m < n
mdvd : m ∣ n
⊢ m = 1

tactic: exact (h m mlt hm).symm.eq_one_of_dvd mdvd
state_before: n : ℕ
h1 : 1 < n
h : ∀ (m : ℕ), m < n → m ≠ 0 → coprime n m
m : ℕ
mlt : m < n
mdvd : m ∣ n
hm : m ≠ 0
⊢ m = 1

tactic: rintro rfl
state_before: n : ℕ
h1 : 1 < n
h : ∀ (m : ℕ), m < n → m ≠ 0 → coprime n m
m : ℕ
mlt : m < n
mdvd : m ∣ n
⊢ m ≠ 0

tactic: rw [zero_dvd_iff] at mdvd
state_before: n : ℕ
h1 : 1 < n
h : ∀ (m : ℕ), m < n → m ≠ 0 → coprime n m
mlt : 0 < n
mdvd : 0 ∣ n
⊢ False

tactic: exact mlt.ne' mdvd
state_before: n : ℕ
h1 : 1 < n
h : ∀ (m : ℕ), m < n → m ≠ 0 → coprime n m
mlt : 0 < n
mdvd : n = 0
⊢ False
Theorem: Finset.diag_mem_sym2_mem_iff
File: Mathlib/Data/Finset/Sym.lean

tactic: rw [← mem_sym2_iff]
state_before: α : Type u_1
inst✝ : DecidableEq α
s t : Finset α
a b : α
m : Sym2 α
⊢ (∀ (b : α), b ∈ Sym2.diag a → b ∈ s) ↔ a ∈ s

tactic: exact mk'_mem_sym2_iff.trans <| and_self_iff _
state_before: α : Type u_1
inst✝ : DecidableEq α
s t : Finset α
a b : α
m : Sym2 α
⊢ Sym2.diag a ∈ Finset.sym2 s ↔ a ∈ s