tasksource/leandojo huggingface dataset:
Theorem: Matrix.eq_zero_of_forall_index_sum_mul_pow_eq_zero
File: Mathlib/LinearAlgebra/Vandermonde.lean

tactic: apply eq_zero_of_forall_index_sum_pow_mul_eq_zero hf
state_before: R✝ : Type ?u.158834
inst✝² : CommRing R✝
R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
n : ℕ
f v : Fin n → R
hf : Function.Injective f
hfv : ∀ (j : Fin n), ∑ i : Fin n, v i * f j ^ ↑i = 0
⊢ v = 0

tactic: simp_rw [mul_comm]
state_before: R✝ : Type ?u.158834
inst✝² : CommRing R✝
R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
n : ℕ
f v : Fin n → R
hf : Function.Injective f
hfv : ∀ (j : Fin n), ∑ i : Fin n, v i * f j ^ ↑i = 0
⊢ ∀ (j : Fin n), ∑ i : Fin n, f j ^ ↑i * v i = 0

tactic: exact hfv
state_before: R✝ : Type ?u.158834
inst✝² : CommRing R✝
R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
n : ℕ
f v : Fin n → R
hf : Function.Injective f
hfv : ∀ (j : Fin n), ∑ i : Fin n, v i * f j ^ ↑i = 0
⊢ ∀ (j : Fin n), ∑ x : Fin n, v x * f j ^ ↑x = 0
Theorem: Finsupp.mapDomain_injective
File: Mathlib/Data/Finsupp/Basic.lean

tactic: intro v₁ v₂ eq
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.251410
ι : Type ?u.251413
M : Type u_3
M' : Type ?u.251419
N : Type ?u.251422
P : Type ?u.251425
G : Type ?u.251428
H : Type ?u.251431
R : Type ?u.251434
S : Type ?u.251437
inst✝ : AddCommMonoid M
v v₁ v₂ : α →₀ M
f : α → β
hf : Injective f
⊢ Injective (mapDomain f)

tactic: ext a
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.251410
ι : Type ?u.251413
M : Type u_3
M' : Type ?u.251419
N : Type ?u.251422
P : Type ?u.251425
G : Type ?u.251428
H : Type ?u.251431
R : Type ?u.251434
S : Type ?u.251437
inst✝ : AddCommMonoid M
v v₁✝ v₂✝ : α →₀ M
f : α → β
hf : Injective f
v₁ v₂ : α →₀ M
eq : mapDomain f v₁ = mapDomain f v₂
⊢ v₁ = v₂

tactic: have : mapDomain f v₁ (f a) = mapDomain f v₂ (f a) := by rw [eq]
state_before: case h
α : Type u_1
β : Type u_2
γ : Type ?u.251410
ι : Type ?u.251413
M : Type u_3
M' : Type ?u.251419
N : Type ?u.251422
P : Type ?u.251425
G : Type ?u.251428
H : Type ?u.251431
R : Type ?u.251434
S : Type ?u.251437
inst✝ : AddCommMonoid M
v v₁✝ v₂✝ : α →₀ M
f : α → β
hf : Injective f
v₁ v₂ : α →₀ M
eq : mapDomain f v₁ = mapDomain f v₂
a : α
⊢ ↑v₁ a = ↑v₂ a

tactic: rwa [mapDomain_apply hf, mapDomain_apply hf] at this
state_before: case h
α : Type u_1
β : Type u_2
γ : Type ?u.251410
ι : Type ?u.251413
M : Type u_3
M' : Type ?u.251419
N : Type ?u.251422
P : Type ?u.251425
G : Type ?u.251428
H : Type ?u.251431
R : Type ?u.251434
S : Type ?u.251437
inst✝ : AddCommMonoid M
v v₁✝ v₂✝ : α →₀ M
f : α → β
hf : Injective f
v₁ v₂ : α →₀ M
eq : mapDomain f v₁ = mapDomain f v₂
a : α
this : ↑(mapDomain f v₁) (f a) = ↑(mapDomain f v₂) (f a)
⊢ ↑v₁ a = ↑v₂ a

