tasksource/leandojo huggingface dataset:
Theorem: le_nhds_mul
File: Mathlib/Topology/Algebra/Monoid.lean

tactic: rw [← map₂_mul, ← map_uncurry_prod, ← nhds_prod_eq]
state_before: ι : Type ?u.8420
α : Type ?u.8423
X : Type ?u.8426
M : Type u_1
N : Type ?u.8432
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace M
inst✝¹ : Mul M
inst✝ : ContinuousMul M
a b : M
⊢ 𝓝 a * 𝓝 b ≤ 𝓝 (a * b)

tactic: exact continuous_mul.tendsto _
state_before: ι : Type ?u.8420
α : Type ?u.8423
X : Type ?u.8426
M : Type u_1
N : Type ?u.8432
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace M
inst✝¹ : Mul M
inst✝ : ContinuousMul M
a b : M
⊢ map (Function.uncurry fun x x_1 => x * x_1) (𝓝 (a, b)) ≤ 𝓝 (a * b)
Theorem: LocalEquiv.trans_assoc
File: Mathlib/Logic/Equiv/LocalEquiv.lean

tactic: simp [trans_source, @preimage_comp α β γ, inter_assoc]
state_before: α : Type u_3
β : Type u_4
γ : Type u_1
δ : Type u_2
e : LocalEquiv α β
e' : LocalEquiv β γ
e'' : LocalEquiv γ δ
⊢ (LocalEquiv.trans (LocalEquiv.trans e e') e'').source = (LocalEquiv.trans e (LocalEquiv.trans e' e'')).source
Theorem: Ideal.smithCoeffs_ne_zero
File: Mathlib/LinearAlgebra/FreeModule/PID.lean

tactic: intro hi
state_before: ι : Type u_1
R : Type u_2
inst✝⁸ : CommRing R
inst✝⁷ : IsDomain R
inst✝⁶ : IsPrincipalIdealRing R
M : Type ?u.391806
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
b✝ : ι → M
S : Type u_3
inst✝³ : CommRing S
inst✝² : IsDomain S
inst✝¹ : Algebra R S
inst✝ : Finite ι
b : Basis ι R S
I : Ideal S
hI : I ≠ ⊥
i : ι
⊢ smithCoeffs b I hI i ≠ 0

tactic: apply Basis.ne_zero (Ideal.selfBasis b I hI) i
state_before: ι : Type u_1
R : Type u_2
inst✝⁸ : CommRing R
inst✝⁷ : IsDomain R
inst✝⁶ : IsPrincipalIdealRing R
M : Type ?u.391806
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
b✝ : ι → M
S : Type u_3
inst✝³ : CommRing S
inst✝² : IsDomain S
inst✝¹ : Algebra R S
inst✝ : Finite ι
b : Basis ι R S
I : Ideal S
hI : I ≠ ⊥
i : ι
hi : smithCoeffs b I hI i = 0
⊢ False

tactic: refine' Subtype.coe_injective _
state_before: ι : Type u_1
R : Type u_2
inst✝⁸ : CommRing R
inst✝⁷ : IsDomain R
inst✝⁶ : IsPrincipalIdealRing R
M : Type ?u.391806
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
b✝ : ι → M
S : Type u_3
inst✝³ : CommRing S
inst✝² : IsDomain S
inst✝¹ : Algebra R S
inst✝ : Finite ι
b : Basis ι R S
I : Ideal S
hI : I ≠ ⊥
i : ι
hi : smithCoeffs b I hI i = 0
⊢ ↑(selfBasis b I hI) i = 0

tactic: simp [hi]
state_before: ι : Type u_1
R : Type u_2
inst✝⁸ : CommRing R
inst✝⁷ : IsDomain R
inst✝⁶ : IsPrincipalIdealRing R
M : Type ?u.391806
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
b✝ : ι → M
S : Type u_3
inst✝³ : CommRing S
inst✝² : IsDomain S
inst✝¹ : Algebra R S
inst✝ : Finite ι
b : Basis ι R S
I : Ideal S
hI : I ≠ ⊥
i : ι
hi : smithCoeffs b I hI i = 0
⊢ (fun a => ↑a) (↑(selfBasis b I hI) i) = (fun a => ↑a) 0
Theorem: Complex.hasStrictFDerivAt_cpow
File: Mathlib/Analysis/SpecialFunctions/Pow/Deriv.lean

tactic: have A : p.1 ≠ 0 := by intro h; simp [h, lt_irrefl] at hp
state_before: p : ℂ × ℂ
hp : 0 < p.fst.re ∨ p.fst.im ≠ 0
⊢ HasStrictFDerivAt (fun x => x.fst ^ x.snd)
    ((p.snd * p.fst ^ (p.snd - 1)) • ContinuousLinearMap.fst ℂ ℂ ℂ +
      (p.fst ^ p.snd * log p.fst) • ContinuousLinearMap.snd ℂ ℂ ℂ)
    p

