tasksource/leandojo huggingface dataset:
Theorem: Combinatorics.Line.prod_apply
File: Mathlib/Combinatorics/HalesJewett.lean

tactic: funext i
state_before: α : Type u_1
ι : Type u_2
ι' : Type u_3
l : Line α ι
l' : Line α ι'
x : α
⊢ (fun x i => Option.getD (idxFun (prod l l') i) x) x =
    Sum.elim ((fun x i => Option.getD (idxFun l i) x) x) ((fun x i => Option.getD (idxFun l' i) x) x)

tactic: cases i <;> rfl
state_before: case h
α : Type u_1
ι : Type u_2
ι' : Type u_3
l : Line α ι
l' : Line α ι'
x : α
i : ι ⊕ ι'
⊢ (fun x i => Option.getD (idxFun (prod l l') i) x) x i =
    Sum.elim ((fun x i => Option.getD (idxFun l i) x) x) ((fun x i => Option.getD (idxFun l' i) x) x) i
Theorem: SimpleGraph.Walk.support_rotate
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: simp only [rotate, tail_support_append]
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
inst✝ : DecidableEq V
u v : V
c : Walk G v v
h : u ∈ support c
⊢ List.tail (support (rotate c h)) ~r List.tail (support c)

tactic: apply List.IsRotated.trans List.isRotated_append
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
inst✝ : DecidableEq V
u v : V
c : Walk G v v
h : u ∈ support c
⊢ (List.tail (support (dropUntil c u h)) ++ List.tail (support (takeUntil c u h))) ~r List.tail (support c)

tactic: rw [← tail_support_append, take_spec]
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
inst✝ : DecidableEq V
u v : V
c : Walk G v v
h : u ∈ support c
⊢ (List.tail (support (takeUntil c u h)) ++ List.tail (support (dropUntil c u h))) ~r List.tail (support c)
Theorem: IsPreirreducible.preimage
File: Mathlib/Topology/SubsetProperties.lean

tactic: rintro U V hU hV ⟨x, hx, hx'⟩ ⟨y, hy, hy'⟩
state_before: α : Type u
β : Type v
ι : Type ?u.209716
π : ι → Type ?u.209721
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
s t Z : Set α
hZ : IsPreirreducible Z
f : β → α
hf : OpenEmbedding f
⊢ IsPreirreducible (f ⁻¹' Z)

tactic: obtain ⟨_, h₁, ⟨z, h₂, rfl⟩, ⟨z', h₃, h₄⟩⟩ :=
  hZ _ _ (hf.isOpenMap _ hU) (hf.isOpenMap _ hV) ⟨f x, hx, Set.mem_image_of_mem f hx'⟩
    ⟨f y, hy, Set.mem_image_of_mem f hy'⟩
state_before: case intro.intro.intro.intro
α : Type u
β : Type v
ι : Type ?u.209716
π : ι → Type ?u.209721
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
s t Z : Set α
hZ : IsPreirreducible Z
f : β → α
hf : OpenEmbedding f
U V : Set β
hU : IsOpen U
hV : IsOpen V
x : β
hx : x ∈ f ⁻¹' Z
hx' : x ∈ U
y : β
hy : y ∈ f ⁻¹' Z
hy' : y ∈ V
⊢ Set.Nonempty (f ⁻¹' Z ∩ (U ∩ V))

tactic: cases hf.inj h₄
state_before: case intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro
α : Type u
β : Type v
ι : Type ?u.209716
π : ι → Type ?u.209721
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
s t Z : Set α
hZ : IsPreirreducible Z
f : β → α
hf : OpenEmbedding f
U V : Set β
hU : IsOpen U
hV : IsOpen V
x : β
hx : x ∈ f ⁻¹' Z
hx' : x ∈ U
y : β
hy : y ∈ f ⁻¹' Z
hy' : y ∈ V
z : β
h₂ : z ∈ U
h₁ : f z ∈ Z
z' : β
h₃ : z' ∈ V
h₄ : f z' = f z
⊢ Set.Nonempty (f ⁻¹' Z ∩ (U ∩ V))

tactic: exact ⟨z, h₁, h₂, h₃⟩
state_before: case intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.refl
α : Type u
β : Type v
ι : Type ?u.209716
π : ι → Type ?u.209721
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
s t Z : Set α
hZ : IsPreirreducible Z
f : β → α
hf : OpenEmbedding f
U V : Set β
hU : IsOpen U
hV : IsOpen V
x : β
hx : x ∈ f ⁻¹' Z
hx' : x ∈ U
y : β
hy : y ∈ f ⁻¹' Z
hy' : y ∈ V
z : β
h₂ : z ∈ U
h₁ : f z ∈ Z
h₃ : z ∈ V
h₄ : f z = f z
⊢ Set.Nonempty (f ⁻¹' Z ∩ (U ∩ V))
Theorem: dist_self_mul_left
File: Mathlib/Analysis/Normed/Group/Basic.lean

tactic: rw [dist_comm, dist_self_mul_right]
state_before: 𝓕 : Type ?u.639132
𝕜 : Type ?u.639135
α : Type ?u.639138
ι : Type ?u.639141
κ : Type ?u.639144
E : Type u_1
F : Type ?u.639150
G : Type ?u.639153
inst✝¹ : SeminormedCommGroup E
inst✝ : SeminormedCommGroup F
a✝ a₁ a₂ b✝ b₁ b₂ : E
r r₁ r₂ : ℝ
a b : E
⊢ dist (a * b) a = ‖b‖
Theorem: MeasureTheory.SimpleFunc.setToSimpleFunc_const
File: Mathlib/MeasureTheory/Integral/SetToL1.lean

tactic: cases hα : isEmpty_or_nonempty α
state_before: α : Type u_1
E : Type ?u.459354
F : Type u_2
F' : Type u_3
G : Type ?u.459363
𝕜 : Type ?u.459366
p : ℝ≥0∞
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
inst✝² : NormedAddCommGroup F'
inst✝¹ : NormedSpace ℝ F'
inst✝ : NormedAddCommGroup G
m✝ : MeasurableSpace α
μ : Measure α
T : Set α → F →L[ℝ] F'
hT_empty : T ∅ = 0
x : F
m : MeasurableSpace α
⊢ setToSimpleFunc T (const α x) = ↑(T Set.univ) x

tactic: have h_univ_empty : (univ : Set α) = ∅ := Subsingleton.elim _ _
state_before: case inl
α : Type u_1
E : Type ?u.459354
F : Type u_2
F' : Type u_3
G : Type ?u.459363
𝕜 : Type ?u.459366
p : ℝ≥0∞
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
inst✝² : NormedAddCommGroup F'
inst✝¹ : NormedSpace ℝ F'
inst✝ : NormedAddCommGroup G
m✝ : MeasurableSpace α
μ : Measure α
T : Set α → F →L[ℝ] F'
hT_empty : T ∅ = 0
x : F
m : MeasurableSpace α
h✝ : IsEmpty α
hα : (_ : IsEmpty α ∨ Nonempty α) = (_ : IsEmpty α ∨ Nonempty α)
⊢ setToSimpleFunc T (const α x) = ↑(T Set.univ) x

tactic: rw [h_univ_empty, hT_empty]
state_before: case inl
α : Type u_1
E : Type ?u.459354
F : Type u_2
F' : Type u_3
G : Type ?u.459363
𝕜 : Type ?u.459366
p : ℝ≥0∞
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
inst✝² : NormedAddCommGroup F'
inst✝¹ : NormedSpace ℝ F'
inst✝ : NormedAddCommGroup G
m✝ : MeasurableSpace α
μ : Measure α
T : Set α → F →L[ℝ] F'
hT_empty : T ∅ = 0
x : F
m : MeasurableSpace α
h✝ : IsEmpty α
hα : (_ : IsEmpty α ∨ Nonempty α) = (_ : IsEmpty α ∨ Nonempty α)
h_univ_empty : Set.univ = ∅
⊢ setToSimpleFunc T (const α x) = ↑(T Set.univ) x

tactic: simp only [setToSimpleFunc, ContinuousLinearMap.zero_apply, sum_empty,
  range_eq_empty_of_isEmpty]
state_before: case inl
α : Type u_1
E : Type ?u.459354
F : Type u_2
F' : Type u_3
G : Type ?u.459363
𝕜 : Type ?u.459366
p : ℝ≥0∞
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
inst✝² : NormedAddCommGroup F'
inst✝¹ : NormedSpace ℝ F'
inst✝ : NormedAddCommGroup G
m✝ : MeasurableSpace α
μ : Measure α
T : Set α → F →L[ℝ] F'
hT_empty : T ∅ = 0
x : F
m : MeasurableSpace α
h✝ : IsEmpty α
hα : (_ : IsEmpty α ∨ Nonempty α) = (_ : IsEmpty α ∨ Nonempty α)
h_univ_empty : Set.univ = ∅
⊢ setToSimpleFunc T (const α x) = ↑0 x

tactic: exact setToSimpleFunc_const' T x
state_before: case inr
α : Type u_1
E : Type ?u.459354
F : Type u_2
F' : Type u_3
G : Type ?u.459363
𝕜 : Type ?u.459366
p : ℝ≥0∞
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
inst✝² : NormedAddCommGroup F'
inst✝¹ : NormedSpace ℝ F'
inst✝ : NormedAddCommGroup G
m✝ : MeasurableSpace α
μ : Measure α
T : Set α → F →L[ℝ] F'
hT_empty : T ∅ = 0
x : F
m : MeasurableSpace α
h✝ : Nonempty α
hα : (_ : IsEmpty α ∨ Nonempty α) = (_ : IsEmpty α ∨ Nonempty α)
⊢ setToSimpleFunc T (const α x) = ↑(T Set.univ) x
Theorem: CompositionSeries.Equivalent.symm
File: Mathlib/Order/JordanHolder.lean

tactic: simpa using h.choose_spec (h.choose.symm i)
state_before: X : Type u
inst✝¹ : Lattice X
inst✝ : JordanHolderLattice X
s₁ s₂ : CompositionSeries X
h : Equivalent s₁ s₂
i : Fin s₂.length
⊢ Iso (series s₁ (↑Fin.castSucc (↑(Exists.choose h).symm i)), series s₁ (Fin.succ (↑(Exists.choose h).symm i)))
    (series s₂ (↑Fin.castSucc i), series s₂ (Fin.succ i))
Theorem: lineMap_strict_mono_endpoints
File: Mathlib/LinearAlgebra/AffineSpace/Ordered.lean

tactic: rcases h₀.eq_or_lt with (rfl | h₀)
state_before: k : Type u_2
E : Type u_1
PE : Type ?u.32974
inst✝³ : OrderedRing k
inst✝² : OrderedAddCommGroup E
inst✝¹ : Module k E
inst✝ : OrderedSMul k E
a a' b b' : E
r r' : k
ha : a < a'
hb : b < b'
h₀ : 0 ≤ r
h₁ : r ≤ 1
⊢ ↑(lineMap a b) r < ↑(lineMap a' b') r

tactic: exact (lineMap_mono_left ha.le h₁).trans_lt (lineMap_strict_mono_right hb h₀)
state_before: case inr
k : Type u_2
E : Type u_1
PE : Type ?u.32974
inst✝³ : OrderedRing k
inst✝² : OrderedAddCommGroup E
inst✝¹ : Module k E
inst✝ : OrderedSMul k E
a a' b b' : E
r r' : k
ha : a < a'
hb : b < b'
h₀✝ : 0 ≤ r
h₁ : r ≤ 1
h₀ : 0 < r
⊢ ↑(lineMap a b) r < ↑(lineMap a' b') r

tactic: simpa
state_before: case inl
k : Type u_2
E : Type u_1
PE : Type ?u.32974
inst✝³ : OrderedRing k
inst✝² : OrderedAddCommGroup E
inst✝¹ : Module k E
inst✝ : OrderedSMul k E
a a' b b' : E
r' : k
ha : a < a'
hb : b < b'
h₀ : 0 ≤ 0
h₁ : 0 ≤ 1
⊢ ↑(lineMap a b) 0 < ↑(lineMap a' b') 0
Theorem: dvd_geom_sum₂_iff_of_dvd_sub'
File: Mathlib/NumberTheory/Multiplicity.lean

tactic: rw [geom_sum₂_comm, dvd_geom_sum₂_iff_of_dvd_sub]
state_before: R : Type u_1
n : ℕ
inst✝ : CommRing R
a b x✝ y✝ x y p : R
h : p ∣ x - y
⊢ p ∣ ∑ i in range n, x ^ i * y ^ (n - 1 - i) ↔ p ∣ ↑n * x ^ (n - 1)

tactic: simpa using h.neg_right
state_before: R : Type u_1
n : ℕ
inst✝ : CommRing R
a b x✝ y✝ x y p : R
h : p ∣ x - y
⊢ p ∣ y - x
Theorem: Mathlib.Tactic.Ring.add_pf_add_lt
File: Mathlib/Tactic/Ring/Basic.lean

tactic: simp [*, add_assoc]
state_before: u : Lean.Level
R : Type u_1
α : Q(Type u)
sα : Q(CommSemiring «$α»)
inst✝ : CommSemiring R
a₂ b c a₁ : R
x✝ : a₂ + b = c
⊢ a₁ + a₂ + b = a₁ + c
Theorem: Cardinal.prod_ne_zero
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: simp [prod_eq_zero]
state_before: α β : Type u
ι : Type u_1
f : ι → Cardinal
⊢ prod f ≠ 0 ↔ ∀ (i : ι), f i ≠ 0
Theorem: Polynomial.funext
File: Mathlib/Data/Polynomial/RingDivision.lean

tactic: rw [← sub_eq_zero]
state_before: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝² : CommRing R
inst✝¹ : IsDomain R
p✝ q✝ : R[X]
inst✝ : Infinite R
p q : R[X]
ext : ∀ (r : R), eval r p = eval r q
⊢ p = q

tactic: apply zero_of_eval_zero
state_before: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝² : CommRing R
inst✝¹ : IsDomain R
p✝ q✝ : R[X]
inst✝ : Infinite R
p q : R[X]
ext : ∀ (r : R), eval r p = eval r q
⊢ p - q = 0

tactic: intro x
state_before: case h
R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝² : CommRing R
inst✝¹ : IsDomain R
p✝ q✝ : R[X]
inst✝ : Infinite R
p q : R[X]
ext : ∀ (r : R), eval r p = eval r q
⊢ ∀ (x : R), eval x (p - q) = 0

tactic: rw [eval_sub, sub_eq_zero, ext]
state_before: case h
R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝² : CommRing R
inst✝¹ : IsDomain R
p✝ q✝ : R[X]
inst✝ : Infinite R
p q : R[X]
ext : ∀ (r : R), eval r p = eval r q
x : R
⊢ eval x (p - q) = 0
Theorem: List.take_eq_nil_iff
File: Mathlib/Data/List/Basic.lean

tactic: cases l <;> cases k <;> simp [Nat.succ_ne_zero]
state_before: ι : Type ?u.177112
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ l : List α
k : ℕ
⊢ take k l = [] ↔ l = [] ∨ k = 0
Theorem: MonoidHom.map_isConj
File: Mathlib/Algebra/Group/Conj.lean

tactic: rw [Units.coe_map, SemiconjBy, ← f.map_mul, hc.eq, f.map_mul]
state_before: α : Type u
β : Type v
inst✝¹ : Monoid α
inst✝ : Monoid β
f : α →* β
a b : α
c : αˣ
hc : SemiconjBy (↑c) a b
⊢ SemiconjBy (↑(↑(Units.map f) c)) (↑f a) (↑f b)
Theorem: LipschitzWith.list_prod
File: Mathlib/Topology/MetricSpace/Lipschitz.lean

tactic: simpa using LipschitzWith.id
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝² : PseudoEMetricSpace α
inst✝¹ : PseudoEMetricSpace β
inst✝ : PseudoEMetricSpace γ
K✝ : ℝ≥0
f✝ : α → β
x y : α
r : ℝ≥0∞
f : ι → Function.End α
K : ι → ℝ≥0
h : ∀ (i : ι), LipschitzWith (K i) (f i)
⊢ LipschitzWith (List.prod (List.map K [])) (List.prod (List.map f []))

tactic: simp only [List.map_cons, List.prod_cons]
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝² : PseudoEMetricSpace α
inst✝¹ : PseudoEMetricSpace β
inst✝ : PseudoEMetricSpace γ
K✝ : ℝ≥0
f✝ : α → β
x y : α
r : ℝ≥0∞
f : ι → Function.End α
K : ι → ℝ≥0
h : ∀ (i : ι), LipschitzWith (K i) (f i)
i : ι
l : List ι
⊢ LipschitzWith (List.prod (List.map K (i :: l))) (List.prod (List.map f (i :: l)))

tactic: exact (h i).mul (LipschitzWith.list_prod f K h l)
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝² : PseudoEMetricSpace α
inst✝¹ : PseudoEMetricSpace β
inst✝ : PseudoEMetricSpace γ
K✝ : ℝ≥0
f✝ : α → β
x y : α
r : ℝ≥0∞
f : ι → Function.End α
K : ι → ℝ≥0
h : ∀ (i : ι), LipschitzWith (K i) (f i)
i : ι
l : List ι
⊢ LipschitzWith (K i * List.prod (List.map K l)) (f i * List.prod (List.map f l))
Theorem: MeasureTheory.AEEqFun.toGerm_eq
File: Mathlib/MeasureTheory/Function/AEEqFun.lean

tactic: rw [← mk_toGerm, mk_coeFn]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.443277
δ : Type ?u.443280
inst✝³ : MeasurableSpace α
μ ν : Measure α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : α →ₘ[μ] β
⊢ toGerm f = ↑↑f
Theorem: intervalIntegral.integral_add
File: Mathlib/MeasureTheory/Integral/IntervalIntegral.lean

tactic: simp only [intervalIntegral_eq_integral_uIoc, integral_add hf.def hg.def, smul_add]
state_before: ι : Type ?u.12526056
𝕜 : Type ?u.12526059
E : Type u_1
F : Type ?u.12526065
A : Type ?u.12526068
inst✝² : NormedAddCommGroup E
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
a b : ℝ
f g : ℝ → E
μ : MeasureTheory.Measure ℝ
hf : IntervalIntegrable f μ a b
hg : IntervalIntegrable g μ a b
⊢ (∫ (x : ℝ) in a..b, f x + g x ∂μ) = (∫ (x : ℝ) in a..b, f x ∂μ) + ∫ (x : ℝ) in a..b, g x ∂μ
Theorem: Ordinal.nfpBFamily_lt_ord
File: Mathlib/SetTheory/Cardinal/Cofinality.lean

tactic: rwa [o.card.lift_id]
state_before: α : Type ?u.35030
r : α → α → Prop
o : Ordinal
f : (a : Ordinal) → a < o → Ordinal → Ordinal
c : Ordinal
hc : ℵ₀ < cof c
hc' : card o < cof c
hf : ∀ (i : Ordinal) (hi : i < o) (b : Ordinal), b < c → f i hi b < c
a : Ordinal
⊢ Cardinal.lift (card o) < cof c
Theorem: HasFDerivAt.isBigO
File: Mathlib/Analysis/Calculus/FDeriv/Basic.lean

tactic: simpa only [sub_add_cancel] using h.isBigO.add (isBigO_sub f' (𝓝 x₀) x₀)
state_before: 𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type ?u.387793
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.387888
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f✝ f₀ f₁ g : E → F
f'✝ f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
f : E → F
x₀ : E
f' : E →L[𝕜] F
h : HasFDerivAt f f' x₀
⊢ (fun x => f x - f x₀) =O[𝓝 x₀] fun x => x - x₀
Theorem: Ideal.minimalPrimes_eq_subsingleton_self
File: Mathlib/RingTheory/Ideal/MinimalPrime.lean

tactic: ext J
state_before: R : Type u_1
S : Type ?u.122062
inst✝² : CommRing R
inst✝¹ : CommRing S
I J : Ideal R
inst✝ : IsPrime I
⊢ Ideal.minimalPrimes I = {I}

tactic: constructor
state_before: case h
R : Type u_1
S : Type ?u.122062
inst✝² : CommRing R
inst✝¹ : CommRing S
I J✝ : Ideal R
inst✝ : IsPrime I
J : Ideal R
⊢ J ∈ Ideal.minimalPrimes I ↔ J ∈ {I}

tactic: exact fun H => (H.2 ⟨inferInstance, rfl.le⟩ H.1.2).antisymm H.1.2
state_before: case h.mp
R : Type u_1
S : Type ?u.122062
inst✝² : CommRing R
inst✝¹ : CommRing S
I J✝ : Ideal R
inst✝ : IsPrime I
J : Ideal R
⊢ J ∈ Ideal.minimalPrimes I → J ∈ {I}

tactic: rintro (rfl : J = I)
state_before: case h.mpr
R : Type u_1
S : Type ?u.122062
inst✝² : CommRing R
inst✝¹ : CommRing S
I J✝ : Ideal R
inst✝ : IsPrime I
J : Ideal R
⊢ J ∈ {I} → J ∈ Ideal.minimalPrimes I

tactic: refine' ⟨⟨inferInstance, rfl.le⟩, fun _ h _ => h.2⟩
state_before: case h.mpr
R : Type u_1
S : Type ?u.122062
inst✝² : CommRing R
inst✝¹ : CommRing S
J✝ J : Ideal R
inst✝ : IsPrime J
⊢ J ∈ Ideal.minimalPrimes J
Theorem: mul_lt_mul_of_neg_left
File: Mathlib/Algebra/Order/Ring/Defs.lean

tactic: simpa only [neg_mul, neg_lt_neg_iff] using mul_lt_mul_of_pos_left h (neg_pos_of_neg hc)
state_before: α : Type u
β : Type ?u.82636
inst✝ : StrictOrderedRing α
a b c : α
h : b < a
hc : c < 0
⊢ c * a < c * b
Theorem: IsAlgClosed.roots_eq_zero_iff
File: Mathlib/FieldTheory/IsAlgClosed/Basic.lean

tactic: refine' ⟨fun h => _, fun hp => by rw [hp, roots_C]⟩
state_before: k : Type u
inst✝¹ : Field k
inst✝ : IsAlgClosed k
p : k[X]
⊢ roots p = 0 ↔ p = ↑C (coeff p 0)

tactic: cases' le_or_lt (degree p) 0 with hd hd
state_before: k : Type u
inst✝¹ : Field k
inst✝ : IsAlgClosed k
p : k[X]
h : roots p = 0
⊢ p = ↑C (coeff p 0)

tactic: rw [hp, roots_C]
state_before: k : Type u
inst✝¹ : Field k
inst✝ : IsAlgClosed k
p : k[X]
hp : p = ↑C (coeff p 0)
⊢ roots p = 0

tactic: exact eq_C_of_degree_le_zero hd
state_before: case inl
k : Type u
inst✝¹ : Field k
inst✝ : IsAlgClosed k
p : k[X]
h : roots p = 0
hd : degree p ≤ 0
⊢ p = ↑C (coeff p 0)

tactic: obtain ⟨z, hz⟩ := IsAlgClosed.exists_root p hd.ne'
state_before: case inr
k : Type u
inst✝¹ : Field k
inst✝ : IsAlgClosed k
p : k[X]
h : roots p = 0
hd : 0 < degree p
⊢ p = ↑C (coeff p 0)

tactic: rw [← mem_roots (ne_zero_of_degree_gt hd), h] at hz
state_before: case inr.intro
k : Type u
inst✝¹ : Field k
inst✝ : IsAlgClosed k
p : k[X]
h : roots p = 0
hd : 0 < degree p
z : k
hz : IsRoot p z
⊢ p = ↑C (coeff p 0)

tactic: simp at hz
state_before: case inr.intro
k : Type u
inst✝¹ : Field k
inst✝ : IsAlgClosed k
p : k[X]
h : roots p = 0
hd : 0 < degree p
z : k
hz : z ∈ 0
⊢ p = ↑C (coeff p 0)
Theorem: LinearMap.curry_uncurryLeft
File: Mathlib/LinearAlgebra/Multilinear/Basic.lean

tactic: ext (m x)
state_before: R : Type u
ι : Type u'
n : ℕ
M : Fin (Nat.succ n) → Type v
M₁ : ι → Type v₁
M₂ : Type v₂
M₃ : Type v₃
M' : Type v'
inst✝⁶ : CommSemiring R
inst✝⁵ : (i : Fin (Nat.succ n)) → AddCommMonoid (M i)
inst✝⁴ : AddCommMonoid M'
inst✝³ : AddCommMonoid M₂
inst✝² : (i : Fin (Nat.succ n)) → Module R (M i)
inst✝¹ : Module R M'
inst✝ : Module R M₂
f : M 0 →ₗ[R] MultilinearMap R (fun i => M (succ i)) M₂
⊢ curryLeft (uncurryLeft f) = f

tactic: simp only [tail_cons, LinearMap.uncurryLeft_apply, MultilinearMap.curryLeft_apply]
state_before: case h.H
R : Type u
ι : Type u'
n : ℕ
M : Fin (Nat.succ n) → Type v
M₁ : ι → Type v₁
M₂ : Type v₂
M₃ : Type v₃
M' : Type v'
inst✝⁶ : CommSemiring R
inst✝⁵ : (i : Fin (Nat.succ n)) → AddCommMonoid (M i)
inst✝⁴ : AddCommMonoid M'
inst✝³ : AddCommMonoid M₂
inst✝² : (i : Fin (Nat.succ n)) → Module R (M i)
inst✝¹ : Module R M'
inst✝ : Module R M₂
f : M 0 →ₗ[R] MultilinearMap R (fun i => M (succ i)) M₂
m : M 0
x : (i : Fin n) → M (succ i)
⊢ ↑(↑(curryLeft (uncurryLeft f)) m) x = ↑(↑f m) x

tactic: rw [cons_zero]
state_before: case h.H
R : Type u
ι : Type u'
n : ℕ
M : Fin (Nat.succ n) → Type v
M₁ : ι → Type v₁
M₂ : Type v₂
M₃ : Type v₃
M' : Type v'
inst✝⁶ : CommSemiring R
inst✝⁵ : (i : Fin (Nat.succ n)) → AddCommMonoid (M i)
inst✝⁴ : AddCommMonoid M'
inst✝³ : AddCommMonoid M₂
inst✝² : (i : Fin (Nat.succ n)) → Module R (M i)
inst✝¹ : Module R M'
inst✝ : Module R M₂
f : M 0 →ₗ[R] MultilinearMap R (fun i => M (succ i)) M₂
m : M 0
x : (i : Fin n) → M (succ i)
⊢ ↑(↑f (cons m x 0)) x = ↑(↑f m) x
Theorem: le_of_forall_one_lt_div_le
File: Mathlib/Algebra/Order/Group/DenselyOrdered.lean

tactic: simpa only [div_eq_mul_inv, inv_inv] using h ε⁻¹ (Left.one_lt_inv_iff.2 ε1)
state_before: α : Type u_1
inst✝³ : Group α
inst✝² : LinearOrder α
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
inst✝ : DenselyOrdered α
a b c : α
h : ∀ (ε : α), 1 < ε → a / ε ≤ b
ε : α
ε1 : ε < 1
⊢ a * ε ≤ b
Theorem: List.perm_comp_perm
File: Mathlib/Data/List/Perm.lean

tactic: funext a c
state_before: α : Type uu
β : Type vv
l₁ l₂ : List α
γ : Type ?u.37152
δ : Type ?u.37155
r : α → β → Prop
p : γ → δ → Prop
⊢ Perm ∘r Perm = Perm

tactic: apply propext
state_before: case h.h
α : Type uu
β : Type vv
l₁ l₂ : List α
γ : Type ?u.37152
δ : Type ?u.37155
r : α → β → Prop
p : γ → δ → Prop
a c : List α
⊢ (Perm ∘r Perm) a c = (a ~ c)

tactic: constructor
state_before: case h.h.a
α : Type uu
β : Type vv
l₁ l₂ : List α
γ : Type ?u.37152
δ : Type ?u.37155
r : α → β → Prop
p : γ → δ → Prop
a c : List α
⊢ (Perm ∘r Perm) a c ↔ a ~ c

tactic: exact fun ⟨b, hab, hba⟩ => Perm.trans hab hba
state_before: case h.h.a.mp
α : Type uu
β : Type vv
l₁ l₂ : List α
γ : Type ?u.37152
δ : Type ?u.37155
r : α → β → Prop
p : γ → δ → Prop
a c : List α
⊢ (Perm ∘r Perm) a c → a ~ c

tactic: exact fun h => ⟨a, Perm.refl a, h⟩
state_before: case h.h.a.mpr
α : Type uu
β : Type vv
l₁ l₂ : List α
γ : Type ?u.37152
δ : Type ?u.37155
r : α → β → Prop
p : γ → δ → Prop
a c : List α
⊢ a ~ c → (Perm ∘r Perm) a c
Theorem: nsmul_eq_mul
File: Mathlib/Algebra/GroupPower/Lemmas.lean

tactic: rw [nsmul_eq_mul', (n.cast_commute a).eq]
state_before: α : Type ?u.256535
M : Type u
N : Type v
G : Type w
H : Type x
A : Type y
B : Type z
R : Type u₁
S : Type u₂
inst✝ : NonAssocSemiring R
n : ℕ
a : R
⊢ n • a = ↑n * a
Theorem: InnerProductGeometry.norm_sub_eq_abs_sub_norm_iff_angle_eq_zero
File: Mathlib/Geometry/Euclidean/Angle/Unoriented/Basic.lean

tactic: refine' ⟨fun h => _, norm_sub_eq_abs_sub_norm_of_angle_eq_zero⟩
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x✝ y✝ x y : V
hx : x ≠ 0
hy : y ≠ 0
⊢ ‖x - y‖ = abs (‖x‖ - ‖y‖) ↔ angle x y = 0

tactic: rw [← inner_eq_mul_norm_iff_angle_eq_zero hx hy]
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x✝ y✝ x y : V
hx : x ≠ 0
hy : y ≠ 0
h : ‖x - y‖ = abs (‖x‖ - ‖y‖)
⊢ angle x y = 0

tactic: have h1 : ‖x - y‖ ^ 2 = (‖x‖ - ‖y‖) ^ 2 := by
  rw [h]
  exact sq_abs (‖x‖ - ‖y‖)
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x✝ y✝ x y : V
hx : x ≠ 0
hy : y ≠ 0
h : ‖x - y‖ = abs (‖x‖ - ‖y‖)
⊢ inner x y = ‖x‖ * ‖y‖

tactic: rw [norm_sub_pow_two_real] at h1
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x✝ y✝ x y : V
hx : x ≠ 0
hy : y ≠ 0
h : ‖x - y‖ = abs (‖x‖ - ‖y‖)
h1 : ‖x - y‖ ^ 2 = (‖x‖ - ‖y‖) ^ 2
⊢ inner x y = ‖x‖ * ‖y‖

tactic: calc
  ⟪x, y⟫ = ((‖x‖ + ‖y‖) ^ 2 - ‖x‖ ^ 2 - ‖y‖ ^ 2) / 2 := by linarith
  _ = ‖x‖ * ‖y‖ := by ring
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x✝ y✝ x y : V
hx : x ≠ 0
hy : y ≠ 0
h : ‖x - y‖ = abs (‖x‖ - ‖y‖)
h1✝ : ‖x - y‖ ^ 2 = (‖x‖ - ‖y‖) ^ 2
h1 : ‖x‖ ^ 2 - 2 * inner x y + ‖y‖ ^ 2 = (‖x‖ - ‖y‖) ^ 2
⊢ inner x y = ‖x‖ * ‖y‖

tactic: rw [h]
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x✝ y✝ x y : V
hx : x ≠ 0
hy : y ≠ 0
h : ‖x - y‖ = abs (‖x‖ - ‖y‖)
⊢ ‖x - y‖ ^ 2 = (‖x‖ - ‖y‖) ^ 2

tactic: exact sq_abs (‖x‖ - ‖y‖)
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x✝ y✝ x y : V
hx : x ≠ 0
hy : y ≠ 0
h : ‖x - y‖ = abs (‖x‖ - ‖y‖)
⊢ abs (‖x‖ - ‖y‖) ^ 2 = (‖x‖ - ‖y‖) ^ 2

tactic: linarith
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x✝ y✝ x y : V
hx : x ≠ 0
hy : y ≠ 0
h : ‖x - y‖ = abs (‖x‖ - ‖y‖)
h1✝ : ‖x - y‖ ^ 2 = (‖x‖ - ‖y‖) ^ 2
h1 : ‖x‖ ^ 2 - 2 * inner x y + ‖y‖ ^ 2 = (‖x‖ - ‖y‖) ^ 2
⊢ inner x y = ((‖x‖ + ‖y‖) ^ 2 - ‖x‖ ^ 2 - ‖y‖ ^ 2) / 2

tactic: ring
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x✝ y✝ x y : V
hx : x ≠ 0
hy : y ≠ 0
h : ‖x - y‖ = abs (‖x‖ - ‖y‖)
h1✝ : ‖x - y‖ ^ 2 = (‖x‖ - ‖y‖) ^ 2
h1 : ‖x‖ ^ 2 - 2 * inner x y + ‖y‖ ^ 2 = (‖x‖ - ‖y‖) ^ 2
⊢ ((‖x‖ + ‖y‖) ^ 2 - ‖x‖ ^ 2 - ‖y‖ ^ 2) / 2 = ‖x‖ * ‖y‖