tactic: rw [eq]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.251410
ι : Type ?u.251413
M : Type u_3
M' : Type ?u.251419
N : Type ?u.251422
P : Type ?u.251425
G : Type ?u.251428
H : Type ?u.251431
R : Type ?u.251434
S : Type ?u.251437
inst✝ : AddCommMonoid M
v v₁✝ v₂✝ : α →₀ M
f : α → β
hf : Injective f
v₁ v₂ : α →₀ M
eq : mapDomain f v₁ = mapDomain f v₂
a : α
⊢ ↑(mapDomain f v₁) (f a) = ↑(mapDomain f v₂) (f a)
Theorem: Zsqrtd.norm_one
File: Mathlib/NumberTheory/Zsqrtd/Basic.lean

tactic: simp [norm]
state_before: d : ℤ
⊢ norm 1 = 1
Theorem: finprod_curry₃
File: Mathlib/Algebra/BigOperators/Finprod.lean

tactic: rw [finprod_curry f h]
state_before: α : Type u_2
β : Type u_3
ι : Type ?u.462199
G : Type ?u.462202
M : Type u_4
N : Type ?u.462208
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f✝ g : α → M
a b : α
s t : Set α
γ : Type u_1
f : α × β × γ → M
h : Set.Finite (mulSupport f)
⊢ (∏ᶠ (abc : α × β × γ), f abc) = ∏ᶠ (a : α) (b : β) (c : γ), f (a, b, c)

tactic: congr
state_before: α : Type u_2
β : Type u_3
ι : Type ?u.462199
G : Type ?u.462202
M : Type u_4
N : Type ?u.462208
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f✝ g : α → M
a b : α
s t : Set α
γ : Type u_1
f : α × β × γ → M
h : Set.Finite (mulSupport f)
⊢ (∏ᶠ (a : α) (b : β × γ), f (a, b)) = ∏ᶠ (a : α) (b : β) (c : γ), f (a, b, c)

tactic: ext a
state_before: case e_f
α : Type u_2
β : Type u_3
ι : Type ?u.462199
G : Type ?u.462202
M : Type u_4
N : Type ?u.462208
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f✝ g : α → M
a b : α
s t : Set α
γ : Type u_1
f : α × β × γ → M
h : Set.Finite (mulSupport f)
⊢ (fun a => ∏ᶠ (b : β × γ), f (a, b)) = fun a => ∏ᶠ (b : β) (c : γ), f (a, b, c)

tactic: rw [finprod_curry]
state_before: case e_f.h
α : Type u_2
β : Type u_3
ι : Type ?u.462199
G : Type ?u.462202
M : Type u_4
N : Type ?u.462208
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f✝ g : α → M
a✝ b : α
s t : Set α
γ : Type u_1
f : α × β × γ → M
h : Set.Finite (mulSupport f)
a : α
⊢ (∏ᶠ (b : β × γ), f (a, b)) = ∏ᶠ (b : β) (c : γ), f (a, b, c)

tactic: simp [h]
state_before: case e_f.h.hf
α : Type u_2
β : Type u_3
ι : Type ?u.462199
G : Type ?u.462202
M : Type u_4
N : Type ?u.462208
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f✝ g : α → M
a✝ b : α
s t : Set α
γ : Type u_1
f : α × β × γ → M
h : Set.Finite (mulSupport f)
a : α
⊢ Set.Finite (mulSupport fun b => f (a, b))
Theorem: Polynomial.content_eq_gcd_leadingCoeff_content_eraseLead
File: Mathlib/RingTheory/Polynomial/Content.lean

tactic: by_cases h : p = 0
state_before: R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
p : R[X]
⊢ content p = gcd (leadingCoeff p) (content (eraseLead p))

tactic: rw [← leadingCoeff_eq_zero, leadingCoeff, ← Ne.def, ← mem_support_iff] at h
state_before: case neg
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
p : R[X]
h : ¬p = 0
⊢ content p = gcd (leadingCoeff p) (content (eraseLead p))

tactic: rw [content, ← Finset.insert_erase h, Finset.gcd_insert, leadingCoeff, content,
  eraseLead_support]
state_before: case neg
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
p : R[X]
h : natDegree p ∈ support p
⊢ content p = gcd (leadingCoeff p) (content (eraseLead p))

