tasksource/leandojo huggingface dataset:
Theorem: Polynomial.degree_mul_le
File: Mathlib/Data/Polynomial/Degree/Definitions.lean

tactic: simp only [← C_mul_X_pow_eq_monomial.symm, mul_eq_sum_sum (p := p) (q := q)]
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p✝ q✝ : R[X]
ι : Type ?u.567630
p q : R[X]
⊢ degree (p * q) ≤ sup (support p) fun i => degree (sum q fun j a => ↑C (coeff p i * a) * X ^ (i + j))

tactic: exact degree_sum_le _ _
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p✝ q✝ : R[X]
ι : Type ?u.567630
p q : R[X]
⊢ degree (∑ x in support p, sum q fun j a => ↑(monomial (x + j)) (coeff p x * a)) ≤
    sup (support p) fun i => degree (sum q fun j a => ↑(monomial (i + j)) (coeff p i * a))

tactic: refine'
  Finset.sup_le fun a ha => Finset.sup_le fun b hb => le_trans (degree_C_mul_X_pow_le _ _) _
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p✝ q✝ : R[X]
ι : Type ?u.567630
p q : R[X]
⊢ (sup (support p) fun i => sup (support q) fun j => degree (↑C (coeff p i * coeff q j) * X ^ (i + j))) ≤
    degree p + degree q

tactic: rw [Nat.cast_withBot, WithBot.coe_add]
state_before: R : Type u
S : Type v
a✝ b✝ c d : R
n m : ℕ
inst✝ : Semiring R
p✝ q✝ : R[X]
ι : Type ?u.567630
p q : R[X]
a : ℕ
ha : a ∈ support p
b : ℕ
hb : b ∈ support q
⊢ ↑(a + b) ≤ degree p + degree q

tactic: rw [mem_support_iff] at ha hb
state_before: R : Type u
S : Type v
a✝ b✝ c d : R
n m : ℕ
inst✝ : Semiring R
p✝ q✝ : R[X]
ι : Type ?u.567630
p q : R[X]
a : ℕ
ha : a ∈ support p
b : ℕ
hb : b ∈ support q
⊢ ↑a + ↑b ≤ degree p + degree q

tactic: exact add_le_add (le_degree_of_ne_zero ha) (le_degree_of_ne_zero hb)
state_before: R : Type u
S : Type v
a✝ b✝ c d : R
n m : ℕ
inst✝ : Semiring R
p✝ q✝ : R[X]
ι : Type ?u.567630
p q : R[X]
a : ℕ
ha : coeff p a ≠ 0
b : ℕ
hb : coeff q b ≠ 0
⊢ ↑a + ↑b ≤ degree p + degree q
Theorem: Nat.pred_eq_succ_iff
File: Mathlib/Data/Nat/Basic.lean

tactic: cases n <;> constructor <;> rintro ⟨⟩ <;> rfl
state_before: m✝ n✝ k n m : ℕ
⊢ pred n = succ m ↔ n = m + 2
Theorem: ContinuousLinearEquiv.comp_contDiffAt_iff
File: Mathlib/Analysis/Calculus/ContDiff.lean