tactic: have : (fun x : ℂ × ℂ => x.1 ^ x.2) =ᶠ[𝓝 p] fun x => exp (log x.1 * x.2) :=
  ((isOpen_ne.preimage continuous_fst).eventually_mem A).mono fun p hp =>
    cpow_def_of_ne_zero hp _
state_before: p : ℂ × ℂ
hp : 0 < p.fst.re ∨ p.fst.im ≠ 0
A : p.fst ≠ 0
⊢ HasStrictFDerivAt (fun x => x.fst ^ x.snd)
    ((p.snd * p.fst ^ (p.snd - 1)) • ContinuousLinearMap.fst ℂ ℂ ℂ +
      (p.fst ^ p.snd * log p.fst) • ContinuousLinearMap.snd ℂ ℂ ℂ)
    p

tactic: rw [cpow_sub _ _ A, cpow_one, mul_div_left_comm, mul_smul, mul_smul]
state_before: p : ℂ × ℂ
hp : 0 < p.fst.re ∨ p.fst.im ≠ 0
A : p.fst ≠ 0
this : (fun x => x.fst ^ x.snd) =ᶠ[𝓝 p] fun x => exp (log x.fst * x.snd)
⊢ HasStrictFDerivAt (fun x => x.fst ^ x.snd)
    ((p.snd * p.fst ^ (p.snd - 1)) • ContinuousLinearMap.fst ℂ ℂ ℂ +
      (p.fst ^ p.snd * log p.fst) • ContinuousLinearMap.snd ℂ ℂ ℂ)
    p

tactic: refine' HasStrictFDerivAt.congr_of_eventuallyEq _ this.symm
state_before: p : ℂ × ℂ
hp : 0 < p.fst.re ∨ p.fst.im ≠ 0
A : p.fst ≠ 0
this : (fun x => x.fst ^ x.snd) =ᶠ[𝓝 p] fun x => exp (log x.fst * x.snd)
⊢ HasStrictFDerivAt (fun x => x.fst ^ x.snd)
    (p.fst ^ p.snd • (p.snd / p.fst) • ContinuousLinearMap.fst ℂ ℂ ℂ +
      p.fst ^ p.snd • log p.fst • ContinuousLinearMap.snd ℂ ℂ ℂ)
    p

tactic: simpa only [cpow_def_of_ne_zero A, div_eq_mul_inv, mul_smul, add_comm, smul_add] using
  ((hasStrictFDerivAt_fst.clog hp).mul hasStrictFDerivAt_snd).cexp
state_before: p : ℂ × ℂ
hp : 0 < p.fst.re ∨ p.fst.im ≠ 0
A : p.fst ≠ 0
this : (fun x => x.fst ^ x.snd) =ᶠ[𝓝 p] fun x => exp (log x.fst * x.snd)
⊢ HasStrictFDerivAt (fun x => exp (log x.fst * x.snd))
    (p.fst ^ p.snd • (p.snd / p.fst) • ContinuousLinearMap.fst ℂ ℂ ℂ +
      p.fst ^ p.snd • log p.fst • ContinuousLinearMap.snd ℂ ℂ ℂ)
    p

tactic: intro h
state_before: p : ℂ × ℂ
hp : 0 < p.fst.re ∨ p.fst.im ≠ 0
⊢ p.fst ≠ 0

tactic: simp [h, lt_irrefl] at hp
state_before: p : ℂ × ℂ
hp : 0 < p.fst.re ∨ p.fst.im ≠ 0
h : p.fst = 0
⊢ False
Theorem: OrderMonoidHom.toOrderHom_injective
File: Mathlib/Algebra/Order/Hom/Monoid.lean

tactic: convert FunLike.ext_iff.1 h using 0
state_before: F : Type ?u.78754
α : Type u_1
β : Type u_2
γ : Type ?u.78763
δ : Type ?u.78766
inst✝⁷ : Preorder α
inst✝⁶ : Preorder β
inst✝⁵ : Preorder γ
inst✝⁴ : Preorder δ
inst✝³ : MulOneClass α
inst✝² : MulOneClass β
inst✝¹ : MulOneClass γ
inst✝ : MulOneClass δ
f✝ g✝ f g : α →*o β
h : toOrderHom f = toOrderHom g
⊢ ∀ (a : α), ↑f a = ↑g a
Theorem: SimpleGraph.Walk.darts_bypass_subset
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: simp!
state_before: case nil
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
inst✝ : DecidableEq V
u v u✝ : V
⊢ darts (bypass nil) ⊆ darts nil