tactic: refine' congr rfl (Finset.gcd_congr rfl fun i hi => _)
state_before: case neg
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
p : R[X]
h : natDegree p ∈ support p
⊢ gcd (coeff p (natDegree p)) (Finset.gcd (Finset.erase (support p) (natDegree p)) (coeff p)) =
    gcd (coeff p (natDegree p)) (Finset.gcd (Finset.erase (support p) (natDegree p)) (coeff (eraseLead p)))

tactic: rw [Finset.mem_erase] at hi
state_before: case neg
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
p : R[X]
h : natDegree p ∈ support p
i : ℕ
hi : i ∈ Finset.erase (support p) (natDegree p)
⊢ coeff p i = coeff (eraseLead p) i

tactic: rw [eraseLead_coeff, if_neg hi.1]
state_before: case neg
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
p : R[X]
h : natDegree p ∈ support p
i : ℕ
hi : i ≠ natDegree p ∧ i ∈ support p
⊢ coeff p i = coeff (eraseLead p) i

tactic: simp [h]
state_before: case pos
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
p : R[X]
h : p = 0
⊢ content p = gcd (leadingCoeff p) (content (eraseLead p))
Theorem: Pretrivialization.proj_symm_apply
File: Mathlib/Topology/FiberBundle/Trivialization.lean

tactic: have := (e.coe_fst (e.map_target hx)).symm
state_before: ι : Type ?u.6755
B : Type u_1
F : Type u_2
E : B → Type ?u.6766
Z : Type u_3
inst✝¹ : TopologicalSpace B
inst✝ : TopologicalSpace F
proj : Z → B
e : Pretrivialization F proj
x✝ : Z
x : B × F
hx : x ∈ e.target
⊢ proj (↑(LocalEquiv.symm e.toLocalEquiv) x) = x.fst

tactic: rwa [← e.coe_coe, e.right_inv hx] at this
state_before: ι : Type ?u.6755
B : Type u_1
F : Type u_2
E : B → Type ?u.6766
Z : Type u_3
inst✝¹ : TopologicalSpace B
inst✝ : TopologicalSpace F
proj : Z → B
e : Pretrivialization F proj
x✝ : Z
x : B × F
hx : x ∈ e.target
this : proj (↑(LocalEquiv.symm e.toLocalEquiv) x) = (↑e (↑(LocalEquiv.symm e.toLocalEquiv) x)).fst
⊢ proj (↑(LocalEquiv.symm e.toLocalEquiv) x) = x.fst
Theorem: Multiset.exists_mem_of_ne_zero
File: Mathlib/Data/Multiset/Basic.lean

tactic: simp
state_before: α : Type u_1
β : Type ?u.17075
γ : Type ?u.17078
s : Multiset α
l✝ : List α
hl : Quot.mk Setoid.r l✝ ≠ 0
a : α
l : List α
x✝ : Quot.mk Setoid.r (a :: l) ≠ 0
⊢ a ∈ Quot.mk Setoid.r (a :: l)
Theorem: Functor.mapEquiv_refl
File: Mathlib/Logic/Equiv/Functor.lean

tactic: ext x
state_before: α β : Type u
f : Type u → Type v
inst✝¹ : Functor f
inst✝ : LawfulFunctor f
⊢ mapEquiv f (Equiv.refl α) = Equiv.refl (f α)

tactic: simp only [mapEquiv_apply, refl_apply]
state_before: case H
α β : Type u
f : Type u → Type v
inst✝¹ : Functor f
inst✝ : LawfulFunctor f
x : f α
⊢ ↑(mapEquiv f (Equiv.refl α)) x = ↑(Equiv.refl (f α)) x

tactic: exact LawfulFunctor.id_map x
state_before: case H
α β : Type u
f : Type u → Type v
inst✝¹ : Functor f
inst✝ : LawfulFunctor f
x : f α
⊢ ↑(Equiv.refl α) <$> x = x
Theorem: Basis.sumCoords_self_apply
File: Mathlib/LinearAlgebra/Basis.lean

tactic: simp only [Basis.sumCoords, LinearMap.id_coe, LinearEquiv.coe_coe, id.def, Basis.repr_self,
  Function.comp_apply, Finsupp.coe_lsum, LinearMap.coe_comp, Finsupp.sum_single_index]
