tasksource/leandojo huggingface dataset:
Theorem: linearIndependent_le_basis
File: Mathlib/LinearAlgebra/Dimension.lean

tactic: cases fintypeOrInfinite ι
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.369966
R : Type u
inst✝³ : Ring R
inst✝² : StrongRankCondition R
M : Type v
inst✝¹ : AddCommGroup M
inst✝ : Module R M
ι : Type u_1
b : Basis ι R M
κ : Type u_1
v : κ → M
i : LinearIndependent R v
⊢ (#κ) ≤ (#ι)

tactic: rw [Cardinal.mk_fintype ι]
state_before: case inl
K : Type u
V V₁ V₂ V₃ : Type v
V' V'₁ : Type v'
V'' : Type v''
ι✝ : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type ?u.369966
R : Type u
inst✝³ : Ring R
inst✝² : StrongRankCondition R
M : Type v
inst✝¹ : AddCommGroup M
inst✝ : Module R M
ι : Type u_1
b : Basis ι R M
κ : Type u_1
v : κ → M
i : LinearIndependent R v
val✝ : Fintype ι
⊢ (#κ) ≤ (#ι)

tactic: haveI : Nontrivial R := nontrivial_of_invariantBasisNumber R
state_before: case inl
K : Type u
V V₁ V₂ V₃ : Type v
V' V'₁ : Type v'
V'' : Type v''
ι✝ : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type ?u.369966
R : Type u
inst✝³ : Ring R
inst✝² : StrongRankCondition R
M : Type v
inst✝¹ : AddCommGroup M
inst✝ : Module R M
ι : Type u_1
b : Basis ι R M
κ : Type u_1
v : κ → M
i : LinearIndependent R v
val✝ : Fintype ι
⊢ (#κ) ≤ ↑(Fintype.card ι)

tactic: rw [Fintype.card_congr (Equiv.ofInjective b b.injective)]
state_before: case inl
K : Type u
V V₁ V₂ V₃ : Type v
V' V'₁ : Type v'
V'' : Type v''
ι✝ : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type ?u.369966
R : Type u
inst✝³ : Ring R
inst✝² : StrongRankCondition R
M : Type v
inst✝¹ : AddCommGroup M
inst✝ : Module R M
ι : Type u_1
b : Basis ι R M
κ : Type u_1
v : κ → M
i : LinearIndependent R v
val✝ : Fintype ι
this : Nontrivial R
⊢ (#κ) ≤ ↑(Fintype.card ι)

tactic: exact linearIndependent_le_span v i (range b) b.span_eq
state_before: case inl
K : Type u
V V₁ V₂ V₃ : Type v
V' V'₁ : Type v'
V'' : Type v''
ι✝ : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type ?u.369966
R : Type u
inst✝³ : Ring R
inst✝² : StrongRankCondition R
M : Type v
inst✝¹ : AddCommGroup M
inst✝ : Module R M
ι : Type u_1
b : Basis ι R M
κ : Type u_1
v : κ → M
i : LinearIndependent R v
val✝ : Fintype ι
this : Nontrivial R
⊢ (#κ) ≤ ↑(Fintype.card ↑(range ↑b))

tactic: exact linearIndependent_le_infinite_basis b v i
state_before: case inr
K : Type u
V V₁ V₂ V₃ : Type v
V' V'₁ : Type v'
V'' : Type v''
ι✝ : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type ?u.369966
R : Type u
inst✝³ : Ring R
inst✝² : StrongRankCondition R
M : Type v
inst✝¹ : AddCommGroup M
inst✝ : Module R M
ι : Type u_1
b : Basis ι R M
κ : Type u_1
v : κ → M
i : LinearIndependent R v
val✝ : Infinite ι
⊢ (#κ) ≤ (#ι)
Theorem: CategoryTheory.Equivalence.inverse_asEquivalence
File: Mathlib/CategoryTheory/Equivalence.lean

tactic: cases E
state_before: C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
E : C ≌ D
⊢ asEquivalence E.inverse = symm E

tactic: congr
state_before: case mk'
C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
functor✝ : C ⥤ D
inverse✝ : D ⥤ C
unitIso✝ : 𝟭 C ≅ functor✝ ⋙ inverse✝
counitIso✝ : inverse✝ ⋙ functor✝ ≅ 𝟭 D
functor_unitIso_comp✝ :
  ∀ (X : C), functor✝.map (unitIso✝.hom.app X) ≫ counitIso✝.hom.app (functor✝.obj X) = 𝟙 (functor✝.obj X)
⊢ asEquivalence (mk' functor✝ inverse✝ unitIso✝ counitIso✝).inverse = symm (mk' functor✝ inverse✝ unitIso✝ counitIso✝)
Theorem: FreeGroup.Red.church_rosser
File: Mathlib/GroupTheory/FreeGroup.lean

tactic: rfl
state_before: α : Type u
L L₁ L₂ L₃ L₄ a b✝ c b : List (α × Bool)
hab hac : Step a b
⊢ ReflGen Step b b

tactic: rfl
state_before: α : Type u
L L₁ L₂ L₃ L₄ a b✝ c b : List (α × Bool)
hab hac : Step a b
⊢ ReflTransGen Step b b
Theorem: Real.cosh_three_mul
File: Mathlib/Data/Complex/Exponential.lean

tactic: rw [← ofReal_inj]
state_before: x y : ℝ
⊢ cosh (3 * x) = 4 * cosh x ^ 3 - 3 * cosh x

tactic: simp [cosh_three_mul]
state_before: x y : ℝ
⊢ ↑(cosh (3 * x)) = ↑(4 * cosh x ^ 3 - 3 * cosh x)
Theorem: Equiv.Perm.isCycleOn_empty
File: Mathlib/GroupTheory/Perm/Cycle/Basic.lean

tactic: simp [IsCycleOn, Set.bijOn_empty]
state_before: ι : Type ?u.1633030
α : Type u_1
β : Type ?u.1633036
f g : Perm α
s t : Set α
a b x y : α
⊢ IsCycleOn f ∅
Theorem: List.nodupKeys_join
File: Mathlib/Data/List/Sigma.lean

tactic: rw [nodupKeys_iff_pairwise, pairwise_join, pairwise_map]
state_before: α : Type u
β : α → Type v
l l₁ l₂ : List (Sigma β)
L : List (List (Sigma β))
⊢ NodupKeys (join L) ↔ (∀ (l : List (Sigma β)), l ∈ L → NodupKeys l) ∧ Pairwise Disjoint (map keys L)

tactic: refine' and_congr (ball_congr fun l _ => by simp [nodupKeys_iff_pairwise]) _
state_before: α : Type u
β : α → Type v
l l₁ l₂ : List (Sigma β)
L : List (List (Sigma β))
⊢ (∀ (l : List (Sigma β)), l ∈ L → Pairwise (fun s s' => s.fst ≠ s'.fst) l) ∧
      Pairwise (fun l₁ l₂ => ∀ (x : Sigma β), x ∈ l₁ → ∀ (y : Sigma β), y ∈ l₂ → x.fst ≠ y.fst) L ↔
    (∀ (l : List (Sigma β)), l ∈ L → NodupKeys l) ∧ Pairwise (fun a b => Disjoint (keys a) (keys b)) L

tactic: apply iff_of_eq
state_before: α : Type u
β : α → Type v
l l₁ l₂ : List (Sigma β)
L : List (List (Sigma β))
⊢ Pairwise (fun l₁ l₂ => ∀ (x : Sigma β), x ∈ l₁ → ∀ (y : Sigma β), y ∈ l₂ → x.fst ≠ y.fst) L ↔
    Pairwise (fun a b => Disjoint (keys a) (keys b)) L

tactic: congr with (l₁ l₂)
state_before: case a
α : Type u
β : α → Type v
l l₁ l₂ : List (Sigma β)
L : List (List (Sigma β))
⊢ Pairwise (fun l₁ l₂ => ∀ (x : Sigma β), x ∈ l₁ → ∀ (y : Sigma β), y ∈ l₂ → x.fst ≠ y.fst) L =
    Pairwise (fun a b => Disjoint (keys a) (keys b)) L

tactic: simp [keys, disjoint_iff_ne]
state_before: case a.e_R.h.h.a
α : Type u
β : α → Type v
l l₁✝ l₂✝ : List (Sigma β)
L : List (List (Sigma β))
l₁ l₂ : List (Sigma β)
⊢ (∀ (x : Sigma β), x ∈ l₁ → ∀ (y : Sigma β), y ∈ l₂ → x.fst ≠ y.fst) ↔ Disjoint (keys l₁) (keys l₂)

tactic: simp [nodupKeys_iff_pairwise]
state_before: α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
L : List (List (Sigma β))
l : List (Sigma β)
x✝ : l ∈ L
⊢ Pairwise (fun s s' => s.fst ≠ s'.fst) l ↔ NodupKeys l
Theorem: IsUnit.div_mul_cancel
File: Mathlib/Algebra/Hom/Units.lean

tactic: rw [div_eq_mul_inv, h.inv_mul_cancel_right]
state_before: F : Type ?u.53366
G : Type ?u.53369
α : Type u_1
M : Type ?u.53375
N : Type ?u.53378
inst✝ : DivisionMonoid α
a✝ b c : α
h : IsUnit b
a : α
⊢ a / b * b = a
Theorem: Nat.Linear.Poly.of_isZero
File: src/lean/Init/Data/Nat/Linear.lean

tactic: simp [isZero] at h
state_before: ctx : Context
p : Poly
h : isZero p = true
⊢ denote ctx p = 0

tactic: split at h
state_before: ctx : Context
p : Poly
h :
  (match p with
    | [] => true
    | x => false) =
    true
⊢ denote ctx p = 0

tactic: simp
state_before: case h_1
ctx : Context
p✝ : Poly
h : true = true
⊢ denote ctx [] = 0

tactic: contradiction
state_before: case h_2
ctx : Context
p p✝ : Poly
x✝ : p = [] → False
h : false = true
⊢ denote ctx p = 0
Theorem: Multiset.fold_add
File: Mathlib/Data/Multiset/Fold.lean

tactic: rw [add_zero, fold_zero, ← fold_cons'_right, ← fold_cons_right op]
state_before: α : Type u_1
β : Type ?u.8358
op : α → α → α
hc : IsCommutative α op
ha : IsAssociative α op
b₁ b₂ : α
s₁ s₂ : Multiset α
⊢ fold op (op b₁ b₂) (s₁ + 0) = op (fold op b₁ s₁) (fold op b₂ 0)

tactic: rw [fold_cons_left, add_cons, fold_cons_left, h, ← ha.assoc, hc.comm a,
ha.assoc]
state_before: α : Type u_1
β : Type ?u.8358
op : α → α → α
hc : IsCommutative α op
ha : IsAssociative α op
b₁ b₂ : α
s₁ s₂ : Multiset α
a : α
b : Multiset α
h : fold op (op b₁ b₂) (s₁ + b) = op (fold op b₁ s₁) (fold op b₂ b)
⊢ fold op (op b₁ b₂) (s₁ + a ::ₘ b) = op (fold op b₁ s₁) (fold op b₂ (a ::ₘ b))
Theorem: Ideal.map_isPrime_of_equiv
File: Mathlib/RingTheory/Ideal/Operations.lean

tactic: simp only [RingHom.ker_equiv, bot_le]
state_before: R : Type u_2
S : Type u_3
F : Type ?u.1964564
inst✝³ : Ring R
inst✝² : Ring S
rc : RingHomClass F R S
F' : Type u_1
inst✝¹ : RingEquivClass F' R S
f : F'
I : Ideal R
inst✝ : IsPrime I
⊢ RingHom.ker f ≤ I
Theorem: IsPreconnected.eqOn_const_of_mapsTo
File: Mathlib/Topology/Connected.lean

tactic: rcases S.eq_empty_or_nonempty with (rfl | ⟨x, hx⟩)
state_before: α : Type u
β : Type v
ι : Type ?u.150118
π : ι → Type ?u.150123
inst✝² : TopologicalSpace α
s t u v : Set α
inst✝¹ : TopologicalSpace β
S : Set α
hS : IsPreconnected S
T : Set β
inst✝ : DiscreteTopology ↑T
f : α → β
hc : ContinuousOn f S
hTm : MapsTo f S T
hne : Set.Nonempty T
⊢ ∃ y, y ∈ T ∧ EqOn f (const α y) S

tactic: exact hne.imp fun _ hy => ⟨hy, eqOn_empty _ _⟩
state_before: case inl
α : Type u
β : Type v
ι : Type ?u.150118
π : ι → Type ?u.150123
inst✝² : TopologicalSpace α
s t u v : Set α
inst✝¹ : TopologicalSpace β
T : Set β
inst✝ : DiscreteTopology ↑T
f : α → β
hne : Set.Nonempty T
hS : IsPreconnected ∅
hc : ContinuousOn f ∅
hTm : MapsTo f ∅ T
⊢ ∃ y, y ∈ T ∧ EqOn f (const α y) ∅

tactic: exact ⟨f x, hTm hx, fun x' hx' => hS.constant_of_mapsTo hc hTm hx' hx⟩
state_before: case inr.intro
α : Type u
β : Type v
ι : Type ?u.150118
π : ι → Type ?u.150123
inst✝² : TopologicalSpace α
s t u v : Set α
inst✝¹ : TopologicalSpace β
S : Set α
hS : IsPreconnected S
T : Set β
inst✝ : DiscreteTopology ↑T
f : α → β
hc : ContinuousOn f S
hTm : MapsTo f S T
hne : Set.Nonempty T
x : α
hx : x ∈ S
⊢ ∃ y, y ∈ T ∧ EqOn f (const α y) S
Theorem: Polynomial.Monic.mul_left_eq_zero_iff
File: Mathlib/Data/Polynomial/Monic.lean

tactic: by_cases hq : q = 0 <;> simp [h.mul_left_ne_zero, hq]
state_before: R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝ : Semiring R
p : R[X]
h : Monic p
q : R[X]
⊢ q * p = 0 ↔ q = 0
Theorem: inv_norm_smul_mem_closed_unit_ball
File: Mathlib/Analysis/NormedSpace/Basic.lean

tactic: simp only [mem_closedBall_zero_iff, norm_smul, norm_inv, norm_norm, ← _root_.div_eq_inv_mul,
  div_self_le_one]
state_before: α : Type ?u.9079
β : Type u_1
γ : Type ?u.9085
ι : Type ?u.9088
inst✝² : NormedField α
inst✝¹ : SeminormedAddCommGroup β
inst✝ : NormedSpace ℝ β
x : β
⊢ ‖x‖⁻¹ • x ∈ closedBall 0 1
Theorem: Algebra.TensorProduct.ext
File: Mathlib/RingTheory/TensorProduct.lean

tactic: apply @AlgHom.toLinearMap_injective R (A ⊗[R] B) C _ _ _ _ _ _ _ _
state_before: R : Type u
inst✝¹⁰ : CommSemiring R
A : Type v₁
inst✝⁹ : Semiring A
inst✝⁸ : Algebra R A
B : Type v₂
inst✝⁷ : Semiring B
inst✝⁶ : Algebra R B
S : Type ?u.721832
inst✝⁵ : CommSemiring S
inst✝⁴ : Algebra R S
inst✝³ : Algebra S A
inst✝² : IsScalarTower R S A
C : Type v₃
inst✝¹ : Semiring C
inst✝ : Algebra R C
g h : A ⊗[R] B →ₐ[R] C
H : ∀ (a : A) (b : B), ↑g (a ⊗ₜ[R] b) = ↑h (a ⊗ₜ[R] b)
⊢ g = h

tactic: ext
state_before: R : Type u
inst✝¹⁰ : CommSemiring R
A : Type v₁
inst✝⁹ : Semiring A
inst✝⁸ : Algebra R A
B : Type v₂
inst✝⁷ : Semiring B
inst✝⁶ : Algebra R B
S : Type ?u.721832
inst✝⁵ : CommSemiring S
inst✝⁴ : Algebra R S
inst✝³ : Algebra S A
inst✝² : IsScalarTower R S A
C : Type v₃
inst✝¹ : Semiring C
inst✝ : Algebra R C
g h : A ⊗[R] B →ₐ[R] C
H : ∀ (a : A) (b : B), ↑g (a ⊗ₜ[R] b) = ↑h (a ⊗ₜ[R] b)
⊢ AlgHom.toLinearMap g = AlgHom.toLinearMap h

tactic: simp [H]
state_before: case a.h.h
R : Type u
inst✝¹⁰ : CommSemiring R
A : Type v₁
inst✝⁹ : Semiring A
inst✝⁸ : Algebra R A
B : Type v₂
inst✝⁷ : Semiring B
inst✝⁶ : Algebra R B
S : Type ?u.721832
inst✝⁵ : CommSemiring S
inst✝⁴ : Algebra R S
inst✝³ : Algebra S A
inst✝² : IsScalarTower R S A
C : Type v₃
inst✝¹ : Semiring C
inst✝ : Algebra R C
g h : A ⊗[R] B →ₐ[R] C
H : ∀ (a : A) (b : B), ↑g (a ⊗ₜ[R] b) = ↑h (a ⊗ₜ[R] b)
x✝¹ : A
x✝ : B
⊢ ↑(↑(AlgebraTensorModule.curry (AlgHom.toLinearMap g)) x✝¹) x✝ =
    ↑(↑(AlgebraTensorModule.curry (AlgHom.toLinearMap h)) x✝¹) x✝
Theorem: Int.neg_lt_sub_left_of_lt_add
File: Std/Data/Int/Lemmas.lean

tactic: have h := Int.lt_neg_add_of_add_lt (Int.sub_left_lt_of_lt_add h)
state_before: a b c : Int
h : c < a + b
⊢ -a < b - c

tactic: rwa [Int.add_comm] at h
state_before: a b c : Int
h✝ : c < a + b
h : -a < -c + b
⊢ -a < b - c
Theorem: BotHom.cancel_left
File: Mathlib/Order/Hom/Bounded.lean

tactic: rw [← BotHom.comp_apply, h, BotHom.comp_apply]
state_before: F : Type ?u.48941
α : Type u_3
β : Type u_1
γ : Type u_2
δ : Type ?u.48953
inst✝³ : Bot α
inst✝² : Bot β
inst✝¹ : Bot γ
inst✝ : Bot δ
g : BotHom β γ
f₁ f₂ : BotHom α β
hg : Injective ↑g
h : comp g f₁ = comp g f₂
a : α
⊢ ↑g (↑f₁ a) = ↑g (↑f₂ a)
Theorem: one_lt_natDegree_of_irrational_root
File: Mathlib/Data/Real/Irrational.lean

tactic: by_contra rid
state_before: x : ℝ
p : ℤ[X]
hx : Irrational x
p_nonzero : p ≠ 0
x_is_root : ↑(aeval x) p = 0
⊢ 1 < natDegree p

tactic: rcases exists_eq_X_add_C_of_natDegree_le_one (not_lt.1 rid) with ⟨a, b, rfl⟩
state_before: x : ℝ
p : ℤ[X]
hx : Irrational x
p_nonzero : p ≠ 0
x_is_root : ↑(aeval x) p = 0
rid : ¬1 < natDegree p
⊢ False

tactic: clear rid
state_before: case intro.intro
x : ℝ
hx : Irrational x
a b : ℤ
p_nonzero : ↑C a * X + ↑C b ≠ 0
x_is_root : ↑(aeval x) (↑C a * X + ↑C b) = 0
rid : ¬1 < natDegree (↑C a * X + ↑C b)
⊢ False

tactic: have : (a : ℝ) * x = -b := by simpa [eq_neg_iff_add_eq_zero] using x_is_root
state_before: case intro.intro
x : ℝ
hx : Irrational x
a b : ℤ
p_nonzero : ↑C a * X + ↑C b ≠ 0
x_is_root : ↑(aeval x) (↑C a * X + ↑C b) = 0
⊢ False

tactic: rcases em (a = 0) with (rfl | ha)
state_before: case intro.intro
x : ℝ
hx : Irrational x
a b : ℤ
p_nonzero : ↑C a * X + ↑C b ≠ 0
x_is_root : ↑(aeval x) (↑C a * X + ↑C b) = 0
this : ↑a * x = -↑b
⊢ False

tactic: simpa [eq_neg_iff_add_eq_zero] using x_is_root
state_before: x : ℝ
hx : Irrational x
a b : ℤ
p_nonzero : ↑C a * X + ↑C b ≠ 0
x_is_root : ↑(aeval x) (↑C a * X + ↑C b) = 0
⊢ ↑a * x = -↑b

tactic: obtain rfl : b = 0 := by simpa
state_before: case intro.intro.inl
x : ℝ
hx : Irrational x
b : ℤ
p_nonzero : ↑C 0 * X + ↑C b ≠ 0
x_is_root : ↑(aeval x) (↑C 0 * X + ↑C b) = 0
this : ↑0 * x = -↑b
⊢ False

tactic: simp at p_nonzero
state_before: case intro.intro.inl
x : ℝ
hx : Irrational x
p_nonzero : ↑C 0 * X + ↑C 0 ≠ 0
x_is_root : ↑(aeval x) (↑C 0 * X + ↑C 0) = 0
this : ↑0 * x = -↑0
⊢ False

tactic: simpa
state_before: x : ℝ
hx : Irrational x
b : ℤ
p_nonzero : ↑C 0 * X + ↑C b ≠ 0
x_is_root : ↑(aeval x) (↑C 0 * X + ↑C b) = 0
this : ↑0 * x = -↑b
⊢ b = 0

tactic: rw [mul_comm, ← eq_div_iff_mul_eq, eq_comm] at this
state_before: case intro.intro.inr
x : ℝ
hx : Irrational x
a b : ℤ
p_nonzero : ↑C a * X + ↑C b ≠ 0
x_is_root : ↑(aeval x) (↑C a * X + ↑C b) = 0
this : ↑a * x = -↑b
ha : ¬a = 0
⊢ False

tactic: refine' hx ⟨-b / a, _⟩
state_before: case intro.intro.inr
x : ℝ
hx : Irrational x
a b : ℤ
p_nonzero : ↑C a * X + ↑C b ≠ 0
x_is_root : ↑(aeval x) (↑C a * X + ↑C b) = 0
this : -↑b / ↑a = x
ha : ¬a = 0
⊢ False

case intro.intro.inr
x : ℝ
hx : Irrational x
a b : ℤ
p_nonzero : ↑C a * X + ↑C b ≠ 0
x_is_root : ↑(aeval x) (↑C a * X + ↑C b) = 0
this : x * ↑a = -↑b
ha : ¬a = 0
⊢ ↑a ≠ 0

tactic: assumption_mod_cast
state_before: case intro.intro.inr
x : ℝ
hx : Irrational x
a b : ℤ
p_nonzero : ↑C a * X + ↑C b ≠ 0
x_is_root : ↑(aeval x) (↑C a * X + ↑C b) = 0
this : -↑b / ↑a = x
ha : ¬a = 0
⊢ ↑(-↑b / ↑a) = x

case intro.intro.inr
x : ℝ
hx : Irrational x
a b : ℤ
p_nonzero : ↑C a * X + ↑C b ≠ 0
x_is_root : ↑(aeval x) (↑C a * X + ↑C b) = 0
this : x * ↑a = -↑b
ha : ¬a = 0
⊢ ↑a ≠ 0

tactic: assumption_mod_cast
state_before: case intro.intro.inr
x : ℝ
hx : Irrational x
a b : ℤ
p_nonzero : ↑C a * X + ↑C b ≠ 0
x_is_root : ↑(aeval x) (↑C a * X + ↑C b) = 0
this : x * ↑a = -↑b
ha : ¬a = 0
⊢ ↑a ≠ 0
Theorem: Polynomial.map_eq_zero
File: Mathlib/Data/Polynomial/FieldDivision.lean

tactic: simp only [Polynomial.ext_iff]
state_before: R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝² : DivisionRing R
p q : R[X]
inst✝¹ : Semiring S
inst✝ : Nontrivial S
f : R →+* S
⊢ map f p = 0 ↔ p = 0

tactic: congr!
state_before: R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝² : DivisionRing R
p q : R[X]
inst✝¹ : Semiring S
inst✝ : Nontrivial S
f : R →+* S
⊢ (∀ (n : ℕ), coeff (map f p) n = coeff 0 n) ↔ ∀ (n : ℕ), coeff p n = coeff 0 n

tactic: simp [map_eq_zero, coeff_map, coeff_zero]
state_before: case a.h.a
R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝² : DivisionRing R
p q : R[X]
inst✝¹ : Semiring S
inst✝ : Nontrivial S
f : R →+* S
a✝ : ℕ
⊢ coeff (map f p) a✝ = coeff 0 a✝ ↔ coeff p a✝ = coeff 0 a✝
Theorem: contDiff_iff_iteratedDeriv
File: Mathlib/Analysis/Calculus/IteratedDeriv.lean

tactic: simp only [contDiff_iff_continuous_differentiable, iteratedFDeriv_eq_equiv_comp,
  LinearIsometryEquiv.comp_continuous_iff, LinearIsometryEquiv.comp_differentiable_iff]
state_before: 𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type u_2
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type ?u.124644
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
n✝ : ℕ
f : 𝕜 → F
s : Set 𝕜
x : 𝕜
n : ℕ∞
⊢ ContDiff 𝕜 n f ↔
    (∀ (m : ℕ), ↑m ≤ n → Continuous (iteratedDeriv m f)) ∧ ∀ (m : ℕ), ↑m < n → Differentiable 𝕜 (iteratedDeriv m f)
Theorem: Relation.comp_iff
File: Mathlib/Logic/Relation.lean

tactic: rw [this, comp_eq]
state_before: α : Type u_1
β : Type ?u.11378
γ : Type ?u.11381
δ : Type ?u.11384
r✝ : α → β → Prop
p : β → γ → Prop
q : γ → δ → Prop
r : α → Prop → Prop
this : (fun x x_1 => x ↔ x_1) = fun x x_1 => x = x_1
⊢ (r ∘r fun x x_1 => x ↔ x_1) = r

tactic: funext a b
state_before: α : Type u_1
β : Type ?u.11378
γ : Type ?u.11381
δ : Type ?u.11384
r✝ : α → β → Prop
p : β → γ → Prop
q : γ → δ → Prop
r : α → Prop → Prop
⊢ (fun x x_1 => x ↔ x_1) = fun x x_1 => x = x_1

tactic: exact iff_eq_eq
state_before: case h.h
α : Type u_1
β : Type ?u.11378
γ : Type ?u.11381
δ : Type ?u.11384
r✝ : α → β → Prop
p : β → γ → Prop
q : γ → δ → Prop
r : α → Prop → Prop
a b : Prop
⊢ (a ↔ b) = (a = b)
Theorem: Filter.isBounded_principal
File: Mathlib/Order/LiminfLimsup.lean

tactic: simp [IsBounded, subset_def]
state_before: α : Type u_1
β : Type ?u.5475
γ : Type ?u.5478
ι : Type ?u.5481
r : α → α → Prop
f g : Filter α
s : Set α
⊢ IsBounded r (𝓟 s) ↔ ∃ t, ∀ (x : α), x ∈ s → r x t
Theorem: Part.some_mod_some
File: Mathlib/Data/Part.lean

tactic: simp [mod_def]
state_before: α : Type u_1
β : Type ?u.73852
γ : Type ?u.73855
inst✝ : Mod α
a b : α
⊢ some a % some b = some (a % b)
Theorem: LipschitzWith.compLp_zero
File: Mathlib/MeasureTheory/Function/LpSpace.lean

tactic: rw [Lp.eq_zero_iff_ae_eq_zero]
state_before: α : Type u_3
E : Type u_1
F : Type u_2
G : Type ?u.2123310
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : MeasureTheory.Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
g : E → F
c : ℝ≥0
hg : LipschitzWith c g
g0 : g 0 = 0
⊢ compLp hg g0 0 = 0

tactic: apply (coeFn_compLp _ _ _).trans
state_before: α : Type u_3
E : Type u_1
F : Type u_2
G : Type ?u.2123310
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : MeasureTheory.Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
g : E → F
c : ℝ≥0
hg : LipschitzWith c g
g0 : g 0 = 0
⊢ ↑↑(compLp hg g0 0) =ᵐ[μ] 0

tactic: filter_upwards [Lp.coeFn_zero E p μ] with _ ha
state_before: α : Type u_3
E : Type u_1
F : Type u_2
G : Type ?u.2123310
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : MeasureTheory.Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
g : E → F
c : ℝ≥0
hg : LipschitzWith c g
g0 : g 0 = 0
⊢ g ∘ ↑↑0 =ᵐ[μ] 0

tactic: simp only [ha, g0, Function.comp_apply, Pi.zero_apply]
state_before: case h
α : Type u_3
E : Type u_1
F : Type u_2
G : Type ?u.2123310
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : MeasureTheory.Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
g : E → F
c : ℝ≥0
hg : LipschitzWith c g
g0 : g 0 = 0
a✝ : α
ha : ↑↑0 a✝ = OfNat.ofNat 0 a✝
⊢ (g ∘ ↑↑0) a✝ = OfNat.ofNat 0 a✝
Theorem: beq_self_eq_true'
File: src/lean/Init/SimpLemmas.lean

tactic: simp [BEq.beq]
state_before: α : Type u_1
inst✝ : DecidableEq α
a : α
⊢ (a == a) = true
Theorem: Set.singleton_vsub_self
File: Mathlib/Algebra/AddTorsor.lean

tactic: rw [Set.singleton_vsub_singleton, vsub_self]
state_before: G : Type u_1
P : Type u_2
inst✝ : AddGroup G
T : AddTorsor G P
p : P
⊢ {p} -ᵥ {p} = {0}
Theorem: Nat.bit1_lt_bit0
File: Mathlib/Init/Data/Nat/Lemmas.lean

tactic: rw [succ_add]
state_before: n m : ℕ
h : n < succ m
this✝ : n ≤ m
this : succ (n + n) ≤ succ (m + m)
⊢ succ (n + n) ≤ succ m + m

tactic: assumption
state_before: n m : ℕ
h : n < succ m
this✝ : n ≤ m
this : succ (n + n) ≤ succ (m + m)
⊢ succ (n + n) ≤ succ (m + m)
Theorem: AddCommGroup.add_nsmul_modEq
File: Mathlib/Algebra/ModEq.lean

tactic: simp
state_before: α : Type u_1
inst✝ : AddCommGroup α
p a a₁ a₂ b b₁ b₂ c : α
n✝ : ℕ
z : ℤ
n : ℕ
⊢ a - (a + n • p) = -↑n • p
Theorem: Function.invFun_eq_of_injective_of_rightInverse
File: Mathlib/Logic/Function/Basic.lean

tactic: rw [hg b]
state_before: α : Sort u_1
β : Sort u_2
inst✝ : Nonempty α
f : α → β
a : α
b✝ : β
g : β → α
hf : Injective f
hg : RightInverse g f
b : β
⊢ f (invFun f b) = f (g b)

tactic: exact invFun_eq ⟨g b, hg b⟩
state_before: α : Sort u_1
β : Sort u_2
inst✝ : Nonempty α
f : α → β
a : α
b✝ : β
g : β → α
hf : Injective f
hg : RightInverse g f
b : β
⊢ f (invFun f b) = b
Theorem: mem_nhdsWithin_Iic_iff_exists_Icc_subset
File: Mathlib/Topology/Order/Basic.lean

tactic: simp only [dual_Icc]
state_before: α : Type u
β : Type v
γ : Type w
inst✝⁴ : TopologicalSpace α
inst✝³ : LinearOrder α
inst✝² : OrderTopology α
inst✝¹ : NoMinOrder α
inst✝ : DenselyOrdered α
a : α
s : Set α
⊢ (∃ u, ↑toDual a < ↑toDual u ∧ Icc (↑toDual a) (↑toDual u) ⊆ ↑ofDual ⁻¹' s) ↔ ∃ l, l < a ∧ Icc l a ⊆ s

tactic: rfl
state_before: α : Type u
β : Type v
γ : Type w
inst✝⁴ : TopologicalSpace α
inst✝³ : LinearOrder α
inst✝² : OrderTopology α
inst✝¹ : NoMinOrder α
inst✝ : DenselyOrdered α
a : α
s : Set α
⊢ (∃ u, ↑toDual a < ↑toDual u ∧ ↑ofDual ⁻¹' Icc u a ⊆ ↑ofDual ⁻¹' s) ↔ ∃ l, l < a ∧ Icc l a ⊆ s
Theorem: BoxIntegral.Prepartition.exists_iUnion_eq_diff
File: Mathlib/Analysis/BoxIntegral/Partition/Split.lean

tactic: rcases π.eventually_splitMany_inf_eq_filter.exists with ⟨s, hs⟩
state_before: ι : Type u_1
M : Type ?u.56100
n : ℕ
I J : Box ι
i : ι
x : ℝ
inst✝ : Finite ι
π : Prepartition I
⊢ ∃ π', Prepartition.iUnion π' = ↑I \ Prepartition.iUnion π

tactic: use (splitMany I s).filter fun J => ¬(J : Set (ι → ℝ)) ⊆ π.iUnion
state_before: case intro
ι : Type u_1
M : Type ?u.56100
n : ℕ
I J : Box ι
i : ι
x : ℝ
inst✝ : Finite ι
π : Prepartition I
s : Finset (ι × ℝ)
hs : π ⊓ splitMany I s = filter (splitMany I s) fun J => ↑J ⊆ Prepartition.iUnion π
⊢ ∃ π', Prepartition.iUnion π' = ↑I \ Prepartition.iUnion π

tactic: simp [← hs]
state_before: case intro
ι : Type u_1
M : Type ?u.56100
n : ℕ
I J : Box ι
i : ι
x : ℝ
inst✝ : Finite ι
π : Prepartition I
s : Finset (ι × ℝ)
hs : π ⊓ splitMany I s = filter (splitMany I s) fun J => ↑J ⊆ Prepartition.iUnion π
⊢ Prepartition.iUnion (filter (splitMany I s) fun J => ¬↑J ⊆ Prepartition.iUnion π) = ↑I \ Prepartition.iUnion π
Theorem: Polynomial.taylor_zero'
File: Mathlib/Data/Polynomial/Taylor.lean

tactic: ext
state_before: R : Type u_1
inst✝ : Semiring R
r : R
f : R[X]
⊢ taylor 0 = LinearMap.id

tactic: simp only [taylor_apply, add_zero, comp_X, _root_.map_zero, LinearMap.id_comp,
  Function.comp_apply, LinearMap.coe_comp]
state_before: case h.h.a
R : Type u_1
inst✝ : Semiring R
r : R
f : R[X]
n✝¹ n✝ : ℕ
⊢ coeff (↑(LinearMap.comp (taylor 0) (monomial n✝¹)) 1) n✝ = coeff (↑(LinearMap.comp LinearMap.id (monomial n✝¹)) 1) n✝