tactic: simp only [← contDiffWithinAt_univ, e.comp_contDiffWithinAt_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.297390
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 : F ≃L[𝕜] G
⊢ ContDiffAt 𝕜 n (↑e ∘ f) x ↔ ContDiffAt 𝕜 n f x
Theorem: continuousWithinAt_union
File: Mathlib/Topology/ContinuousOn.lean

tactic: simp only [ContinuousWithinAt, nhdsWithin_union, tendsto_sup]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.322097
δ : Type ?u.322100
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : α → β
s t : Set α
x : α
⊢ ContinuousWithinAt f (s ∪ t) x ↔ ContinuousWithinAt f s x ∧ ContinuousWithinAt f t x
Theorem: exists_deriv_eq_zero'
File: Mathlib/Analysis/Calculus/LocalExtr.lean

tactic: push_neg  at h
state_before: f f' : ℝ → ℝ
a b l : ℝ
hab : a < b
hfa : Tendsto f (𝓝[Ioi a] a) (𝓝 l)
hfb : Tendsto f (𝓝[Iio b] b) (𝓝 l)
h : ¬∀ (x : ℝ), x ∈ Ioo a b → DifferentiableAt ℝ f x
⊢ ∃ x, x ∈ Ioo a b ∧ ¬DifferentiableAt ℝ f x

tactic: exact h
state_before: f f' : ℝ → ℝ
a b l : ℝ
hab : a < b
hfa : Tendsto f (𝓝[Ioi a] a) (𝓝 l)
hfb : Tendsto f (𝓝[Iio b] b) (𝓝 l)
h : ∃ x, x ∈ Ioo a b ∧ ¬DifferentiableAt ℝ f x
⊢ ∃ x, x ∈ Ioo a b ∧ ¬DifferentiableAt ℝ f x
Theorem: divp_mul_divp
File: Mathlib/Algebra/Group/Units.lean

tactic: rw [divp_mul_eq_mul_divp, divp_assoc', divp_divp_eq_divp_mul]
state_before: α : Type u
inst✝ : CommMonoid α
x y : α
ux uy : αˣ
⊢ x /ₚ ux * (y /ₚ uy) = x * y /ₚ (ux * uy)
Theorem: SimpleGraph.Walk.toSubgraph_rotate
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: rw [rotate, toSubgraph_append, sup_comm, ← toSubgraph_append, take_spec]
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v w : V
inst✝ : DecidableEq V
c : Walk G v v
h : u ∈ support c
⊢ Walk.toSubgraph (rotate c h) = Walk.toSubgraph c
Theorem: List.get?_zip_eq_some
File: Mathlib/Data/List/Zip.lean

tactic: cases z
state_before: α : Type u
β : Type u_1
γ : Type ?u.155522
δ : Type ?u.155525
ε : Type ?u.155528
l₁ : List α
l₂ : List β
z : α × β
i : ℕ
⊢ get? (zip l₁ l₂) i = some z ↔ get? l₁ i = some z.fst ∧ get? l₂ i = some z.snd

tactic: rw [zip, get?_zip_with_eq_some]
state_before: case mk
α : Type u
β : Type u_1
γ : Type ?u.155522
δ : Type ?u.155525
ε : Type ?u.155528
l₁ : List α
l₂ : List β
i : ℕ
fst✝ : α
snd✝ : β
⊢ get? (zip l₁ l₂) i = some (fst✝, snd✝) ↔ get? l₁ i = some (fst✝, snd✝).fst ∧ get? l₂ i = some (fst✝, snd✝).snd

tactic: constructor
state_before: case mk
α : Type u
β : Type u_1
γ : Type ?u.155522
δ : Type ?u.155525
ε : Type ?u.155528
l₁ : List α
l₂ : List β
i : ℕ
fst✝ : α
snd✝ : β
⊢ (∃ x y, get? l₁ i = some x ∧ get? l₂ i = some y ∧ (x, y) = (fst✝, snd✝)) ↔
    get? l₁ i = some (fst✝, snd✝).fst ∧ get? l₂ i = some (fst✝, snd✝).snd

tactic: rintro ⟨x, y, h₀, h₁, h₂⟩
state_before: case mk.mp
α : Type u
β : Type u_1
γ : Type ?u.155522
δ : Type ?u.155525
ε : Type ?u.155528
l₁ : List α
l₂ : List β
i : ℕ
fst✝ : α
snd✝ : β
⊢ (∃ x y, get? l₁ i = some x ∧ get? l₂ i = some y ∧ (x, y) = (fst✝, snd✝)) →
    get? l₁ i = some (fst✝, snd✝).fst ∧ get? l₂ i = some (fst✝, snd✝).snd

tactic: simpa [h₀, h₁] using h₂
state_before: case mk.mp.intro.intro.intro.intro
α : Type u
β : Type u_1
γ : Type ?u.155522
δ : Type ?u.155525
ε : Type ?u.155528
l₁ : List α
l₂ : List β
i : ℕ
fst✝ : α
snd✝ : β
x : α
y : β
h₀ : get? l₁ i = some x
h₁ : get? l₂ i = some y
h₂ : (x, y) = (fst✝, snd✝)
⊢ get? l₁ i = some (fst✝, snd✝).fst ∧ get? l₂ i = some (fst✝, snd✝).snd

tactic: rintro ⟨h₀, h₁⟩
state_before: case mk.mpr
α : Type u
β : Type u_1
γ : Type ?u.155522
δ : Type ?u.155525
ε : Type ?u.155528
l₁ : List α
l₂ : List β
i : ℕ
fst✝ : α
snd✝ : β
⊢ get? l₁ i = some (fst✝, snd✝).fst ∧ get? l₂ i = some (fst✝, snd✝).snd →
    ∃ x y, get? l₁ i = some x ∧ get? l₂ i = some y ∧ (x, y) = (fst✝, snd✝)

tactic: exact ⟨_, _, h₀, h₁, rfl⟩
state_before: case mk.mpr.intro
α : Type u
β : Type u_1
γ : Type ?u.155522
δ : Type ?u.155525
ε : Type ?u.155528
l₁ : List α
l₂ : List β
i : ℕ
fst✝ : α
snd✝ : β
h₀ : get? l₁ i = some (fst✝, snd✝).fst
h₁ : get? l₂ i = some (fst✝, snd✝).snd
⊢ ∃ x y, get? l₁ i = some x ∧ get? l₂ i = some y ∧ (x, y) = (fst✝, snd✝)
Theorem: ENNReal.exists_mem_Ioc_zpow
File: Mathlib/Data/Real/ENNReal.lean

tactic: lift x to ℝ≥0 using h'x
state_before: α : Type ?u.560921
β : Type ?u.560924
a b c d : ℝ≥0∞
r p q : ℝ≥0
x y : ℝ≥0∞
hx : x ≠ 0
h'x : x ≠ ⊤
hy : 1 < y
h'y : y ≠ ⊤
⊢ ∃ n, x ∈ Ioc (y ^ n) (y ^ (n + 1))

tactic: lift y to ℝ≥0 using h'y
state_before: case intro
α : Type ?u.560921
β : Type ?u.560924
a b c d : ℝ≥0∞
r p q : ℝ≥0
y : ℝ≥0∞
hy : 1 < y
h'y : y ≠ ⊤
x : ℝ≥0
hx : ↑x ≠ 0
⊢ ∃ n, ↑x ∈ Ioc (y ^ n) (y ^ (n + 1))

tactic: have A : y ≠ 0 := by simpa only [Ne.def, coe_eq_zero] using (zero_lt_one.trans hy).ne'
state_before: case intro.intro
α : Type ?u.560921
β : Type ?u.560924
a b c d : ℝ≥0∞
r p q x : ℝ≥0
hx : ↑x ≠ 0
y : ℝ≥0
hy : 1 < ↑y
⊢ ∃ n, ↑x ∈ Ioc (↑y ^ n) (↑y ^ (n + 1))

tactic: obtain ⟨n, hn, h'n⟩ : ∃ n : ℤ, y ^ n < x ∧ x ≤ y ^ (n + 1) := by
  refine' NNReal.exists_mem_Ioc_zpow _ (one_lt_coe_iff.1 hy)
  simpa only [Ne.def, coe_eq_zero] using hx
state_before: case intro.intro
α : Type ?u.560921
β : Type ?u.560924
a b c d : ℝ≥0∞
r p q x : ℝ≥0
hx : ↑x ≠ 0
y : ℝ≥0
hy : 1 < ↑y
A : y ≠ 0
⊢ ∃ n, ↑x ∈ Ioc (↑y ^ n) (↑y ^ (n + 1))

tactic: refine' ⟨n, _, _⟩
state_before: case intro.intro.intro.intro
α : Type ?u.560921
β : Type ?u.560924
a b c d : ℝ≥0∞
r p q x : ℝ≥0
hx : ↑x ≠ 0
y : ℝ≥0
hy : 1 < ↑y
A : y ≠ 0
n : ℤ
hn : y ^ n < x
h'n : x ≤ y ^ (n + 1)
⊢ ∃ n, ↑x ∈ Ioc (↑y ^ n) (↑y ^ (n + 1))

tactic: simpa only [Ne.def, coe_eq_zero] using (zero_lt_one.trans hy).ne'
state_before: α : Type ?u.560921
β : Type ?u.560924
a b c d : ℝ≥0∞
r p q x : ℝ≥0
hx : ↑x ≠ 0
y : ℝ≥0
hy : 1 < ↑y
⊢ y ≠ 0

tactic: refine' NNReal.exists_mem_Ioc_zpow _ (one_lt_coe_iff.1 hy)
state_before: α : Type ?u.560921
β : Type ?u.560924
a b c d : ℝ≥0∞
r p q x : ℝ≥0
hx : ↑x ≠ 0
y : ℝ≥0
hy : 1 < ↑y
A : y ≠ 0
⊢ ∃ n, y ^ n < x ∧ x ≤ y ^ (n + 1)

tactic: simpa only [Ne.def, coe_eq_zero] using hx
state_before: α : Type ?u.560921
β : Type ?u.560924
a b c d : ℝ≥0∞
r p q x : ℝ≥0
hx : ↑x ≠ 0
y : ℝ≥0
hy : 1 < ↑y
A : y ≠ 0
⊢ x ≠ 0

tactic: rwa [← ENNReal.coe_zpow A, ENNReal.coe_lt_coe]
state_before: case intro.intro.intro.intro.refine'_1
α : Type ?u.560921
β : Type ?u.560924
a b c d : ℝ≥0∞
r p q x : ℝ≥0
hx : ↑x ≠ 0
y : ℝ≥0
hy : 1 < ↑y
A : y ≠ 0
n : ℤ
hn : y ^ n < x
h'n : x ≤ y ^ (n + 1)
⊢ ↑y ^ n < ↑x

tactic: rwa [← ENNReal.coe_zpow A, ENNReal.coe_le_coe]
state_before: case intro.intro.intro.intro.refine'_2
α : Type ?u.560921
β : Type ?u.560924
a b c d : ℝ≥0∞
r p q x : ℝ≥0
hx : ↑x ≠ 0
y : ℝ≥0
hy : 1 < ↑y
A : y ≠ 0
n : ℤ
hn : y ^ n < x
h'n : x ≤ y ^ (n + 1)
⊢ ↑x ≤ ↑y ^ (n + 1)
Theorem: Num.cast_bit0
File: Mathlib/Data/Num/Lemmas.lean

tactic: rw [← bit0_of_bit0, _root_.bit0, cast_add]
state_before: α : Type u_1
inst✝ : Semiring α
n : Num
⊢ ↑(Num.bit0 n) = _root_.bit0 ↑n

tactic: rfl
state_before: α : Type u_1
inst✝ : Semiring α
n : Num
⊢ ↑n + ↑n = _root_.bit0 ↑n
Theorem: intervalIntegral.norm_integral_eq_norm_integral_Ioc
File: Mathlib/MeasureTheory/Integral/IntervalIntegral.lean

tactic: rw [← norm_integral_min_max, integral_of_le min_le_max, uIoc]
state_before: ι : Type ?u.11586972
𝕜 : Type ?u.11586975
E : Type u_1
F : Type ?u.11586981
A : Type ?u.11586984
inst✝² : NormedAddCommGroup E
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
a b : ℝ
f✝ g : ℝ → E
μ : MeasureTheory.Measure ℝ
f : ℝ → E
⊢ ‖∫ (x : ℝ) in a..b, f x ∂μ‖ = ‖∫ (x : ℝ) in Ι a b, f x ∂μ‖
Theorem: Set.iUnion_Ioc_right
File: Mathlib/Data/Set/Intervals/Disjoint.lean

tactic: simp only [← Ioi_inter_Iic, ← inter_iUnion, iUnion_Iic, inter_univ]
state_before: ι : Sort u
α : Type v
β : Type w
inst✝ : Preorder α
a✝ b c a : α
⊢ (⋃ (b : α), Ioc a b) = Ioi a
Theorem: PNat.factorMultiset_mul
File: Mathlib/Data/PNat/Factors.lean

tactic: let u := factorMultiset n
state_before: n m : ℕ+
⊢ factorMultiset (n * m) = factorMultiset n + factorMultiset m

tactic: let v := factorMultiset m
state_before: n m : ℕ+
u : PrimeMultiset := factorMultiset n
⊢ factorMultiset (n * m) = factorMultiset n + factorMultiset m

tactic: have : n = u.prod := (prod_factorMultiset n).symm
state_before: n m : ℕ+
u : PrimeMultiset := factorMultiset n
v : PrimeMultiset := factorMultiset m
⊢ factorMultiset (n * m) = factorMultiset n + factorMultiset m

tactic: rw [this]
state_before: n m : ℕ+
u : PrimeMultiset := factorMultiset n
v : PrimeMultiset := factorMultiset m
this : n = PrimeMultiset.prod u
⊢ factorMultiset (n * m) = factorMultiset n + factorMultiset m

tactic: have : m = v.prod := (prod_factorMultiset m).symm
state_before: n m : ℕ+
u : PrimeMultiset := factorMultiset n
v : PrimeMultiset := factorMultiset m
this : n = PrimeMultiset.prod u
⊢ factorMultiset (PrimeMultiset.prod u * m) = factorMultiset (PrimeMultiset.prod u) + factorMultiset m

tactic: rw [this]
state_before: n m : ℕ+
u : PrimeMultiset := factorMultiset n
v : PrimeMultiset := factorMultiset m
this✝ : n = PrimeMultiset.prod u
this : m = PrimeMultiset.prod v
⊢ factorMultiset (PrimeMultiset.prod u * m) = factorMultiset (PrimeMultiset.prod u) + factorMultiset m

tactic: rw [← PrimeMultiset.prod_add]
state_before: n m : ℕ+
u : PrimeMultiset := factorMultiset n
v : PrimeMultiset := factorMultiset m
this✝ : n = PrimeMultiset.prod u
this : m = PrimeMultiset.prod v
⊢ factorMultiset (PrimeMultiset.prod u * PrimeMultiset.prod v) =
    factorMultiset (PrimeMultiset.prod u) + factorMultiset (PrimeMultiset.prod v)

tactic: repeat' rw [PrimeMultiset.factorMultiset_prod]
state_before: n m : ℕ+
u : PrimeMultiset := factorMultiset n
v : PrimeMultiset := factorMultiset m
this✝ : n = PrimeMultiset.prod u
this : m = PrimeMultiset.prod v
⊢ factorMultiset (PrimeMultiset.prod (u + v)) =
    factorMultiset (PrimeMultiset.prod u) + factorMultiset (PrimeMultiset.prod v)

tactic: rw [PrimeMultiset.factorMultiset_prod]
state_before: n m : ℕ+
u : PrimeMultiset := factorMultiset n
v : PrimeMultiset := factorMultiset m
this✝ : n = PrimeMultiset.prod u
this : m = PrimeMultiset.prod v
⊢ u + v = u + factorMultiset (PrimeMultiset.prod v)
Theorem: MeasureTheory.ExistsSeqTendstoAe.seqTendstoAeSeq_succ
File: Mathlib/MeasureTheory/Function/ConvergenceInMeasure.lean

tactic: rw [seqTendstoAeSeq]
state_before: α : Type u_1
ι : Type ?u.15886
E : Type u_2
m : MeasurableSpace α
μ : Measure α
inst✝ : MetricSpace E
f : ℕ → α → E
g : α → E
hfg : TendstoInMeasure μ f atTop g
n : ℕ
⊢ seqTendstoAeSeq hfg (n + 1) = max (seqTendstoAeSeqAux hfg (n + 1)) (seqTendstoAeSeq hfg n + 1)
Theorem: Submodule.prod_span
File: Mathlib/Algebra/Algebra/Operations.lean

tactic: letI := Classical.decEq ι
state_before: ι✝ : Sort uι
R : Type u
inst✝² : CommSemiring R
A : Type v
inst✝¹ : CommSemiring A
inst✝ : Algebra R A
M✝ N : Submodule R A
m n : A
ι : Type u_1
s : Finset ι
M : ι → Set A
⊢ ∏ i in s, span R (M i) = span R (∏ i in s, M i)

tactic: refine' Finset.induction_on s _ _
state_before: ι✝ : Sort uι
R : Type u
inst✝² : CommSemiring R
A : Type v
inst✝¹ : CommSemiring A
inst✝ : Algebra R A
M✝ N : Submodule R A
m n : A
ι : Type u_1
s : Finset ι
M : ι → Set A
this : DecidableEq ι := Classical.decEq ι
⊢ ∏ i in s, span R (M i) = span R (∏ i in s, M i)

tactic: simp [one_eq_span, Set.singleton_one]
state_before: case refine'_1
ι✝ : Sort uι
R : Type u
inst✝² : CommSemiring R
A : Type v
inst✝¹ : CommSemiring A
inst✝ : Algebra R A
M✝ N : Submodule R A
m n : A
ι : Type u_1
s : Finset ι
M : ι → Set A
this : DecidableEq ι := Classical.decEq ι
⊢ ∏ i in ∅, span R (M i) = span R (∏ i in ∅, M i)

tactic: intro _ _ H ih
state_before: case refine'_2
ι✝ : Sort uι
R : Type u
inst✝² : CommSemiring R
A : Type v
inst✝¹ : CommSemiring A
inst✝ : Algebra R A
M✝ N : Submodule R A
m n : A
ι : Type u_1
s : Finset ι
M : ι → Set A
this : DecidableEq ι := Classical.decEq ι
⊢ ∀ ⦃a : ι⦄ {s : Finset ι},
    ¬a ∈ s →
      ∏ i in s, span R (M i) = span R (∏ i in s, M i) →
        ∏ i in insert a s, span R (M i) = span R (∏ i in insert a s, M i)

tactic: rw [Finset.prod_insert H, Finset.prod_insert H, ih, span_mul_span]
state_before: case refine'_2
ι✝ : Sort uι
R : Type u
inst✝² : CommSemiring R
A : Type v
inst✝¹ : CommSemiring A
inst✝ : Algebra R A
M✝ N : Submodule R A
m n : A
ι : Type u_1
s : Finset ι
M : ι → Set A
this : DecidableEq ι := Classical.decEq ι
a✝ : ι
s✝ : Finset ι
H : ¬a✝ ∈ s✝
ih : ∏ i in s✝, span R (M i) = span R (∏ i in s✝, M i)
⊢ ∏ i in insert a✝ s✝, span R (M i) = span R (∏ i in insert a✝ s✝, M i)
Theorem: MonoidHom.ker_eq_bot_of_cancel
File: Mathlib/Algebra/Category/GroupCat/EpiMono.lean

tactic: simpa using _root_.congr_arg range (h f.ker.subtype 1 (by aesop_cat))
state_before: A : Type u
B : Type v
inst✝¹ : Group A
inst✝ : Group B
f : A →* B
h : ∀ (u v : { x // x ∈ ker f } →* A), comp f u = comp f v → u = v
⊢ ker f = ⊥

tactic: aesop_cat
state_before: A : Type u
B : Type v
inst✝¹ : Group A
inst✝ : Group B
f : A →* B
h : ∀ (u v : { x // x ∈ ker f } →* A), comp f u = comp f v → u = v
⊢ comp f (Subgroup.subtype (ker f)) = comp f 1
Theorem: AlgebraicTopology.DoldKan.PInfty_f_idem
File: Mathlib/AlgebraicTopology/DoldKan/PInfty.lean

tactic: simp only [PInfty_f, P_f_idem]
state_before: C : Type u_2
inst✝¹ : Category C
inst✝ : Preadditive C
X : SimplicialObject C
n : ℕ
⊢ HomologicalComplex.Hom.f PInfty n ≫ HomologicalComplex.Hom.f PInfty n = HomologicalComplex.Hom.f PInfty n
Theorem: CategoryTheory.NatIso.cancel_natIso_inv_right_assoc
File: Mathlib/CategoryTheory/NatIso.lean

tactic: simp only [← Category.assoc, cancel_mono, refl]
state_before: C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
E : Type u₃
inst✝ : Category E
F G : C ⥤ D
α : F ≅ G
W X X' : D
Y : C
f : W ⟶ X
g : X ⟶ G.obj Y
f' : W ⟶ X'
g' : X' ⟶ G.obj Y
⊢ f ≫ g ≫ α.inv.app Y = f' ≫ g' ≫ α.inv.app Y ↔ f ≫ g = f' ≫ g'
Theorem: eq_iff_eq_of_div_eq_div
File: Mathlib/Algebra/Group/Basic.lean

tactic: rw [← div_eq_one, H, div_eq_one]
state_before: α : Type ?u.62821
β : Type ?u.62824
G : Type u_1
inst✝ : Group G
a b c d : G
H : a / b = c / d
⊢ a = b ↔ c = d
Theorem: NormedSpace.eq_zero_iff_forall_dual_eq_zero
File: Mathlib/Analysis/NormedSpace/Dual.lean

tactic: simp [hx]
state_before: 𝕜 : Type v
inst✝² : IsROrC 𝕜
E : Type u
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
x : E
hx : x = 0
⊢ ∀ (g : Dual 𝕜 E), ↑g x = 0
Theorem: Equiv.pointReflection_midpoint_left
File: Mathlib/LinearAlgebra/AffineSpace/Midpoint.lean

tactic: rw [midpoint, pointReflection_apply, lineMap_apply, vadd_vsub, vadd_vadd, ← add_smul, ← two_mul,
  mul_invOf_self, one_smul, vsub_vadd]
state_before: R : Type u_3
V : Type u_2
V' : Type ?u.17515
P : Type u_1
P' : Type ?u.17521
inst✝⁷ : Ring R
inst✝⁶ : Invertible 2
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
x✝ y✝ z x y : P
⊢ ↑(pointReflection (midpoint R x y)) x = y
Theorem: CategoryTheory.Abelian.Functor.preserves_exact_of_PreservesFiniteColimits_of_epi
File: Mathlib/CategoryTheory/Abelian/LeftDerived.lean

tactic: simp [← Functor.map_comp, ex.w]
state_before: C : Type u
inst✝⁶ : Category C
D : Type u
inst✝⁵ : Category D
F : C ⥤ D
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
inst✝⁴ : Abelian C
inst✝³ : Abelian D
inst✝² : Functor.Additive F
inst✝¹ : PreservesFiniteColimits F
inst✝ : Epi g
ex : Exact f g
⊢ F.map f ≫ F.map g = 0
Theorem: CategoryTheory.Endofunctor.Algebra.Initial.left_inv'
File: Mathlib/CategoryTheory/Endofunctor/Algebra.lean

tactic: rw [←Category.assoc, F.map_comp, strInv, ←Hom.h]
state_before: C : Type u
inst✝ : Category C
F : C ⥤ C
A A₀ A₁ A₂ : Algebra F
f : A₀ ⟶ A₁
g : A₁ ⟶ A₂
h : Limits.IsInitial A
⊢ F.map (strInv h ≫ A.str) ≫ A.str = A.str ≫ strInv h ≫ A.str
Theorem: UniformCauchySeqOn.uniformCauchySeqOnFilter
File: Mathlib/Topology/UniformSpace/UniformConvergence.lean

tactic: rwa [← uniformCauchySeqOn_iff_uniformCauchySeqOnFilter]
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
hF : UniformCauchySeqOn F p s
⊢ UniformCauchySeqOnFilter F p (𝓟 s)
Theorem: SimpleGraph.le_card_nonuniformWitness
File: Mathlib/Combinatorics/SimpleGraph/Regularity/Uniform.lean

tactic: unfold nonuniformWitness
state_before: α : Type u_1
𝕜 : Type u_2
inst✝¹ : LinearOrderedField 𝕜
G : SimpleGraph α
inst✝ : DecidableRel G.Adj
ε : 𝕜
s t : Finset α
a b : α
h : ¬IsUniform G ε s t
⊢ ↑(card s) * ε ≤ ↑(card (nonuniformWitness G ε s t))

tactic: split_ifs
state_before: α : Type u_1
𝕜 : Type u_2
inst✝¹ : LinearOrderedField 𝕜
G : SimpleGraph α
inst✝ : DecidableRel G.Adj
ε : 𝕜
s t : Finset α
a b : α
h : ¬IsUniform G ε s t
⊢ ↑(card s) * ε ≤
    ↑(card (if WellOrderingRel s t then (nonuniformWitnesses G ε s t).fst else (nonuniformWitnesses G ε t s).snd))

tactic: exact G.left_nonuniformWitnesses_card h
state_before: case inl
α : Type u_1
𝕜 : Type u_2
inst✝¹ : LinearOrderedField 𝕜
G : SimpleGraph α
inst✝ : DecidableRel G.Adj
ε : 𝕜
s t : Finset α
a b : α
h : ¬IsUniform G ε s t
h✝ : WellOrderingRel s t
⊢ ↑(card s) * ε ≤ ↑(card (nonuniformWitnesses G ε s t).fst)

tactic: exact G.right_nonuniformWitnesses_card fun i => h i.symm
state_before: case inr
α : Type u_1
𝕜 : Type u_2
inst✝¹ : LinearOrderedField 𝕜
G : SimpleGraph α
inst✝ : DecidableRel G.Adj
ε : 𝕜
s t : Finset α
a b : α
h : ¬IsUniform G ε s t
h✝ : ¬WellOrderingRel s t
⊢ ↑(card s) * ε ≤ ↑(card (nonuniformWitnesses G ε t s).snd)
Theorem: Finsupp.iInf_ker_lapply_le_bot
File: Mathlib/LinearAlgebra/Finsupp.lean

tactic: simp only [SetLike.le_def, mem_iInf, mem_ker, mem_bot, lapply_apply]
state_before: α : Type u_1
M : Type u_2
N : Type ?u.32590
P : Type ?u.32593
R : Type u_3
S : Type ?u.32599
inst✝⁷ : Semiring R
inst✝⁶ : Semiring S
inst✝⁵ : AddCommMonoid M
inst✝⁴ : Module R M
inst✝³ : AddCommMonoid N
inst✝² : Module R N
inst✝¹ : AddCommMonoid P
inst✝ : Module R P
⊢ (⨅ (a : α), ker (lapply a)) ≤ ⊥

tactic: exact fun a h => Finsupp.ext h
state_before: α : Type u_1
M : Type u_2
N : Type ?u.32590
P : Type ?u.32593
R : Type u_3
S : Type ?u.32599
inst✝⁷ : Semiring R
inst✝⁶ : Semiring S
inst✝⁵ : AddCommMonoid M
inst✝⁴ : Module R M
inst✝³ : AddCommMonoid N
inst✝² : Module R N
inst✝¹ : AddCommMonoid P
inst✝ : Module R P
⊢ ∀ ⦃x : α →₀ M⦄, (∀ (i : α), ↑x i = 0) → x = 0
Theorem: Polynomial.coeff_update
File: Mathlib/Data/Polynomial/Basic.lean

tactic: ext
state_before: R : Type u
a✝ b : R
m n✝ : ℕ
inst✝ : Semiring R
p✝ q p : R[X]
n : ℕ
a : R
⊢ coeff (update p n a) = Function.update (coeff p) n a

tactic: cases p
state_before: case h
R : Type u
a✝ b : R
m n✝ : ℕ
inst✝ : Semiring R
p✝ q p : R[X]
n : ℕ
a : R
x✝ : ℕ
⊢ coeff (update p n a) x✝ = Function.update (coeff p) n a x✝

tactic: simp only [coeff, update, Function.update_apply, coe_update]
state_before: case h.ofFinsupp
R : Type u
a✝ b : R
m n✝ : ℕ
inst✝ : Semiring R
p q : R[X]
n : ℕ
a : R
x✝ : ℕ
toFinsupp✝ : AddMonoidAlgebra R ℕ
⊢ coeff (update { toFinsupp := toFinsupp✝ } n a) x✝ = Function.update (coeff { toFinsupp := toFinsupp✝ }) n a x✝
Theorem: AlgHom.fieldRange_of_normal
File: Mathlib/FieldTheory/Normal.lean

tactic: letI : Algebra E E := Algebra.id E
state_before: F : Type u_1
K : Type u_2
inst✝¹⁹ : Field F
inst✝¹⁸ : Field K
inst✝¹⁷ : Algebra F K
K₁ : Type ?u.303481
K₂ : Type ?u.303484
K₃ : Type ?u.303487
inst✝¹⁶ : Field F
inst✝¹⁵ : Field K₁
inst✝¹⁴ : Field K₂
inst✝¹³ : Field K₃
inst✝¹² : Algebra F K₁
inst✝¹¹ : Algebra F K₂
inst✝¹⁰ : Algebra F K₃
ϕ : K₁ →ₐ[F] K₂
χ : K₁ ≃ₐ[F] K₂
ψ : K₂ →ₐ[F] K₃
ω : K₂ ≃ₐ[F] K₃
E✝ : Type ?u.303905
inst✝⁹ : Field E✝
inst✝⁸ : Algebra F E✝
inst✝⁷ : Algebra E✝ K₁
inst✝⁶ : Algebra E✝ K₂
inst✝⁵ : Algebra E✝ K₃
inst✝⁴ : IsScalarTower F E✝ K₁
inst✝³ : IsScalarTower F E✝ K₂
inst✝² : IsScalarTower F E✝ K₃
inst✝¹ : Algebra F K
E : IntermediateField F K
inst✝ : Normal F { x // x ∈ E }
f : { x // x ∈ E } →ₐ[F] K
⊢ fieldRange f = E

tactic: let g := f.restrictNormal' E
state_before: F : Type u_1
K : Type u_2
inst✝¹⁹ : Field F
inst✝¹⁸ : Field K
inst✝¹⁷ : Algebra F K
K₁ : Type ?u.303481
K₂ : Type ?u.303484
K₃ : Type ?u.303487
inst✝¹⁶ : Field F
inst✝¹⁵ : Field K₁
inst✝¹⁴ : Field K₂
inst✝¹³ : Field K₃
inst✝¹² : Algebra F K₁
inst✝¹¹ : Algebra F K₂
inst✝¹⁰ : Algebra F K₃
ϕ : K₁ →ₐ[F] K₂
χ : K₁ ≃ₐ[F] K₂
ψ : K₂ →ₐ[F] K₃
ω : K₂ ≃ₐ[F] K₃
E✝ : Type ?u.303905
inst✝⁹ : Field E✝
inst✝⁸ : Algebra F E✝
inst✝⁷ : Algebra E✝ K₁
inst✝⁶ : Algebra E✝ K₂
inst✝⁵ : Algebra E✝ K₃
inst✝⁴ : IsScalarTower F E✝ K₁
inst✝³ : IsScalarTower F E✝ K₂
inst✝² : IsScalarTower F E✝ K₃
inst✝¹ : Algebra F K
E : IntermediateField F K
inst✝ : Normal F { x // x ∈ E }
f : { x // x ∈ E } →ₐ[F] K
this : Algebra { x // x ∈ E } { x // x ∈ E } := Algebra.id { x // x ∈ E }
⊢ fieldRange f = E

tactic: rw [← show E.val.comp ↑g = f from FunLike.ext_iff.mpr (f.restrictNormal_commutes E), ←
  IntermediateField.AlgHom.map_fieldRange, IntermediateField.AlgEquiv.fieldRange_eq_top g,
    ← IntermediateField.AlgHom.fieldRange_eq_map, IntermediateField.fieldRange_val]
state_before: F : Type u_1
K : Type u_2
inst✝¹⁹ : Field F
inst✝¹⁸ : Field K
inst✝¹⁷ : Algebra F K
K₁ : Type ?u.303481
K₂ : Type ?u.303484
K₃ : Type ?u.303487
inst✝¹⁶ : Field F
inst✝¹⁵ : Field K₁
inst✝¹⁴ : Field K₂
inst✝¹³ : Field K₃
inst✝¹² : Algebra F K₁
inst✝¹¹ : Algebra F K₂
inst✝¹⁰ : Algebra F K₃
ϕ : K₁ →ₐ[F] K₂
χ : K₁ ≃ₐ[F] K₂
ψ : K₂ →ₐ[F] K₃
ω : K₂ ≃ₐ[F] K₃
E✝ : Type ?u.303905
inst✝⁹ : Field E✝
inst✝⁸ : Algebra F E✝
inst✝⁷ : Algebra E✝ K₁
inst✝⁶ : Algebra E✝ K₂
inst✝⁵ : Algebra E✝ K₃
inst✝⁴ : IsScalarTower F E✝ K₁
inst✝³ : IsScalarTower F E✝ K₂
inst✝² : IsScalarTower F E✝ K₃
inst✝¹ : Algebra F K
E : IntermediateField F K
inst✝ : Normal F { x // x ∈ E }
f : { x // x ∈ E } →ₐ[F] K
this : Algebra { x // x ∈ E } { x // x ∈ E } := Algebra.id { x // x ∈ E }
g : { x // x ∈ E } ≃ₐ[F] { x // x ∈ E } := restrictNormal' f { x // x ∈ E }
⊢ fieldRange f = E