state_before: ι : Type u_2
ι' : Type ?u.168945
R : Type u_1
R₂ : Type ?u.168951
K : Type ?u.168954
M : Type u_3
M' : Type ?u.168960
M'' : Type ?u.168963
V : Type u
V' : Type ?u.168968
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
b b₁ : Basis ι R M
i : ι
c : R
x : M
⊢ ↑(sumCoords b) (↑b i) = 1
Theorem: Metric.mem_closure_range_iff
File: Mathlib/Topology/MetricSpace/Basic.lean

tactic: simp only [mem_closure_iff, exists_range_iff]
state_before: α : Type u
β : Type v
X : Type ?u.303666
ι : Type ?u.303669
inst✝ : PseudoMetricSpace α
x y z : α
ε ε₁ ε₂ : ℝ
s : Set α
e : β → α
a : α
⊢ a ∈ closure (range e) ↔ ∀ (ε : ℝ), ε > 0 → ∃ k, dist a (e k) < ε
Theorem: Bool.not_beq_false
File: src/lean/Init/SimpLemmas.lean

tactic: cases b <;> rfl
state_before: b : Bool
⊢ (!b == false) = (b == true)
Theorem: MonoidHom.mrangeRestrict_mker
File: Mathlib/GroupTheory/Submonoid/Operations.lean

tactic: ext x
state_before: M : Type u_1
N : Type u_2
P : Type ?u.138500
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : MulOneClass P
S : Submonoid M
A : Type ?u.138521
inst✝ : SetLike A M
hA : SubmonoidClass A M
S' : A
F : Type ?u.138545
mc : MonoidHomClass F M N
f : M →* N
⊢ mker (mrangeRestrict f) = mker f

tactic: change (⟨f x, _⟩ : mrange f) = ⟨1, _⟩ ↔ f x = 1
state_before: case h
M : Type u_1
N : Type u_2
P : Type ?u.138500
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : MulOneClass P
S : Submonoid M
A : Type ?u.138521
inst✝ : SetLike A M
hA : SubmonoidClass A M
S' : A
F : Type ?u.138545
mc : MonoidHomClass F M N
f : M →* N
x : M
⊢ x ∈ mker (mrangeRestrict f) ↔ x ∈ mker f

tactic: simp
state_before: case h
M : Type u_1
N : Type u_2
P : Type ?u.138500
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : MulOneClass P
S : Submonoid M
A : Type ?u.138521
inst✝ : SetLike A M
hA : SubmonoidClass A M
S' : A
F : Type ?u.138545
mc : MonoidHomClass F M N
f : M →* N
x : M
⊢ { val := ↑f x, property := (_ : ∃ y, ↑f y = ↑f x) } = { val := 1, property := (_ : 1 ∈ mrange f) } ↔ ↑f x = 1
Theorem: CategoryTheory.Idempotents.Karoubi.decompId_p_toKaroubi
File: Mathlib/CategoryTheory/Idempotents/Karoubi.lean

tactic: rfl
state_before: C : Type u_2
inst✝ : Category C
X : C
⊢ decompId_p ((toKaroubi C).obj X) = 𝟙 (mk ((toKaroubi C).obj X).X (𝟙 ((toKaroubi C).obj X).X))
Theorem: Int.eq_of_mul_eq_mul_right
File: Std/Data/Int/Lemmas.lean

tactic: rwa [Int.sub_mul, Int.sub_eq_zero]
state_before: a b c : Int
ha : a ≠ 0
h : b * a = c * a
⊢ (b - c) * a = 0
Theorem: Finset.centerMass_empty
File: Mathlib/Analysis/Convex/Combination.lean

tactic: simp only [centerMass, sum_empty, smul_zero]
state_before: R : Type u_2
E : Type u_1
F : Type ?u.5996
ι : Type u_3
ι' : Type ?u.6002
α : Type ?u.6005
inst✝⁷ : LinearOrderedField R
inst✝⁶ : AddCommGroup E
inst✝⁵ : AddCommGroup F
inst✝⁴ : LinearOrderedAddCommGroup α
inst✝³ : Module R E
inst✝² : Module R F
inst✝¹ : Module R α
inst✝ : OrderedSMul R α
s : Set E
i j : ι
c : R
t : Finset ι
w : ι → R
z : ι → E
⊢ centerMass ∅ w z = 0
Theorem: Cardinal.natCast_lt
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: rw [lt_iff_le_not_le, ← not_le]
state_before: α β : Type u
m n : ℕ
⊢ ↑m < ↑n ↔ m < n

