tasksource/leandojo huggingface dataset:
Theorem: Commute.geom_sum₂_Ico
File: Mathlib/Algebra/GeomSum.lean

tactic: have : x - y ≠ 0 := by simp_all [sub_eq_iff_eq_add]
state_before: α : Type u
inst✝ : DivisionRing α
x y : α
h : Commute x y
hxy : x ≠ y
m n : ℕ
hmn : m ≤ n
⊢ ∑ i in Ico m n, x ^ i * y ^ (n - 1 - i) = (x ^ n - y ^ (n - m) * x ^ m) / (x - y)

tactic: rw [← h.geom_sum₂_Ico_mul hmn, mul_div_cancel _ this]
state_before: α : Type u
inst✝ : DivisionRing α
x y : α
h : Commute x y
hxy : x ≠ y
m n : ℕ
hmn : m ≤ n
this : x - y ≠ 0
⊢ ∑ i in Ico m n, x ^ i * y ^ (n - 1 - i) = (x ^ n - y ^ (n - m) * x ^ m) / (x - y)

tactic: simp_all [sub_eq_iff_eq_add]
state_before: α : Type u
inst✝ : DivisionRing α
x y : α
h : Commute x y
hxy : x ≠ y
m n : ℕ
hmn : m ≤ n
⊢ x - y ≠ 0
Theorem: FirstOrder.Language.Term.realize_quotient_mk'
File: Mathlib/ModelTheory/Quotients.lean

tactic: induction' t with _ _ _ _ ih
state_before: L : Language
M : Type u_4
s : Setoid M
ps : Prestructure L s
β : Type u_1
t : Term L β
x : β → M
⊢ realize (fun i => Quotient.mk s (x i)) t = Quotient.mk s (realize x t)

tactic: rfl
state_before: case var
L : Language
M : Type u_4
s : Setoid M
ps : Prestructure L s
β : Type u_1
x : β → M
_a✝ : β
⊢ realize (fun i => Quotient.mk s (x i)) (var _a✝) = Quotient.mk s (realize x (var _a✝))