tactic: simp! only
state_before: case cons
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
inst✝ : DecidableEq V
u v u✝ v✝ w✝ : V
h✝ : Adj G u✝ v✝
p✝ : Walk G v✝ w✝
ih : darts (bypass p✝) ⊆ darts p✝
⊢ darts (bypass (cons h✝ p✝)) ⊆ darts (cons h✝ p✝)

tactic: split_ifs
state_before: case cons
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
inst✝ : DecidableEq V
u v u✝ v✝ w✝ : V
h✝ : Adj G u✝ v✝
p✝ : Walk G v✝ w✝
ih : darts (bypass p✝) ⊆ darts p✝
⊢ darts (if hs : u✝ ∈ support (bypass p✝) then dropUntil (bypass p✝) u✝ hs else cons h✝ (bypass p✝)) ⊆
    { toProd := (u✝, v✝), is_adj := h✝ } :: darts p✝

tactic: apply List.Subset.trans (darts_dropUntil_subset _ _)
state_before: case cons.inl
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
inst✝ : DecidableEq V
u v u✝ v✝ w✝ : V
h✝¹ : Adj G u✝ v✝
p✝ : Walk G v✝ w✝
ih : darts (bypass p✝) ⊆ darts p✝
h✝ : u✝ ∈ support (bypass p✝)
⊢ darts (dropUntil (bypass p✝) u✝ h✝) ⊆ { toProd := (u✝, v✝), is_adj := h✝¹ } :: darts p✝

tactic: apply List.subset_cons_of_subset _ ih
state_before: case cons.inl
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
inst✝ : DecidableEq V
u v u✝ v✝ w✝ : V
h✝¹ : Adj G u✝ v✝
p✝ : Walk G v✝ w✝
ih : darts (bypass p✝) ⊆ darts p✝
h✝ : u✝ ∈ support (bypass p✝)
⊢ darts (bypass p✝) ⊆ { toProd := (u✝, v✝), is_adj := h✝¹ } :: darts p✝

tactic: rw [darts_cons]
state_before: case cons.inr
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
inst✝ : DecidableEq V
u v u✝ v✝ w✝ : V
h✝¹ : Adj G u✝ v✝
p✝ : Walk G v✝ w✝
ih : darts (bypass p✝) ⊆ darts p✝
h✝ : ¬u✝ ∈ support (bypass p✝)
⊢ darts (cons h✝¹ (bypass p✝)) ⊆ { toProd := (u✝, v✝), is_adj := h✝¹ } :: darts p✝

tactic: exact List.cons_subset_cons _ ih
state_before: case cons.inr
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
inst✝ : DecidableEq V
u v u✝ v✝ w✝ : V
h✝¹ : Adj G u✝ v✝
p✝ : Walk G v✝ w✝
ih : darts (bypass p✝) ⊆ darts p✝
h✝ : ¬u✝ ∈ support (bypass p✝)
⊢ { toProd := (u✝, v✝), is_adj := h✝¹ } :: darts (bypass p✝) ⊆ { toProd := (u✝, v✝), is_adj := h✝¹ } :: darts p✝
Theorem: Array.foldrM_push
File: Std/Data/Array/Init/Lemmas.lean

tactic: simp [foldrM_eq_reverse_foldlM_data, -size_push]
state_before: m : Type u_1 → Type u_2
α : Type u_3
β : Type u_1
inst✝ : Monad m
f : α → β → m β
init : β
arr : Array α
a : α
⊢ foldrM f init (push arr a) (size (push arr a)) = do
    let init ← f a init
    foldrM f init arr (size arr)
Theorem: BilinForm.mul_toMatrix'_mul
File: Mathlib/LinearAlgebra/Matrix/BilinearForm.lean