tactic: simp only [natCast_le, not_le, and_iff_right_iff_imp]
state_before: α β : Type u
m n : ℕ
⊢ ↑m ≤ ↑n ∧ ¬↑n ≤ ↑m ↔ ¬n ≤ m

tactic: exact fun h ↦ le_of_lt h
state_before: α β : Type u
m n : ℕ
⊢ m < n → m ≤ n
Theorem: Cardinal.continuum_le_lift
File: Mathlib/SetTheory/Cardinal/Continuum.lean

tactic: rw [← lift_continuum.{u,v}, lift_le]
state_before: c : Cardinal
⊢ 𝔠 ≤ lift c ↔ 𝔠 ≤ c
Theorem: List.sublist.erase
File: Std/Data/List/Lemmas.lean

tactic: simp only [erase_eq_eraseP]
state_before: α : Type u_1
inst✝ : DecidableEq α
a : α
l₁ l₂ : List α
h : l₁ <+ l₂
⊢ List.erase l₁ a <+ List.erase l₂ a

tactic: exact h.eraseP
state_before: α : Type u_1
inst✝ : DecidableEq α
a : α
l₁ l₂ : List α
h : l₁ <+ l₂
⊢ eraseP (fun b => decide (a = b)) l₁ <+ eraseP (fun b => decide (a = b)) l₂
Theorem: IsCoprime.mul_add_left_right
File: Mathlib/RingTheory/Coprime/Basic.lean

tactic: rw [add_comm]
state_before: R : Type u
inst✝ : CommRing R
x y : R
h : IsCoprime x y
z : R
⊢ IsCoprime x (x * z + y)

tactic: exact h.add_mul_left_right z
state_before: R : Type u
inst✝ : CommRing R
x y : R
h : IsCoprime x y
z : R
⊢ IsCoprime x (y + x * z)
Theorem: Real.cos_pi_div_two
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