tactic: simp only [ih, funMap_quotient_mk', Term.realize]
state_before: case func
L : Language
M : Type u_4
s : Setoid M
ps : Prestructure L s
β : Type u_1
x : β → M
l✝ : ℕ
_f✝ : Functions L l✝
_ts✝ : Fin l✝ → Term L β
ih : ∀ (a : Fin l✝), realize (fun i => Quotient.mk s (x i)) (_ts✝ a) = Quotient.mk s (realize x (_ts✝ a))
⊢ realize (fun i => Quotient.mk s (x i)) (func _f✝ _ts✝) = Quotient.mk s (realize x (func _f✝ _ts✝))
Theorem: rank_pi
File: Mathlib/LinearAlgebra/Dimension.lean

tactic: cases nonempty_fintype η
state_before: K : Type u
V V₁ V₂ V₃ : Type v
V' V'₁ : Type v'
V'' : Type v''
ι : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type u_1
inst✝¹⁴ : Ring K
inst✝¹³ : StrongRankCondition K
inst✝¹² : AddCommGroup V
inst✝¹¹ : Module K V
inst✝¹⁰ : Module.Free K V
inst✝⁹ : AddCommGroup V'
inst✝⁸ : Module K V'
inst✝⁷ : Module.Free K V'
inst✝⁶ : AddCommGroup V₁
inst✝⁵ : Module K V₁
inst✝⁴ : Module.Free K V₁
inst✝³ : (i : η) → AddCommGroup (φ i)
inst✝² : (i : η) → Module K (φ i)
inst✝¹ : ∀ (i : η), Module.Free K (φ i)
inst✝ : Finite η
⊢ Module.rank K ((i : η) → φ i) = sum fun i => Module.rank K (φ i)

tactic: let B i := chooseBasis K (φ i)
state_before: case intro
K : Type u
V V₁ V₂ V₃ : Type v
V' V'₁ : Type v'
V'' : Type v''
ι : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type u_1
inst✝¹⁴ : Ring K
inst✝¹³ : StrongRankCondition K
inst✝¹² : AddCommGroup V
inst✝¹¹ : Module K V
inst✝¹⁰ : Module.Free K V
inst✝⁹ : AddCommGroup V'
inst✝⁸ : Module K V'
inst✝⁷ : Module.Free K V'
inst✝⁶ : AddCommGroup V₁
inst✝⁵ : Module K V₁
inst✝⁴ : Module.Free K V₁
inst✝³ : (i : η) → AddCommGroup (φ i)
inst✝² : (i : η) → Module K (φ i)
inst✝¹ : ∀ (i : η), Module.Free K (φ i)
inst✝ : Finite η
val✝ : Fintype η
⊢ Module.rank K ((i : η) → φ i) = sum fun i => Module.rank K (φ i)

tactic: let b : Basis _ K (∀ i, φ i) := Pi.basis fun i => B i
state_before: case intro
K : Type u
V V₁ V₂ V₃ : Type v
V' V'₁ : Type v'
V'' : Type v''
ι : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type u_1
inst✝¹⁴ : Ring K
inst✝¹³ : StrongRankCondition K
inst✝¹² : AddCommGroup V
inst✝¹¹ : Module K V
inst✝¹⁰ : Module.Free K V
inst✝⁹ : AddCommGroup V'
inst✝⁸ : Module K V'
inst✝⁷ : Module.Free K V'
inst✝⁶ : AddCommGroup V₁
inst✝⁵ : Module K V₁
inst✝⁴ : Module.Free K V₁
inst✝³ : (i : η) → AddCommGroup (φ i)
inst✝² : (i : η) → Module K (φ i)
inst✝¹ : ∀ (i : η), Module.Free K (φ i)
inst✝ : Finite η
val✝ : Fintype η
B : (i : η) → Basis (ChooseBasisIndex K (φ i)) K (φ i) := fun i => chooseBasis K (φ i)
⊢ Module.rank K ((i : η) → φ i) = sum fun i => Module.rank K (φ i)

tactic: simp [← b.mk_eq_rank'', fun i => (B i).mk_eq_rank'']
state_before: case intro
K : Type u
V V₁ V₂ V₃ : Type v
V' V'₁ : Type v'
V'' : Type v''
ι : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type u_1
inst✝¹⁴ : Ring K
inst✝¹³ : StrongRankCondition K
inst✝¹² : AddCommGroup V
inst✝¹¹ : Module K V
inst✝¹⁰ : Module.Free K V
inst✝⁹ : AddCommGroup V'
inst✝⁸ : Module K V'
inst✝⁷ : Module.Free K V'
inst✝⁶ : AddCommGroup V₁
inst✝⁵ : Module K V₁
inst✝⁴ : Module.Free K V₁
inst✝³ : (i : η) → AddCommGroup (φ i)
inst✝² : (i : η) → Module K (φ i)
inst✝¹ : ∀ (i : η), Module.Free K (φ i)
inst✝ : Finite η
val✝ : Fintype η
B : (i : η) → Basis (ChooseBasisIndex K (φ i)) K (φ i) := fun i => chooseBasis K (φ i)
b : Basis ((j : η) × ChooseBasisIndex K (φ j)) K ((i : η) → φ i) := Pi.basis fun i => B i
⊢ Module.rank K ((i : η) → φ i) = sum fun i => Module.rank K (φ i)
Theorem: SimpleGraph.Subgraph.edgeSet_sSup
File: Mathlib/Combinatorics/SimpleGraph/Subgraph.lean

tactic: ext e
state_before: ι : Sort ?u.109989
V : Type u
W : Type v
G : SimpleGraph V
G₁ G₂ : Subgraph G
a b : V
s : Set (Subgraph G)
⊢ edgeSet (sSup s) = ⋃ (G' : Subgraph G) (_ : G' ∈ s), edgeSet G'

tactic: induction e using Sym2.ind
state_before: case h
ι : Sort ?u.109989
V : Type u
W : Type v
G : SimpleGraph V
G₁ G₂ : Subgraph G
a b : V
s : Set (Subgraph G)
e : Sym2 V
⊢ e ∈ edgeSet (sSup s) ↔ e ∈ ⋃ (G' : Subgraph G) (_ : G' ∈ s), edgeSet G'

tactic: simp
state_before: case h.h
ι : Sort ?u.109989
V : Type u
W : Type v
G : SimpleGraph V
G₁ G₂ : Subgraph G
a b : V
s : Set (Subgraph G)
x✝ y✝ : V
⊢ Quotient.mk (Sym2.Rel.setoid V) (x✝, y✝) ∈ edgeSet (sSup s) ↔
    Quotient.mk (Sym2.Rel.setoid V) (x✝, y✝) ∈ ⋃ (G' : Subgraph G) (_ : G' ∈ s), edgeSet G'
Theorem: Filter.prod_inf_prod
File: Mathlib/Order/Filter/Prod.lean

tactic: simp only [SProd.sprod, Filter.prod, comap_inf, inf_comm, inf_assoc, inf_left_comm]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.41525
δ : Type ?u.41528
ι : Sort ?u.41531
s : Set α
t : Set β
f : Filter α
g : Filter β
f₁ f₂ : Filter α
g₁ g₂ : Filter β
⊢ f₁ ×ˢ g₁ ⊓ f₂ ×ˢ g₂ = (f₁ ⊓ f₂) ×ˢ (g₁ ⊓ g₂)
Theorem: Seminorm.closedBall_add_closedBall_subset
File: Mathlib/Analysis/Seminorm.lean

tactic: rintro x ⟨y₁, y₂, hy₁, hy₂, rfl⟩
state_before: R : Type ?u.878378
R' : Type ?u.878381
𝕜 : Type u_1
𝕜₂ : Type ?u.878387
𝕜₃ : Type ?u.878390
𝕝 : Type ?u.878393
E : Type u_2
E₂ : Type ?u.878399
E₃ : Type ?u.878402
F : Type ?u.878405
G : Type ?u.878408
ι : Type ?u.878411
inst✝² : SeminormedRing 𝕜
inst✝¹ : AddCommGroup E
inst✝ : SMul 𝕜 E
p✝ : Seminorm 𝕜 E
x y : E
r : ℝ
p : Seminorm 𝕜 E
r₁ r₂ : ℝ
x₁ x₂ : E
⊢ closedBall p x₁ r₁ + closedBall p x₂ r₂ ⊆ closedBall p (x₁ + x₂) (r₁ + r₂)

tactic: rw [mem_closedBall, add_sub_add_comm]
state_before: case intro.intro.intro.intro
R : Type ?u.878378
R' : Type ?u.878381
𝕜 : Type u_1
𝕜₂ : Type ?u.878387
𝕜₃ : Type ?u.878390
𝕝 : Type ?u.878393
E : Type u_2
E₂ : Type ?u.878399
E₃ : Type ?u.878402
F : Type ?u.878405
G : Type ?u.878408
ι : Type ?u.878411
inst✝² : SeminormedRing 𝕜
inst✝¹ : AddCommGroup E
inst✝ : SMul 𝕜 E
p✝ : Seminorm 𝕜 E
x y : E
r : ℝ
p : Seminorm 𝕜 E
r₁ r₂ : ℝ
x₁ x₂ y₁ y₂ : E
hy₁ : y₁ ∈ closedBall p x₁ r₁
hy₂ : y₂ ∈ closedBall p x₂ r₂
⊢ (fun x x_1 => x + x_1) y₁ y₂ ∈ closedBall p (x₁ + x₂) (r₁ + r₂)

tactic: exact (map_add_le_add p _ _).trans (add_le_add hy₁ hy₂)
state_before: case intro.intro.intro.intro
R : Type ?u.878378
R' : Type ?u.878381
𝕜 : Type u_1
𝕜₂ : Type ?u.878387
𝕜₃ : Type ?u.878390
𝕝 : Type ?u.878393
E : Type u_2
E₂ : Type ?u.878399
E₃ : Type ?u.878402
F : Type ?u.878405
G : Type ?u.878408
ι : Type ?u.878411
inst✝² : SeminormedRing 𝕜
inst✝¹ : AddCommGroup E
inst✝ : SMul 𝕜 E
p✝ : Seminorm 𝕜 E
x y : E
r : ℝ
p : Seminorm 𝕜 E
r₁ r₂ : ℝ
x₁ x₂ y₁ y₂ : E
hy₁ : y₁ ∈ closedBall p x₁ r₁
hy₂ : y₂ ∈ closedBall p x₂ r₂
⊢ ↑p (y₁ - x₁ + (y₂ - x₂)) ≤ r₁ + r₂
Theorem: Complex.arg_cos_add_sin_mul_I_coe_angle
File: Mathlib/Analysis/SpecialFunctions/Complex/Arg.lean

tactic: rw [← one_mul (_ + _), ← ofReal_one, arg_mul_cos_add_sin_mul_I_coe_angle zero_lt_one]
state_before: θ : Angle
⊢ ↑(arg (↑(Angle.cos θ) + ↑(Angle.sin θ) * I)) = θ
Theorem: Finset.min'_insert
File: Mathlib/Data/Finset/Lattice.lean

tactic: rw [coe_insert, min_comm]
state_before: F : Type ?u.361063
α : Type u_1
β : Type ?u.361069
γ : Type ?u.361072
ι : Type ?u.361075
κ : Type ?u.361078
inst✝ : LinearOrder α
s✝ : Finset α
H✝ : Finset.Nonempty s✝
x a : α
s : Finset α
H : Finset.Nonempty s
⊢ IsLeast (↑(insert a s)) (min (min' s H) a)

tactic: exact (isLeast_min' _ _).insert _
state_before: F : Type ?u.361063
α : Type u_1
β : Type ?u.361069
γ : Type ?u.361072
ι : Type ?u.361075
κ : Type ?u.361078
inst✝ : LinearOrder α
s✝ : Finset α
H✝ : Finset.Nonempty s✝
x a : α
s : Finset α
H : Finset.Nonempty s
⊢ IsLeast (insert a ↑s) (min a (min' s H))
Theorem: List.append_eq_append_iff
File: Std/Data/List/Lemmas.lean

tactic: induction a generalizing c with
| nil => simp; exact (or_iff_left_of_imp fun ⟨_, ⟨e, rfl⟩, h⟩ => e ▸ h.symm).symm
| cons a as ih => cases c <;> simp [eq_comm, and_assoc, ih, and_or_left]
state_before: α : Type u_1
a b c d : List α
⊢ a ++ b = c ++ d ↔ (∃ a', c = a ++ a' ∧ b = a' ++ d) ∨ ∃ c', a = c ++ c' ∧ d = c' ++ b

tactic: simp
state_before: case nil
α : Type u_1
b d c : List α
⊢ [] ++ b = c ++ d ↔ (∃ a', c = [] ++ a' ∧ b = a' ++ d) ∨ ∃ c', [] = c ++ c' ∧ d = c' ++ b

tactic: exact (or_iff_left_of_imp fun ⟨_, ⟨e, rfl⟩, h⟩ => e ▸ h.symm).symm
state_before: case nil
α : Type u_1
b d c : List α
⊢ b = c ++ d ↔ b = c ++ d ∨ ∃ c', (c = [] ∧ c' = []) ∧ d = c' ++ b

tactic: cases c <;> simp [eq_comm, and_assoc, ih, and_or_left]
state_before: case cons
α : Type u_1
b d : List α
a : α
as : List α
ih : ∀ {c : List α}, as ++ b = c ++ d ↔ (∃ a', c = as ++ a' ∧ b = a' ++ d) ∨ ∃ c', as = c ++ c' ∧ d = c' ++ b
c : List α
⊢ a :: as ++ b = c ++ d ↔ (∃ a', c = a :: as ++ a' ∧ b = a' ++ d) ∨ ∃ c', a :: as = c ++ c' ∧ d = c' ++ b
Theorem: Orthonormal.linearIndependent
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

tactic: rw [linearIndependent_iff]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.2133622
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
dec_E : DecidableEq E
ι : Type u_3
dec_ι : DecidableEq ι
v : ι → E
hv : Orthonormal 𝕜 v
⊢ LinearIndependent 𝕜 v

tactic: intro l hl
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.2133622
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
dec_E : DecidableEq E
ι : Type u_3
dec_ι : DecidableEq ι
v : ι → E
hv : Orthonormal 𝕜 v
⊢ ∀ (l : ι →₀ 𝕜), ↑(Finsupp.total ι E 𝕜 v) l = 0 → l = 0

tactic: ext i
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.2133622
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
dec_E : DecidableEq E
ι : Type u_3
dec_ι : DecidableEq ι
v : ι → E
hv : Orthonormal 𝕜 v
l : ι →₀ 𝕜
hl : ↑(Finsupp.total ι E 𝕜 v) l = 0
⊢ l = 0

tactic: have key : ⟪v i, Finsupp.total ι E 𝕜 v l⟫ = ⟪v i, 0⟫ := by rw [hl]
state_before: case h
𝕜 : Type u_1
E : Type u_2
F : Type ?u.2133622
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
dec_E : DecidableEq E
ι : Type u_3
dec_ι : DecidableEq ι
v : ι → E
hv : Orthonormal 𝕜 v
l : ι →₀ 𝕜
hl : ↑(Finsupp.total ι E 𝕜 v) l = 0
i : ι
⊢ ↑l i = ↑0 i

tactic: simpa only [hv.inner_right_finsupp, inner_zero_right] using key
state_before: case h
𝕜 : Type u_1
E : Type u_2
F : Type ?u.2133622
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
dec_E : DecidableEq E
ι : Type u_3
dec_ι : DecidableEq ι
v : ι → E
hv : Orthonormal 𝕜 v
l : ι →₀ 𝕜
hl : ↑(Finsupp.total ι E 𝕜 v) l = 0
i : ι
key : inner (v i) (↑(Finsupp.total ι E 𝕜 v) l) = inner (v i) 0
⊢ ↑l i = ↑0 i

tactic: rw [hl]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.2133622
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
dec_E : DecidableEq E
ι : Type u_3
dec_ι : DecidableEq ι
v : ι → E
hv : Orthonormal 𝕜 v
l : ι →₀ 𝕜
hl : ↑(Finsupp.total ι E 𝕜 v) l = 0
i : ι
⊢ inner (v i) (↑(Finsupp.total ι E 𝕜 v) l) = inner (v i) 0
Theorem: MeasureTheory.Content.outerMeasure_pos_of_is_mul_left_invariant
File: Mathlib/MeasureTheory/Measure/Content.lean

tactic: convert μ.innerContent_pos_of_is_mul_left_invariant h3 K hK ⟨U, h1U⟩ h2U
state_before: G : Type w
inst✝³ : TopologicalSpace G
μ : Content G
inst✝² : T2Space G
inst✝¹ : Group G
inst✝ : TopologicalGroup G
h3 :
  ∀ (g : G) {K : Compacts G},
    (fun s => ↑(toFun μ s)) (Compacts.map (fun b => g * b) (_ : Continuous fun b => g * b) K) =
      (fun s => ↑(toFun μ s)) K
K : Compacts G
hK : (fun s => ↑(toFun μ s)) K ≠ 0
U : Set G
h1U : IsOpen U
h2U : Set.Nonempty U
⊢ 0 < ↑(Content.outerMeasure μ) U

tactic: exact μ.outerMeasure_opens ⟨U, h1U⟩
state_before: case h.e'_4
G : Type w
inst✝³ : TopologicalSpace G
μ : Content G
inst✝² : T2Space G
inst✝¹ : Group G
inst✝ : TopologicalGroup G
h3 :
  ∀ (g : G) {K : Compacts G},
    (fun s => ↑(toFun μ s)) (Compacts.map (fun b => g * b) (_ : Continuous fun b => g * b) K) =
      (fun s => ↑(toFun μ s)) K
K : Compacts G
hK : (fun s => ↑(toFun μ s)) K ≠ 0
U : Set G
h1U : IsOpen U
h2U : Set.Nonempty U
⊢ ↑(Content.outerMeasure μ) U = innerContent μ { carrier := U, is_open' := h1U }
Theorem: PNat.XgcdType.reduce_v
File: Mathlib/Data/PNat/Xgcd.lean

tactic: rw [reduce_a h, finish_v u h]
state_before: u✝ x✝ : XgcdType
u : XgcdType := x✝
h : r u = 0
⊢ v (reduce x✝) = v x✝

tactic: have : SizeOf.sizeOf u.step < SizeOf.sizeOf u := u.step_wf h
state_before: u✝ x✝ : XgcdType
u : XgcdType := x✝
h : ¬r u = 0
⊢ v (reduce x✝) = v x✝

tactic: rw [reduce_b h, flip_v, reduce_v (step u), step_v u h, Prod.swap_swap]
state_before: u✝ x✝ : XgcdType
u : XgcdType := x✝
h : ¬r u = 0
this : sizeOf (step u) < sizeOf u
⊢ v (reduce x✝) = v x✝
Theorem: CategoryTheory.OplaxNatTrans.whiskerLeft_naturality_id
File: Mathlib/CategoryTheory/Bicategory/NaturalTransformation.lean

tactic: simp_rw [← whiskerLeft_comp, naturality_id]
state_before: B : Type u₁
inst✝¹ : Bicategory B
C : Type u₂
inst✝ : Bicategory C
F G H : OplaxFunctor B C
η : OplaxNatTrans F G
θ : OplaxNatTrans G H
a b c : B
a' : C
f : a' ⟶ (↑G.toPrelaxFunctor).obj a
⊢ f ◁ naturality θ (𝟙 a) ≫ f ◁ app θ a ◁ OplaxFunctor.mapId H a =
    f ◁ OplaxFunctor.mapId G a ▷ app θ a ≫ f ◁ (λ_ (app θ a)).hom ≫ f ◁ (ρ_ (app θ a)).inv
Theorem: exists_pos_right_iff_sameRay
File: Mathlib/LinearAlgebra/Ray.lean

tactic: rw [SameRay.sameRay_comm]
state_before: R : Type u_2
inst✝² : LinearOrderedField R
M : Type u_1
inst✝¹ : AddCommGroup M
inst✝ : Module R M
x y : M
hx : x ≠ 0
hy : y ≠ 0
⊢ (∃ r, 0 < r ∧ x = r • y) ↔ SameRay R x y

tactic: simp_rw [eq_comm (a := x)]
state_before: R : Type u_2
inst✝² : LinearOrderedField R
M : Type u_1
inst✝¹ : AddCommGroup M
inst✝ : Module R M
x y : M
hx : x ≠ 0
hy : y ≠ 0
⊢ (∃ r, 0 < r ∧ x = r • y) ↔ SameRay R y x

tactic: exact exists_pos_left_iff_sameRay hy hx
state_before: R : Type u_2
inst✝² : LinearOrderedField R
M : Type u_1
inst✝¹ : AddCommGroup M
inst✝ : Module R M
x y : M
hx : x ≠ 0
hy : y ≠ 0
⊢ (∃ r, 0 < r ∧ r • y = x) ↔ SameRay R y x
Theorem: SimpleGraph.IsClique.card_le_chromaticNumber
File: Mathlib/Combinatorics/SimpleGraph/Coloring.lean

tactic: cases nonempty_fintype V
state_before: V : Type u
G : SimpleGraph V
α : Type v
C : Coloring G α
inst✝ : Finite V
s : Finset V
h : IsClique G ↑s
⊢ Finset.card s ≤ chromaticNumber G

tactic: exact h.card_le_of_colorable G.colorable_chromaticNumber_of_fintype
state_before: case intro
V : Type u
G : SimpleGraph V
α : Type v
C : Coloring G α
inst✝ : Finite V
s : Finset V
h : IsClique G ↑s
val✝ : Fintype V
⊢ Finset.card s ≤ chromaticNumber G
Theorem: Finset.affineCombinationLineMapWeights_apply_right
File: Mathlib/LinearAlgebra/AffineSpace/Combination.lean

tactic: simp [affineCombinationLineMapWeights, h.symm]
state_before: k : Type u_2
V : Type ?u.438199
P : Type ?u.438202
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
S : AffineSpace V P
ι : Type u_1
s : Finset ι
ι₂ : Type ?u.438858
s₂ : Finset ι₂
inst✝ : DecidableEq ι
i j : ι
h : i ≠ j
c : k
⊢ affineCombinationLineMapWeights i j c j = c
Theorem: exists_zpow_eq_one
File: Mathlib/GroupTheory/OrderOfElement.lean

tactic: rcases exists_pow_eq_one x with ⟨w, hw1, hw2⟩
state_before: G : Type u
A : Type v
x✝ y : G
a b : A
n m : ℕ
inst✝² : Group G
inst✝¹ : AddGroup A
inst✝ : Finite G
x : G
⊢ ∃ i x_1, x ^ i = 1

tactic: refine' ⟨w, Int.coe_nat_ne_zero.mpr (_root_.ne_of_gt hw1), _⟩
state_before: case intro.intro
G : Type u
A : Type v
x✝ y : G
a b : A
n m : ℕ
inst✝² : Group G
inst✝¹ : AddGroup A
inst✝ : Finite G
x : G
w : ℕ
hw1 : w > 0
hw2 : IsPeriodicPt ((fun x x_1 => x * x_1) x) w 1
⊢ ∃ i x_1, x ^ i = 1

tactic: rw [zpow_ofNat]
state_before: case intro.intro
G : Type u
A : Type v
x✝ y : G
a b : A
n m : ℕ
inst✝² : Group G
inst✝¹ : AddGroup A
inst✝ : Finite G
x : G
w : ℕ
hw1 : w > 0
hw2 : IsPeriodicPt ((fun x x_1 => x * x_1) x) w 1
⊢ x ^ ↑w = 1

tactic: exact (isPeriodicPt_mul_iff_pow_eq_one _).mp hw2
state_before: case intro.intro
G : Type u
A : Type v
x✝ y : G
a b : A
n m : ℕ
inst✝² : Group G
inst✝¹ : AddGroup A
inst✝ : Finite G
x : G
w : ℕ
hw1 : w > 0
hw2 : IsPeriodicPt ((fun x x_1 => x * x_1) x) w 1
⊢ x ^ w = 1
Theorem: Polynomial.ofFinsupp_mul
File: Mathlib/Data/Polynomial/Basic.lean

tactic: rw [mul_def]
state_before: R : Type u
a✝ b✝ : R
m n : ℕ
inst✝ : Semiring R
p q : R[X]
a b : AddMonoidAlgebra R ℕ
⊢ { toFinsupp := a * b } = Polynomial.mul { toFinsupp := a } { toFinsupp := b }
Theorem: CharP.exists
File: Mathlib/Algebra/CharP/Basic.lean

tactic: rw [zero_dvd_iff]
state_before: R : Type u_1
inst✝ : NonAssocSemiring R
this : DecidableEq R := Classical.decEq R
H : ∀ (p : ℕ), ↑p = 0 → p = 0
x : ℕ
⊢ ↑x = 0 ↔ 0 ∣ x

tactic: exact ⟨H x, by rintro rfl; simp⟩
state_before: R : Type u_1
inst✝ : NonAssocSemiring R
this : DecidableEq R := Classical.decEq R
H : ∀ (p : ℕ), ↑p = 0 → p = 0
x : ℕ
⊢ ↑x = 0 ↔ x = 0

tactic: rintro rfl
state_before: R : Type u_1
inst✝ : NonAssocSemiring R
this : DecidableEq R := Classical.decEq R
H : ∀ (p : ℕ), ↑p = 0 → p = 0
x : ℕ
⊢ x = 0 → ↑x = 0

tactic: simp
state_before: R : Type u_1
inst✝ : NonAssocSemiring R
this : DecidableEq R := Classical.decEq R
H : ∀ (p : ℕ), ↑p = 0 → p = 0
⊢ ↑0 = 0

tactic: rwa [← Nat.mod_add_div x (Nat.find (not_forall.1 H)), Nat.cast_add,
  Nat.cast_mul,
  of_not_not (not_not_of_not_imp <| Nat.find_spec (not_forall.1 H)),
  MulZeroClass.zero_mul, add_zero] at H1
state_before: R : Type u_1
inst✝ : NonAssocSemiring R
this : DecidableEq R := Classical.decEq R
H : ¬∀ (p : ℕ), ↑p = 0 → p = 0
x : ℕ
H1 : ↑x = 0
H2 : ¬x % Nat.find (_ : ∃ x, ¬(↑x = 0 → x = 0)) = 0
⊢ ↑(x % Nat.find (_ : ∃ x, ¬(↑x = 0 → x = 0))) = 0

tactic: rw [← Nat.mul_div_cancel' H1, Nat.cast_mul,
  of_not_not (not_not_of_not_imp <| Nat.find_spec (not_forall.1 H)),
  MulZeroClass.zero_mul]
state_before: R : Type u_1
inst✝ : NonAssocSemiring R
this : DecidableEq R := Classical.decEq R
H : ¬∀ (p : ℕ), ↑p = 0 → p = 0
x : ℕ
H1 : Nat.find (_ : ∃ x, ¬(↑x = 0 → x = 0)) ∣ x
⊢ ↑x = 0
Theorem: MeasureTheory.set_lintegral_univ
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

tactic: rw [Measure.restrict_univ]
state_before: α : Type u_1
β : Type ?u.925545
γ : Type ?u.925548
δ : Type ?u.925551
m : MeasurableSpace α
μ ν : Measure α
f : α → ℝ≥0∞
⊢ (∫⁻ (x : α) in univ, f x ∂μ) = ∫⁻ (x : α), f x ∂μ
Theorem: Ideal.isMaximal_iff
File: Mathlib/RingTheory/Ideal/Basic.lean

tactic: rw [lt_iff_le_not_le]
state_before: α : Type u
β : Type v
inst✝ : Semiring α
I✝ : Ideal α
a b : α
I J : Ideal α
⊢ I < J → J = ⊤ ↔ ∀ (x : α), I ≤ J → ¬x ∈ I → x ∈ J → 1 ∈ J

tactic: exact
  ⟨fun H x h hx₁ hx₂ => J.eq_top_iff_one.1 <| H ⟨h, not_subset.2 ⟨_, hx₂, hx₁⟩⟩,
    fun H ⟨h₁, h₂⟩ =>
    let ⟨x, xJ, xI⟩ := not_subset.1 h₂
    J.eq_top_iff_one.2 <| H x h₁ xI xJ⟩
state_before: α : Type u
β : Type v
inst✝ : Semiring α
I✝ : Ideal α
a b : α
I J : Ideal α
⊢ I ≤ J ∧ ¬J ≤ I → J = ⊤ ↔ ∀ (x : α), I ≤ J → ¬x ∈ I → x ∈ J → 1 ∈ J
Theorem: Subfield.sInf_toSubring
File: Mathlib/FieldTheory/Subfield.lean

tactic: ext x
state_before: K : Type u
L : Type v
M : Type w
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Field M
s : Set (Subfield K)
⊢ (sInf s).toSubring = ⨅ (t : Subfield K) (_ : t ∈ s), t.toSubring

tactic: rw [mem_toSubring, mem_sInf]
state_before: case h
K : Type u
L : Type v
M : Type w
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Field M
s : Set (Subfield K)
x : K
⊢ x ∈ (sInf s).toSubring ↔ x ∈ ⨅ (t : Subfield K) (_ : t ∈ s), t.toSubring

tactic: erw [Subring.mem_sInf]
state_before: case h
K : Type u
L : Type v
M : Type w
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Field M
s : Set (Subfield K)
x : K
⊢ (∀ (p : Subfield K), p ∈ s → x ∈ p) ↔ x ∈ ⨅ (t : Subfield K) (_ : t ∈ s), t.toSubring

tactic: exact
  ⟨fun h p ⟨p', hp⟩ => hp ▸ Subring.mem_sInf.mpr fun p ⟨hp', hp⟩ => hp ▸ h _ hp', fun h p hp =>
    h p.toSubring
      ⟨p,
        Subring.ext fun x =>
          ⟨fun hx => Subring.mem_sInf.mp hx _ ⟨hp, rfl⟩, fun hx =>
            Subring.mem_sInf.mpr fun p' ⟨_, p'_eq⟩ => p'_eq ▸ hx⟩⟩⟩
state_before: case h
K : Type u
L : Type v
M : Type w
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Field M
s : Set (Subfield K)
x : K
⊢ (∀ (p : Subfield K), p ∈ s → x ∈ p) ↔ ∀ (p : Subring K), (p ∈ Set.range fun t => ⨅ (_ : t ∈ s), t.toSubring) → x ∈ p
Theorem: UniformSpace.Completion.uniformity_dist
File: Mathlib/Topology/MetricSpace/Completion.lean

tactic: simpa [iInf_subtype] using @Completion.uniformity_dist' α _
state_before: α : Type u
β : Type v
inst✝ : PseudoMetricSpace α
⊢ 𝓤 (Completion α) = ⨅ (ε : ℝ) (_ : ε > 0), 𝓟 {p | dist p.fst p.snd < ε}
Theorem: AffineIsometry.edist_map
File: Mathlib/Analysis/NormedSpace/AffineIsometry.lean

tactic: simp [edist_dist, (dist_map)]
state_before: 𝕜 : Type u_5
V : Type u_2
V₁ : Type ?u.50158
V₂ : Type u_3
V₃ : Type ?u.50164
V₄ : Type ?u.50167
P₁ : Type ?u.50170
P : Type u_4
P₂ : Type u_1
P₃ : Type ?u.50179
P₄ : Type ?u.50182
inst✝²⁰ : NormedField 𝕜
inst✝¹⁹ : SeminormedAddCommGroup V
inst✝¹⁸ : SeminormedAddCommGroup V₁
inst✝¹⁷ : SeminormedAddCommGroup V₂
inst✝¹⁶ : SeminormedAddCommGroup V₃
inst✝¹⁵ : SeminormedAddCommGroup V₄
inst✝¹⁴ : NormedSpace 𝕜 V
inst✝¹³ : NormedSpace 𝕜 V₁
inst✝¹² : NormedSpace 𝕜 V₂
inst✝¹¹ : NormedSpace 𝕜 V₃
inst✝¹⁰ : NormedSpace 𝕜 V₄
inst✝⁹ : PseudoMetricSpace P
inst✝⁸ : MetricSpace P₁
inst✝⁷ : PseudoMetricSpace P₂
inst✝⁶ : PseudoMetricSpace P₃
inst✝⁵ : PseudoMetricSpace P₄
inst✝⁴ : NormedAddTorsor V P
inst✝³ : NormedAddTorsor V₁ P₁
inst✝² : NormedAddTorsor V₂ P₂
inst✝¹ : NormedAddTorsor V₃ P₃
inst✝ : NormedAddTorsor V₄ P₄
f : P →ᵃⁱ[𝕜] P₂
f₁ : P₁ →ᵃⁱ[𝕜] P₂
x y : P
⊢ edist (↑f x) (↑f y) = edist x y
Theorem: Set.mk_preimage_prod_left
File: Mathlib/Data/Set/Prod.lean

tactic: ext a
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.25613
δ : Type ?u.25616
s s₁ s₂ : Set α
t t₁ t₂ : Set β
a : α
b : β
hb : b ∈ t
⊢ (fun a => (a, b)) ⁻¹' s ×ˢ t = s

tactic: simp [hb]
state_before: case h
α : Type u_2
β : Type u_1
γ : Type ?u.25613
δ : Type ?u.25616
s s₁ s₂ : Set α
t t₁ t₂ : Set β
a✝ : α
b : β
hb : b ∈ t
a : α
⊢ a ∈ (fun a => (a, b)) ⁻¹' s ×ˢ t ↔ a ∈ s