tactic: simp only [B.toMatrix'_comp, transpose_transpose, toMatrix'_toLin']
state_before: R : Type ?u.740707
M✝ : Type ?u.740710
inst✝¹⁸ : Semiring R
inst✝¹⁷ : AddCommMonoid M✝
inst✝¹⁶ : Module R M✝
R₁ : Type ?u.740746
M₁ : Type ?u.740749
inst✝¹⁵ : Ring R₁
inst✝¹⁴ : AddCommGroup M₁
inst✝¹³ : Module R₁ M₁
R₂ : Type u_1
M₂ : Type ?u.741361
inst✝¹² : CommSemiring R₂
inst✝¹¹ : AddCommMonoid M₂
inst✝¹⁰ : Module R₂ M₂
R₃ : Type ?u.741548
M₃ : Type ?u.741551
inst✝⁹ : CommRing R₃
inst✝⁸ : AddCommGroup M₃
inst✝⁷ : Module R₃ M₃
V : Type ?u.742139
K : Type ?u.742142
inst✝⁶ : Field K
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module K V
B✝ : BilinForm R M✝
B₁ : BilinForm R₁ M₁
B₂ : BilinForm R₂ M₂
n : Type u_2
o : Type u_3
inst✝³ : Fintype n
inst✝² : Fintype o
inst✝¹ : DecidableEq n
inst✝ : DecidableEq o
B : BilinForm R₂ (n → R₂)
M : Matrix o n R₂
N : Matrix n o R₂
⊢ M ⬝ ↑toMatrix' B ⬝ N = ↑toMatrix' (comp B (↑Matrix.toLin' Mᵀ) (↑Matrix.toLin' N))
Theorem: Ordinal.type_preimage_aux
File: Mathlib/SetTheory/Ordinal/Basic.lean

tactic: convert (RelIso.preimage f r).ordinal_type_eq
state_before: α✝ : Type ?u.30166
β✝ : Type ?u.30169
γ : Type ?u.30172
r✝ : α✝ → α✝ → Prop
s : β✝ → β✝ → Prop
t : γ → γ → Prop
α β : Type u
r : α → α → Prop
inst✝ : IsWellOrder α r
f : β ≃ α
⊢ (type fun x y => r (↑f x) (↑f y)) = type r
Theorem: BilinForm.mul_toMatrix
File: Mathlib/LinearAlgebra/Matrix/BilinearForm.lean

tactic: rw [B.toMatrix_compLeft b, toMatrix_toLin, transpose_transpose]
state_before: R : Type ?u.1715810
M✝ : Type ?u.1715813
inst✝²⁰ : Semiring R
inst✝¹⁹ : AddCommMonoid M✝
inst✝¹⁸ : Module R M✝
R₁ : Type ?u.1715849
M₁ : Type ?u.1715852
inst✝¹⁷ : Ring R₁
inst✝¹⁶ : AddCommGroup M₁
inst✝¹⁵ : Module R₁ M₁
R₂ : Type u_1
M₂ : Type u_2
inst✝¹⁴ : CommSemiring R₂
inst✝¹³ : AddCommMonoid M₂
inst✝¹² : Module R₂ M₂
R₃ : Type ?u.1716651
M₃ : Type ?u.1716654
inst✝¹¹ : CommRing R₃
inst✝¹⁰ : AddCommGroup M₃
inst✝⁹ : Module R₃ M₃
V : Type ?u.1717242
K : Type ?u.1717245
inst✝⁸ : Field K
inst✝⁷ : AddCommGroup V
inst✝⁶ : Module K V
B✝ : BilinForm R M✝
B₁ : BilinForm R₁ M₁
B₂ : BilinForm R₂ M₂
n : Type u_3
o : Type ?u.1718462
inst✝⁵ : Fintype n
inst✝⁴ : Fintype o
inst✝³ : DecidableEq n
b : Basis n R₂ M₂
M₂' : Type ?u.1718621
inst✝² : AddCommMonoid M₂'
inst✝¹ : Module R₂ M₂'
c : Basis o R₂ M₂'
inst✝ : DecidableEq o
B : BilinForm R₂ M₂
M : Matrix n n R₂
⊢ M ⬝ ↑(toMatrix b) B = ↑(toMatrix b) (compLeft B (↑(Matrix.toLin b b) Mᵀ))
Theorem: Cardinal.mk_eq_nat_iff
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: rw [← lift_mk_fin, ← lift_uzero (#α), lift_mk_eq']
state_before: α✝ β α : Type u
n : ℕ
⊢ (#α) = ↑n ↔ Nonempty (α ≃ Fin n)
Theorem: tendsto_inv_nhdsWithin_Ici
File: Mathlib/Topology/Algebra/Group/Basic.lean

tactic: simp [tendsto_principal_principal]
state_before: α : Type u
β : Type v
G : Type w
H : Type x
inst✝⁶ : TopologicalSpace G
inst✝⁵ : Group G
inst✝⁴ : TopologicalGroup G
inst✝³ : TopologicalSpace α
f : α → G
s : Set α
x : α
inst✝² : TopologicalSpace H
inst✝¹ : OrderedCommGroup H
inst✝ : ContinuousInv H
a : H
⊢ Tendsto (fun a => a⁻¹) (𝓟 (Ici a)) (𝓟 (Iic a⁻¹))
Theorem: DihedralGroup.orderOf_sr
File: Mathlib/GroupTheory/SpecificGroups/Dihedral.lean

tactic: apply orderOf_eq_prime
state_before: n : ℕ
i : ZMod n
⊢ orderOf (sr i) = 2

tactic: rw [sq, sr_mul_self]
state_before: case hg
n : ℕ
i : ZMod n
⊢ sr i ^ 2 = 1

tactic: revert n
state_before: case hg1
n : ℕ
i : ZMod n
⊢ sr i ≠ 1

tactic: simp_rw [one_def, ne_eq, forall_const]
state_before: case hg1

⊢ ∀ {n : ℕ} (i : ZMod n), sr i ≠ 1
Theorem: Complex.hasDerivAt_exp
File: Mathlib/Analysis/SpecialFunctions/ExpDeriv.lean

tactic: rw [hasDerivAt_iff_isLittleO_nhds_zero]
state_before: 𝕜 : Type ?u.55
inst✝¹ : NontriviallyNormedField 𝕜
inst✝ : NormedAlgebra 𝕜 ℂ
x : ℂ
⊢ HasDerivAt exp (exp x) x

tactic: have : (1 : ℕ) < 2 := by norm_num
state_before: 𝕜 : Type ?u.55
inst✝¹ : NontriviallyNormedField 𝕜
inst✝ : NormedAlgebra 𝕜 ℂ
x : ℂ
⊢ (fun h => exp (x + h) - exp x - h • exp x) =o[𝓝 0] fun h => h

tactic: refine' (IsBigO.of_bound ‖exp x‖ _).trans_isLittleO (isLittleO_pow_id this)
state_before: 𝕜 : Type ?u.55
inst✝¹ : NontriviallyNormedField 𝕜
inst✝ : NormedAlgebra 𝕜 ℂ
x : ℂ
this : 1 < 2
⊢ (fun h => exp (x + h) - exp x - h • exp x) =o[𝓝 0] fun h => h

tactic: filter_upwards [Metric.ball_mem_nhds (0 : ℂ) zero_lt_one]
state_before: 𝕜 : Type ?u.55
inst✝¹ : NontriviallyNormedField 𝕜
inst✝ : NormedAlgebra 𝕜 ℂ
x : ℂ
this : 1 < 2
⊢ ∀ᶠ (x_1 : ℂ) in 𝓝 0, ‖exp (x + x_1) - exp x - x_1 • exp x‖ ≤ ‖exp x‖ * ‖x_1 ^ 2‖

tactic: simp only [Metric.mem_ball, dist_zero_right, norm_pow]
state_before: case h
𝕜 : Type ?u.55
inst✝¹ : NontriviallyNormedField 𝕜
inst✝ : NormedAlgebra 𝕜 ℂ
x : ℂ
this : 1 < 2
⊢ ∀ (a : ℂ), a ∈ Metric.ball 0 1 → ‖exp (x + a) - exp x - a • exp x‖ ≤ ‖exp x‖ * ‖a ^ 2‖

tactic: exact fun z hz => exp_bound_sq x z hz.le
state_before: case h
𝕜 : Type ?u.55
inst✝¹ : NontriviallyNormedField 𝕜
inst✝ : NormedAlgebra 𝕜 ℂ
x : ℂ
this : 1 < 2
⊢ ∀ (a : ℂ), ‖a‖ < 1 → ‖exp (x + a) - exp x - a • exp x‖ ≤ ‖exp x‖ * ‖a‖ ^ 2

tactic: norm_num
state_before: 𝕜 : Type ?u.55
inst✝¹ : NontriviallyNormedField 𝕜
inst✝ : NormedAlgebra 𝕜 ℂ
x : ℂ
⊢ 1 < 2
Theorem: summable_sigma_of_nonneg
File: Mathlib/Topology/Instances/ENNReal.lean

tactic: lift f to (Σx, β x) → ℝ≥0 using hf
state_before: α : Type u_2
β✝ : Type ?u.346013
γ : Type ?u.346016
β : α → Type u_1
f : (x : α) × β x → ℝ
hf : ∀ (x : (x : α) × β x), 0 ≤ f x
⊢ Summable f ↔
    (∀ (x : α), Summable fun y => f { fst := x, snd := y }) ∧ Summable fun x => ∑' (y : β x), f { fst := x, snd := y }

tactic: exact_mod_cast NNReal.summable_sigma
state_before: case intro
α : Type u_2
β✝ : Type ?u.346013
γ : Type ?u.346016
β : α → Type u_1
f : (x : α) × β x → ℝ≥0
⊢ (Summable fun i => ↑(f i)) ↔
    (∀ (x : α), Summable fun y => (fun i => ↑(f i)) { fst := x, snd := y }) ∧
      Summable fun x => ∑' (y : β x), (fun i => ↑(f i)) { fst := x, snd := y }
Theorem: AffineSubspace.sOppSide_vadd_right_iff
File: Mathlib/Analysis/Convex/Side.lean

tactic: rw [sOppSide_comm, sOppSide_vadd_left_iff hv, sOppSide_comm]
state_before: R : Type u_1
V : Type u_2
V' : Type ?u.156301
P : Type u_3
P' : Type ?u.156307
inst✝⁶ : StrictOrderedCommRing R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
s : AffineSubspace R P
x y : P
v : V
hv : v ∈ direction s
⊢ SOppSide s x (v +ᵥ y) ↔ SOppSide s x y
Theorem: PrimeMultiset.prod_dvd_iff
File: Mathlib/Data/PNat/Factors.lean

tactic: let h := @PNat.factorMultiset_le_iff' u.prod v
state_before: u v : PrimeMultiset
⊢ prod u ∣ prod v ↔ u ≤ v

tactic: rw [u.factorMultiset_prod] at h
state_before: u v : PrimeMultiset
h : PNat.factorMultiset (prod u) ≤ v ↔ prod u ∣ prod v := PNat.factorMultiset_le_iff'
⊢ prod u ∣ prod v ↔ u ≤ v

tactic: exact h.symm
state_before: u v : PrimeMultiset
h : u ≤ v ↔ prod u ∣ prod v
⊢ prod u ∣ prod v ↔ u ≤ v
Theorem: List.maximum_cons
File: Mathlib/Data/List/MinMax.lean

tactic: simp [@max_eq_left (WithBot α) _ _ _ bot_le]
state_before: α : Type u_1
β : Type ?u.101376
inst✝ : LinearOrder α
l✝ : List α
a✝ m a : α
l : List α
⊢ maximum [a] = max (↑a) (maximum [])

tactic: rw [← cons_append, maximum_concat, ih, maximum_concat, max_assoc]
state_before: α : Type u_1
β : Type ?u.101376
inst✝ : LinearOrder α
l✝ : List α
a✝ m a : α
l tl : List α
hd : α
ih : maximum (a :: tl) = max (↑a) (maximum tl)
⊢ maximum (a :: (tl ++ [hd])) = max (↑a) (maximum (tl ++ [hd]))
Theorem: Polynomial.support_trinomial
File: Mathlib/Data/Polynomial/Coeff.lean

tactic: apply subset_antisymm (support_trinomial' k m n x y z)
state_before: R : Type u
S : Type v
a b : R
n✝ m✝ : ℕ
inst✝ : Semiring R
p q r : R[X]
k m n : ℕ
hkm : k < m
hmn : m < n
x y z : R
hx : x ≠ 0
hy : y ≠ 0
hz : z ≠ 0
⊢ support (↑C x * X ^ k + ↑C y * X ^ m + ↑C z * X ^ n) = {k, m, n}

tactic: simp_rw [insert_subset, singleton_subset_iff, mem_support_iff, coeff_add, coeff_C_mul,
  coeff_X_pow_self, mul_one, coeff_X_pow, if_neg hkm.ne, if_neg hkm.ne', if_neg hmn.ne,
  if_neg hmn.ne', if_neg (hkm.trans hmn).ne, if_neg (hkm.trans hmn).ne', mul_zero, add_zero,
  zero_add, Ne.def, hx, hy, hz]
state_before: R : Type u
S : Type v
a b : R
n✝ m✝ : ℕ
inst✝ : Semiring R
p q r : R[X]
k m n : ℕ
hkm : k < m
hmn : m < n
x y z : R
hx : x ≠ 0
hy : y ≠ 0
hz : z ≠ 0
⊢ {k, m, n} ⊆ support (↑C x * X ^ k + ↑C y * X ^ m + ↑C z * X ^ n)
Theorem: Polynomial.leadingCoeff_map
File: Mathlib/Data/Polynomial/FieldDivision.lean

tactic: simp only [← coeff_natDegree, coeff_map f, natDegree_map]
state_before: R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝¹ : Field R
p q : R[X]
inst✝ : DivisionRing k
f : R →+* k
⊢ leadingCoeff (map f p) = ↑f (leadingCoeff p)
Theorem: Dfinsupp.inner_sum
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

tactic: simp (config := { contextual := true }) only [Dfinsupp.sum, _root_.inner_sum, smul_eq_mul]
state_before: 𝕜 : Type u_3
E : Type u_4
F : Type ?u.1509183
inst✝⁶ : IsROrC 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : InnerProductSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : InnerProductSpace ℝ F
dec_E : DecidableEq E
ι : Type u_1
dec : DecidableEq ι
α : ι → Type u_2
inst✝¹ : (i : ι) → AddZeroClass (α i)
inst✝ : (i : ι) → (x : α i) → Decidable (x ≠ 0)
f : (i : ι) → α i → E
l : Π₀ (i : ι), α i
x : E
⊢ inner x (sum l f) = sum l fun i a => inner x (f i a)
Theorem: UniqueFactorizationMonoid.exists_mem_normalizedFactors_of_dvd
File: Mathlib/RingTheory/UniqueFactorizationDomain.lean

tactic: simp_all
state_before: α : Type u_1
inst✝³ : CancelCommMonoidWithZero α
inst✝² : DecidableEq α
inst✝¹ : NormalizationMonoid α
inst✝ : UniqueFactorizationMonoid α
a p : α
ha0 : a ≠ 0
hp : Irreducible p
x✝ : p ∣ a
b : α
hb : a = p * b
hb0 : b = 0
⊢ False

tactic: rw [Multiset.prod_cons]
state_before: α : Type u_1
inst✝³ : CancelCommMonoidWithZero α
inst✝² : DecidableEq α
inst✝¹ : NormalizationMonoid α
inst✝ : UniqueFactorizationMonoid α
a p : α
ha0 : a ≠ 0
hp : Irreducible p
x✝ : p ∣ a
b : α
hb : a = p * b
hb0 : b ≠ 0
⊢ p * b ~ᵤ Multiset.prod (p ::ₘ normalizedFactors b)

tactic: exact (normalizedFactors_prod hb0).symm.mul_left _
state_before: α : Type u_1
inst✝³ : CancelCommMonoidWithZero α
inst✝² : DecidableEq α
inst✝¹ : NormalizationMonoid α
inst✝ : UniqueFactorizationMonoid α
a p : α
ha0 : a ≠ 0
hp : Irreducible p
x✝ : p ∣ a
b : α
hb : a = p * b
hb0 : b ≠ 0
⊢ p * b ~ᵤ p * Multiset.prod (normalizedFactors b)

tactic: simp
state_before: α : Type u_1
inst✝³ : CancelCommMonoidWithZero α
inst✝² : DecidableEq α
inst✝¹ : NormalizationMonoid α
inst✝ : UniqueFactorizationMonoid α
a p : α
ha0 : a ≠ 0
hp : Irreducible p
x✝ : p ∣ a
b : α
hb : a = p * b
hb0 : b ≠ 0
this : Multiset.Rel Associated (p ::ₘ normalizedFactors b) (normalizedFactors a)
⊢ p ∈ p ::ₘ normalizedFactors b
Theorem: Int.neg_emod_two
File: Mathlib/Data/Int/Order/Basic.lean

tactic: apply Int.emod_eq_emod_iff_emod_sub_eq_zero.mpr
state_before: a b : ℤ
n : ℕ
i : ℤ
⊢ -i % 2 = i % 2

tactic: convert Int.mul_emod_right 2 (-i) using 2
state_before: a b : ℤ
n : ℕ
i : ℤ
⊢ (-i - i) % 2 = 0

tactic: rw [two_mul, sub_eq_add_neg]
state_before: case h.e'_2.h.e'_5
a b : ℤ
n : ℕ
i : ℤ
⊢ -i - i = 2 * -i
Theorem: midpoint_add_self
File: Mathlib/LinearAlgebra/AffineSpace/Midpoint.lean

tactic: rw [midpoint_comm]
state_before: R : Type u_2
V : Type u_1
V' : Type ?u.112580
P : Type ?u.112583
P' : Type ?u.112586
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 : P
x y : V
⊢ midpoint R x y +ᵥ midpoint R x y = midpoint R x y +ᵥ midpoint R y x

tactic: rw [midpoint_vadd_midpoint, vadd_eq_add, vadd_eq_add, add_comm, midpoint_self]
state_before: R : Type u_2
V : Type u_1
V' : Type ?u.112580
P : Type ?u.112583
P' : Type ?u.112586
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 : P
x y : V
⊢ midpoint R x y +ᵥ midpoint R y x = x + y
Theorem: Polynomial.hasseDeriv_X
File: Mathlib/Data/Polynomial/HasseDeriv.lean

tactic: rw [← monomial_one_one_eq_X, hasseDeriv_monomial, Nat.choose_eq_zero_of_lt hk, Nat.cast_zero,
  MulZeroClass.zero_mul, monomial_zero_right]
state_before: R : Type u_1
inst✝ : Semiring R
k : ℕ
f : R[X]
hk : 1 < k
⊢ ↑(hasseDeriv k) X = 0
Theorem: Units.mul_right_eq_zero
File: Mathlib/Algebra/GroupWithZero/Units/Basic.lean

tactic: simpa using mul_eq_zero_of_right (↑u⁻¹) h
state_before: α : Type ?u.1597
M₀ : Type u_1
G₀ : Type ?u.1603
M₀' : Type ?u.1606
G₀' : Type ?u.1609
F : Type ?u.1612
F' : Type ?u.1615
inst✝ : MonoidWithZero M₀
u : M₀ˣ
a : M₀
h : ↑u * a = 0
⊢ a = 0
Theorem: Set.mem_list_prod
File: Mathlib/Data/Set/Pointwise/ListOfFn.lean

tactic: induction' l using List.ofFnRec with n f
state_before: F : Type ?u.8458
α : Type u_1
β : Type ?u.8464
γ : Type ?u.8467
inst✝ : Monoid α
s t : Set α
a✝ : α
m n : ℕ
l : List (Set α)
a : α
⊢ a ∈ List.prod l ↔ ∃ l', List.prod (List.map (fun x => ↑x.snd) l') = a ∧ List.map Sigma.fst l' = l

tactic: simp only [mem_prod_list_ofFn, List.exists_iff_exists_tuple, List.map_ofFn, Function.comp,
  List.ofFn_inj', Sigma.mk.inj_iff, and_left_comm, exists_and_left, exists_eq_left, heq_eq_eq]
state_before: case h
F : Type ?u.8458
α : Type u_1
β : Type ?u.8464
γ : Type ?u.8467
inst✝ : Monoid α
s t : Set α
a✝ : α
m n✝ : ℕ
a : α
n : ℕ
f : Fin n → Set α
⊢ a ∈ List.prod (List.ofFn f) ↔
    ∃ l', List.prod (List.map (fun x => ↑x.snd) l') = a ∧ List.map Sigma.fst l' = List.ofFn f

tactic: constructor
state_before: case h
F : Type ?u.8458
α : Type u_1
β : Type ?u.8464
γ : Type ?u.8467
inst✝ : Monoid α
s t : Set α
a✝ : α
m n✝ : ℕ
a : α
n : ℕ
f : Fin n → Set α
⊢ (∃ f_1, List.prod (List.ofFn fun i => ↑(f_1 i)) = a) ↔
    ∃ x, List.prod (List.ofFn fun x_1 => ↑(x x_1).snd) = a ∧ (fun x_1 => (x x_1).fst) = f

tactic: rintro ⟨fi, rfl⟩
state_before: case h.mp
F : Type ?u.8458
α : Type u_1
β : Type ?u.8464
γ : Type ?u.8467
inst✝ : Monoid α
s t : Set α
a✝ : α
m n✝ : ℕ
a : α
n : ℕ
f : Fin n → Set α
⊢ (∃ f_1, List.prod (List.ofFn fun i => ↑(f_1 i)) = a) →
    ∃ x, List.prod (List.ofFn fun x_1 => ↑(x x_1).snd) = a ∧ (fun x_1 => (x x_1).fst) = f

tactic: exact ⟨fun i ↦ ⟨_, fi i⟩, rfl, rfl⟩
state_before: case h.mp.intro
F : Type ?u.8458
α : Type u_1
β : Type ?u.8464
γ : Type ?u.8467
inst✝ : Monoid α
s t : Set α
a : α
m n✝ n : ℕ
f : Fin n → Set α
fi : (i : Fin n) → ↑(f i)
⊢ ∃ x,
    List.prod (List.ofFn fun x_1 => ↑(x x_1).snd) = List.prod (List.ofFn fun i => ↑(fi i)) ∧
      (fun x_1 => (x x_1).fst) = f

tactic: rintro ⟨fi, rfl, rfl⟩
state_before: case h.mpr
F : Type ?u.8458
α : Type u_1
β : Type ?u.8464
γ : Type ?u.8467
inst✝ : Monoid α
s t : Set α
a✝ : α
m n✝ : ℕ
a : α
n : ℕ
f : Fin n → Set α
⊢ (∃ x, List.prod (List.ofFn fun x_1 => ↑(x x_1).snd) = a ∧ (fun x_1 => (x x_1).fst) = f) →
    ∃ f_1, List.prod (List.ofFn fun i => ↑(f_1 i)) = a

tactic: exact ⟨fun i ↦ _, rfl⟩
state_before: case h.mpr.intro.intro
F : Type ?u.8458
α : Type u_1
β : Type ?u.8464
γ : Type ?u.8467
inst✝ : Monoid α
s t : Set α
a : α
m n✝ n : ℕ
fi : Fin n → (s : Set α) × ↑s
⊢ ∃ f, List.prod (List.ofFn fun i => ↑(f i)) = List.prod (List.ofFn fun x => ↑(fi x).snd)
Theorem: Polynomial.content_X_pow
File: Mathlib/RingTheory/Polynomial/Content.lean

tactic: induction' k with k hi
state_before: R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
k : ℕ
⊢ content (X ^ k) = 1

tactic: rw [pow_succ, content_X_mul, hi]
state_before: case succ
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
k : ℕ
hi : content (X ^ k) = 1
⊢ content (X ^ Nat.succ k) = 1

tactic: simp
state_before: case zero
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
⊢ content (X ^ Nat.zero) = 1