tactic: rw [Real.pi, mul_div_cancel_left _ (two_ne_zero' ℝ)]
state_before: ⊢ cos (π / 2) = 0

tactic: exact (Classical.choose_spec exists_cos_eq_zero).2
state_before: ⊢ cos (choose exists_cos_eq_zero) = 0
Theorem: SimpleGraph.incidenceSet_inter_incidenceSet_of_not_adj
File: Mathlib/Combinatorics/SimpleGraph/Basic.lean

tactic: simp_rw [Set.eq_empty_iff_forall_not_mem, Set.mem_inter_iff, not_and]
state_before: ι : Sort ?u.101434
𝕜 : Type ?u.101437
V : Type u
W : Type v
X : Type w
G : SimpleGraph V
G' : SimpleGraph W
a b c u v w : V
e : Sym2 V
h : ¬Adj G a b
hn : a ≠ b
⊢ incidenceSet G a ∩ incidenceSet G b = ∅

tactic: intro u ha hb
state_before: ι : Sort ?u.101434
𝕜 : Type ?u.101437
V : Type u
W : Type v
X : Type w
G : SimpleGraph V
G' : SimpleGraph W
a b c u v w : V
e : Sym2 V
h : ¬Adj G a b
hn : a ≠ b
⊢ ∀ (x : Sym2 V), x ∈ incidenceSet G a → ¬x ∈ incidenceSet G b

tactic: exact h (G.adj_of_mem_incidenceSet hn ha hb)
state_before: ι : Sort ?u.101434
𝕜 : Type ?u.101437
V : Type u
W : Type v
X : Type w
G : SimpleGraph V
G' : SimpleGraph W
a b c u✝ v w : V
e : Sym2 V
h : ¬Adj G a b
hn : a ≠ b
u : Sym2 V
ha : u ∈ incidenceSet G a
hb : u ∈ incidenceSet G b
⊢ False
Theorem: CircleDeg1Lift.commute_sub_nat
File: Mathlib/Dynamics/Circle/RotationNumber/TranslationNumber.lean

tactic: simpa only [sub_eq_add_neg] using
  (f.commute_add_nat n).inverses_right (Equiv.addRight _).right_inv (Equiv.addRight _).left_inv
state_before: f g : CircleDeg1Lift
n : ℕ
⊢ Function.Commute ↑f fun x => x - ↑n
Theorem: SimpleGraph.Subgraph.IsMatching.toEdge_eq_toEdge_of_adj
File: Mathlib/Combinatorics/SimpleGraph/Matching.lean

tactic: rw [h.toEdge_eq_of_adj hv ha, h.toEdge_eq_of_adj hw (M.symm ha), Subtype.mk_eq_mk, Sym2.eq_swap]
state_before: V : Type u
G : SimpleGraph V
M✝ M : Subgraph G
v w : V
h : IsMatching M
hv : v ∈ M.verts
hw : w ∈ M.verts
ha : Adj M v w
⊢ toEdge h { val := v, property := hv } = toEdge h { val := w, property := hw }
Theorem: Rel.comp_assoc
File: Mathlib/Data/Rel.lean

tactic: unfold comp
state_before: α : Type u_2
β : Type u_3
γ : Type u_4
r✝ : Rel α β
δ : Type u_1
r : Rel α β
s : Rel β γ
t : Rel γ δ
⊢ (r • s) • t = r • s • t

tactic: ext (x w)
state_before: α : Type u_2
β : Type u_3
γ : Type u_4
r✝ : Rel α β
δ : Type u_1
r : Rel α β
s : Rel β γ
t : Rel γ δ
⊢ (fun x z => ∃ y, (∃ y_1, r x y_1 ∧ s y_1 y) ∧ t y z) = fun x z => ∃ y, r x y ∧ ∃ y_1, s y y_1 ∧ t y_1 z

tactic: constructor
state_before: case a.h.a
α : Type u_2
β : Type u_3
γ : Type u_4
r✝ : Rel α β
δ : Type u_1
r : Rel α β
s : Rel β γ
t : Rel γ δ
x : α
w : δ
⊢ (∃ y, (∃ y_1, r x y_1 ∧ s y_1 y) ∧ t y w) ↔ ∃ y, r x y ∧ ∃ y_1, s y y_1 ∧ t y_1 w

tactic: rintro ⟨z, ⟨y, rxy, syz⟩, tzw⟩
state_before: case a.h.a.mp
α : Type u_2
β : Type u_3
γ : Type u_4
r✝ : Rel α β
δ : Type u_1
r : Rel α β
s : Rel β γ
t : Rel γ δ
x : α
w : δ
⊢ (∃ y, (∃ y_1, r x y_1 ∧ s y_1 y) ∧ t y w) → ∃ y, r x y ∧ ∃ y_1, s y y_1 ∧ t y_1 w

tactic: exact ⟨y, rxy, z, syz, tzw⟩
state_before: case a.h.a.mp.intro.intro.intro.intro
α : Type u_2
β : Type u_3
γ : Type u_4
r✝ : Rel α β
δ : Type u_1
r : Rel α β
s : Rel β γ
t : Rel γ δ
x : α
w : δ
z : γ
tzw : t z w
y : β
rxy : r x y
syz : s y z
⊢ ∃ y, r x y ∧ ∃ y_1, s y y_1 ∧ t y_1 w

tactic: rintro ⟨y, rxy, z, syz, tzw⟩
state_before: case a.h.a.mpr
α : Type u_2
β : Type u_3
γ : Type u_4
r✝ : Rel α β
δ : Type u_1
r : Rel α β
s : Rel β γ
t : Rel γ δ
x : α
w : δ
⊢ (∃ y, r x y ∧ ∃ y_1, s y y_1 ∧ t y_1 w) → ∃ y, (∃ y_1, r x y_1 ∧ s y_1 y) ∧ t y w

tactic: exact ⟨z, ⟨y, rxy, syz⟩, tzw⟩
state_before: case a.h.a.mpr.intro.intro.intro.intro
α : Type u_2
β : Type u_3
γ : Type u_4
r✝ : Rel α β
δ : Type u_1
r : Rel α β
s : Rel β γ
t : Rel γ δ
x : α
w : δ
y : β
rxy : r x y
z : γ
syz : s y z
tzw : t z w
⊢ ∃ y, (∃ y_1, r x y_1 ∧ s y_1 y) ∧ t y w
Theorem: ConvexOn.le_right_of_left_le'
File: Mathlib/Analysis/Convex/Function.lean

tactic: rw [add_comm] at hab hfx⊢
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.537715
α : Type ?u.537718
β : Type u_3
ι : Type ?u.537724
inst✝⁶ : OrderedSemiring 𝕜
inst✝⁵ : AddCommMonoid E
inst✝⁴ : AddCommMonoid F
inst✝³ : LinearOrderedCancelAddCommMonoid β
inst✝² : SMul 𝕜 E
inst✝¹ : Module 𝕜 β
inst✝ : OrderedSMul 𝕜 β
s : Set E
f g : E → β
hf : ConvexOn 𝕜 s f
x y : E
a b : 𝕜
hx : x ∈ s
hy : y ∈ s
ha : 0 ≤ a
hb : 0 < b
hab : a + b = 1
hfx : f x ≤ f (a • x + b • y)
⊢ f (a • x + b • y) ≤ f y

tactic: exact hf.le_left_of_right_le' hy hx hb ha hab hfx
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.537715
α : Type ?u.537718
β : Type u_3
ι : Type ?u.537724
inst✝⁶ : OrderedSemiring 𝕜
inst✝⁵ : AddCommMonoid E
inst✝⁴ : AddCommMonoid F
inst✝³ : LinearOrderedCancelAddCommMonoid β
inst✝² : SMul 𝕜 E
inst✝¹ : Module 𝕜 β
inst✝ : OrderedSMul 𝕜 β
s : Set E
f g : E → β
hf : ConvexOn 𝕜 s f
x y : E
a b : 𝕜
hx : x ∈ s
hy : y ∈ s
ha : 0 ≤ a
hb : 0 < b
hab : b + a = 1
hfx : f x ≤ f (b • y + a • x)
⊢ f (b • y + a • x) ≤ f y
Theorem: intervalIntegral.integral_cases
File: Mathlib/MeasureTheory/Integral/IntervalIntegral.lean

tactic: rw [intervalIntegral_eq_integral_uIoc]
state_before: ι : Type ?u.10756409
𝕜 : Type ?u.10756412
E : Type u_1
F : Type ?u.10756418
A : Type ?u.10756421
inst✝² : NormedAddCommGroup E
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
a✝ b✝ : ℝ
f✝ g : ℝ → E
μ : MeasureTheory.Measure ℝ
f : ℝ → E
a b : ℝ
⊢ (∫ (x : ℝ) in a..b, f x ∂μ) ∈ {∫ (x : ℝ) in Ι a b, f x ∂μ, -∫ (x : ℝ) in Ι a b, f x ∂μ}

tactic: split_ifs <;> simp
state_before: ι : Type ?u.10756409
𝕜 : Type ?u.10756412
E : Type u_1
F : Type ?u.10756418
A : Type ?u.10756421
inst✝² : NormedAddCommGroup E
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
a✝ b✝ : ℝ
f✝ g : ℝ → E
μ : MeasureTheory.Measure ℝ
f : ℝ → E
a b : ℝ
⊢ ((if a ≤ b then 1 else -1) • ∫ (x : ℝ) in Ι a b, f x ∂μ) ∈ {∫ (x : ℝ) in Ι a b, f x ∂μ, -∫ (x : ℝ) in Ι a b, f x ∂μ}
Theorem: Stream'.WSeq.join_cons
File: Mathlib/Data/Seq/WSeq.lean

tactic: simp [think, join]
state_before: α : Type u
β : Type v
γ : Type w
s : WSeq α
S : WSeq (WSeq α)
⊢ join (cons s S) = think (append s (join S))

tactic: simp [join, cons, append]
state_before: α : Type u
β : Type v
γ : Type w
s : WSeq α
S : WSeq (WSeq α)
⊢ Seq.join
      (Seq.map
        (fun o =>
          match o with
          | none => Seq1.ret none
          | some s => (none, s))
        (cons s S)) =
    Seq.cons none
      (append s
        (Seq.join
          (Seq.map
            (fun o =>
              match o with
              | none => Seq1.ret none
              | some s => (none, s))
            S)))
Theorem: PFun.preimage_univ
File: Mathlib/Data/PFun.lean

tactic: ext
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.43744
δ : Type ?u.43747
ε : Type ?u.43750
ι : Type ?u.43753
f : α →. β
⊢ preimage f Set.univ = Dom f

tactic: simp [mem_preimage, mem_dom]
state_before: case h
α : Type u_1
β : Type u_2
γ : Type ?u.43744
δ : Type ?u.43747
ε : Type ?u.43750
ι : Type ?u.43753
f : α →. β
x✝ : α
⊢ x✝ ∈ preimage f Set.univ ↔ x✝ ∈ Dom f
Theorem: CategoryTheory.Limits.colimit.isoColimitCocone_ι_inv
File: Mathlib/CategoryTheory/Limits/HasLimits.lean

tactic: dsimp [colimit.isoColimitCocone, IsColimit.coconePointUniqueUpToIso]
state_before: J : Type u₁
inst✝³ : Category J
K : Type u₂
inst✝² : Category K
C : Type u
inst✝¹ : Category C
F✝ F : J ⥤ C
inst✝ : HasColimit F
t : ColimitCocone F
j : J
⊢ t.cocone.ι.app j ≫ (isoColimitCocone t).inv = ι F j

tactic: aesop_cat
state_before: J : Type u₁
inst✝³ : Category J
K : Type u₂
inst✝² : Category K
C : Type u
inst✝¹ : Category C
F✝ F : J ⥤ C
inst✝ : HasColimit F
t : ColimitCocone F
j : J
⊢ t.cocone.ι.app j ≫ IsColimit.desc t.isColimit (cocone F) = ι F j
Theorem: AddMonoidAlgebra.mem_gradeBy_iff
File: Mathlib/Algebra/MonoidAlgebra/Grading.lean

tactic: rfl
state_before: M : Type u_2
ι : Type u_3
R : Type u_1
inst✝¹ : DecidableEq M
inst✝ : CommSemiring R
f : M → ι
i : ι
a : AddMonoidAlgebra R M
⊢ a ∈ gradeBy R f i ↔ ↑a.support ⊆ f ⁻¹' {i}
Theorem: Function.Antiperiodic.div
File: Mathlib/Algebra/Periodic.lean

tactic: simp_all [neg_div_neg_eq]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.225603
f g : α → β
c c₁ c₂ x : α
inst✝² : Add α
inst✝¹ : DivisionMonoid β
inst✝ : HasDistribNeg β
hf : Antiperiodic f c
hg : Antiperiodic g c
⊢ Periodic (f / g) c
Theorem: UV.compress_self
File: Mathlib/Combinatorics/SetFamily/Compression/UV.lean

tactic: unfold compress
state_before: α : Type u_1
inst✝² : GeneralizedBooleanAlgebra α
inst✝¹ : DecidableRel Disjoint
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
s : Finset α
u✝ v a✝ b u a : α
⊢ compress u u a = a

tactic: split_ifs
state_before: α : Type u_1
inst✝² : GeneralizedBooleanAlgebra α
inst✝¹ : DecidableRel Disjoint
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
s : Finset α
u✝ v a✝ b u a : α
⊢ (if Disjoint u a ∧ u ≤ a then (a ⊔ u) \ u else a) = a

tactic: exact ‹Disjoint u a ∧ u ≤ a›.1.symm.sup_sdiff_cancel_right
state_before: case inl
α : Type u_1
inst✝² : GeneralizedBooleanAlgebra α
inst✝¹ : DecidableRel Disjoint
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
s : Finset α
u✝ v a✝ b u a : α
h✝ : Disjoint u a ∧ u ≤ a
⊢ (a ⊔ u) \ u = a

tactic: rfl
state_before: case inr
α : Type u_1
inst✝² : GeneralizedBooleanAlgebra α
inst✝¹ : DecidableRel Disjoint
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
s : Finset α
u✝ v a✝ b u a : α
h✝ : ¬(Disjoint u a ∧ u ≤ a)
⊢ a = a
Theorem: Mathlib.Tactic.Abel.const_add_term
File: Mathlib/Tactic/Abel.lean

tactic: simp [h.symm, term, add_comm, add_assoc]
state_before: α : Type u_1
inst✝ : AddCommMonoid α
k : α
n : ℕ
x a a' : α
h : k + a = a'
⊢ k + term n x a = term n x a'