tasksource/leandojo huggingface dataset:
Theorem: map_eq_bot_iff
File: Mathlib/Order/Hom/Bounded.lean

tactic: letI : BotHomClass F α β := OrderIsoClass.toBotHomClass
state_before: F : Type u_3
α : Type u_1
β : Type u_2
γ : Type ?u.7624
δ : Type ?u.7627
inst✝⁴ : LE α
inst✝³ : OrderBot α
inst✝² : PartialOrder β
inst✝¹ : OrderBot β
inst✝ : OrderIsoClass F α β
f : F
a : α
⊢ ↑f a = ⊥ ↔ a = ⊥

tactic: rw [← map_bot f, (EquivLike.injective f).eq_iff]
state_before: F : Type u_3
α : Type u_1
β : Type u_2
γ : Type ?u.7624
δ : Type ?u.7627
inst✝⁴ : LE α
inst✝³ : OrderBot α
inst✝² : PartialOrder β
inst✝¹ : OrderBot β
inst✝ : OrderIsoClass F α β
f : F
a : α
this : BotHomClass F α β := OrderIsoClass.toBotHomClass
⊢ ↑f a = ⊥ ↔ a = ⊥
Theorem: Cardinal.aleph0_lt_lift
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: rw [← lift_aleph0.{u,v}, lift_lt]
state_before: α β : Type u
c : Cardinal
⊢ ℵ₀ < lift c ↔ ℵ₀ < c
Theorem: zero_zpow
File: Mathlib/Algebra/GroupWithZero/Power.lean

tactic: rw [zpow_ofNat, zero_pow']
state_before: G₀ : Type u_1
inst✝ : GroupWithZero G₀
n : ℕ
h : ↑n ≠ 0
⊢ 0 ^ ↑n = 0

tactic: simpa using h
state_before: case a
G₀ : Type u_1
inst✝ : GroupWithZero G₀
n : ℕ
h : ↑n ≠ 0
⊢ n ≠ 0

tactic: simp
state_before: G₀ : Type u_1
inst✝ : GroupWithZero G₀
n : ℕ
x✝ : -[n+1] ≠ 0
⊢ 0 ^ -[n+1] = 0
Theorem: List.eraseP_append_left
File: Std/Data/List/Lemmas.lean

tactic: by_cases h' : p x <;> simp [h']
state_before: α : Type u_1
p : α → Bool
a : α
pa : p a = true
x : α
xs l₂ : List α
h : a ∈ x :: xs
⊢ eraseP p (x :: xs ++ l₂) = eraseP p (x :: xs) ++ l₂

tactic: rw [eraseP_append_left pa l₂ ((mem_cons.1 h).resolve_left (mt _ h'))]
state_before: case neg
α : Type u_1
p : α → Bool
a : α
pa : p a = true
x : α
xs l₂ : List α
h : a ∈ x :: xs
h' : ¬p x = true
⊢ eraseP p (xs ++ l₂) = eraseP p xs ++ l₂

tactic: intro | rfl => exact pa
state_before: α : Type u_1
p : α → Bool
a : α
pa : p a = true
x : α
xs l₂ : List α
h : a ∈ x :: xs
h' : ¬p x = true
⊢ a = x → p x = true

tactic: exact pa
state_before: α : Type u_1
p : α → Bool
a : α
pa : p a = true
x : α
xs l₂ : List α
x✝ : a = x
h : a ∈ a :: xs
h' : ¬p a = true
⊢ p a = true
Theorem: MeasureTheory.Measure.haar.haarContent_self
File: Mathlib/MeasureTheory/Measure/Haar/Basic.lean

tactic: simp_rw [← ENNReal.coe_one, haarContent_apply, ENNReal.coe_eq_coe, chaar_self]
state_before: G : Type u_1
inst✝³ : Group G
inst✝² : TopologicalSpace G
inst✝¹ : TopologicalGroup G
inst✝ : T2Space G
K₀ : PositiveCompacts G
⊢ (fun s => ↑(Content.toFun (haarContent K₀) s)) K₀.toCompacts = 1

tactic: rfl
state_before: G : Type u_1
inst✝³ : Group G
inst✝² : TopologicalSpace G
inst✝¹ : TopologicalGroup G
inst✝ : T2Space G
K₀ : PositiveCompacts G
⊢ { val := 1, property := (_ : (fun r => 0 ≤ r) 1) } = 1
Theorem: Dfinsupp.erase_ne
File: Mathlib/Data/Dfinsupp/Basic.lean

tactic: simp [h]
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝ : (i : ι) → Zero (β i)
s : Finset ι
x : (i : ↑↑s) → β ↑i
i✝ i i' : ι
f : Π₀ (i : ι), β i
h : i' ≠ i
⊢ ↑(erase i f) i' = ↑f i'
Theorem: IsGLB.mul_left
File: Mathlib/Algebra/Order/Field/Basic.lean

tactic: rcases lt_or_eq_of_le ha with (ha | rfl)
state_before: ι : Type ?u.130842
α : Type u_1
β : Type ?u.130848
inst✝ : LinearOrderedSemifield α
a b c d e : α
m n : ℤ
s : Set α
ha : 0 ≤ a
hs : IsGLB s b
⊢ IsGLB ((fun b => a * b) '' s) (a * b)

tactic: exact (OrderIso.mulLeft₀ _ ha).isGLB_image'.2 hs
state_before: case inl
ι : Type ?u.130842
α : Type u_1
β : Type ?u.130848
inst✝ : LinearOrderedSemifield α
a b c d e : α
m n : ℤ
s : Set α
ha✝ : 0 ≤ a
hs : IsGLB s b
ha : 0 < a
⊢ IsGLB ((fun b => a * b) '' s) (a * b)

tactic: simp_rw [zero_mul]
state_before: case inr
ι : Type ?u.130842
α : Type u_1
β : Type ?u.130848
inst✝ : LinearOrderedSemifield α
b c d e : α
m n : ℤ
s : Set α
hs : IsGLB s b
ha : 0 ≤ 0
⊢ IsGLB ((fun b => 0 * b) '' s) (0 * b)

tactic: rw [hs.nonempty.image_const]
state_before: case inr
ι : Type ?u.130842
α : Type u_1
β : Type ?u.130848
inst✝ : LinearOrderedSemifield α
b c d e : α
m n : ℤ
s : Set α
hs : IsGLB s b
ha : 0 ≤ 0
⊢ IsGLB ((fun a => 0) '' s) 0

tactic: exact isGLB_singleton
state_before: case inr
ι : Type ?u.130842
α : Type u_1
β : Type ?u.130848
inst✝ : LinearOrderedSemifield α
b c d e : α
m n : ℤ
s : Set α
hs : IsGLB s b
ha : 0 ≤ 0
⊢ IsGLB {0} 0
Theorem: Multiset.noncommFoldr_eq_foldr
File: Mathlib/Data/Finset/NoncommProd.lean

tactic: induction s using Quotient.inductionOn
state_before: F : Type ?u.2925
ι : Type ?u.2928
α : Type u_1
β : Type u_2
γ : Type ?u.2937
f : α → β → β
op : α → α → α
s : Multiset α
h : LeftCommutative f
b : β
⊢ noncommFoldr f s
      (_ : ∀ (x : α), x ∈ {x | x ∈ s} → ∀ (y : α), y ∈ {x | x ∈ s} → x ≠ y → ∀ (b : β), f x (f y b) = f y (f x b)) b =
    foldr f h b s

tactic: simp
state_before: case h
F : Type ?u.2925
ι : Type ?u.2928
α : Type u_1
β : Type u_2
γ : Type ?u.2937
f : α → β → β
op : α → α → α
h : LeftCommutative f
b : β
a✝ : List α
⊢ noncommFoldr f (Quotient.mk (List.isSetoid α) a✝)
      (_ :
        ∀ (x : α),
          x ∈ {x | x ∈ Quotient.mk (List.isSetoid α) a✝} →
            ∀ (y : α), y ∈ {x | x ∈ Quotient.mk (List.isSetoid α) a✝} → x ≠ y → ∀ (b : β), f x (f y b) = f y (f x b))
      b =
    foldr f h b (Quotient.mk (List.isSetoid α) a✝)
Theorem: Int.cast_abs
File: Mathlib/Data/Int/Cast/Lemmas.lean

tactic: simp [abs_eq_max_neg]
state_before: F : Type ?u.20890
ι : Type ?u.20893
α : Type u_1
β : Type ?u.20899
inst✝ : LinearOrderedRing α
a b n : ℤ
⊢ ↑(abs a) = abs ↑a
Theorem: Set.iUnion_Icc_left
File: Mathlib/Data/Set/Intervals/Disjoint.lean

tactic: simp only [← Ici_inter_Iic, ← iUnion_inter, iUnion_Ici, univ_inter]
state_before: ι : Sort u
α : Type v
β : Type w
inst✝ : Preorder α
a b✝ c b : α
⊢ (⋃ (a : α), Icc a b) = Iic b
Theorem: Nat.one_lt_cast
File: Mathlib/Data/Nat/Cast/Basic.lean

tactic: rw [← cast_one, cast_lt]
state_before: α : Type u_1
β : Type ?u.17835
inst✝¹ : OrderedSemiring α
inst✝ : CharZero α
m n : ℕ
⊢ 1 < ↑n ↔ 1 < n
Theorem: Algebra.eq_top_iff
File: Mathlib/Algebra/Algebra/Subalgebra/Basic.lean

tactic: rw [h]
state_before: R : Type u
A : Type v
B : Type w
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Algebra R A
inst✝¹ : Semiring B
inst✝ : Algebra R B
S : Subalgebra R A
h : S = ⊤
x : A
⊢ x ∈ S

tactic: exact mem_top
state_before: R : Type u
A : Type v
B : Type w
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Algebra R A
inst✝¹ : Semiring B
inst✝ : Algebra R B
S : Subalgebra R A
h : S = ⊤
x : A
⊢ x ∈ ⊤

tactic: ext x
state_before: R : Type u
A : Type v
B : Type w
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Algebra R A
inst✝¹ : Semiring B
inst✝ : Algebra R B
S : Subalgebra R A
h : ∀ (x : A), x ∈ S
⊢ S = ⊤

tactic: exact ⟨fun _ => mem_top, fun _ => h x⟩
state_before: case h
R : Type u
A : Type v
B : Type w
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Algebra R A
inst✝¹ : Semiring B
inst✝ : Algebra R B
S : Subalgebra R A
h : ∀ (x : A), x ∈ S
x : A
⊢ x ∈ S ↔ x ∈ ⊤
Theorem: SimpleGraph.Walk.subset_support_append_left
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: simp only [Walk.support_append, List.subset_append_left]
state_before: V✝ : Type u
V' : Type v
V'' : Type w
G✝ : SimpleGraph V✝
G' : SimpleGraph V'
G'' : SimpleGraph V''
V : Type u
G : SimpleGraph V
u v w : V
p : Walk G u v
q : Walk G v w
⊢ support p ⊆ support (append p q)
Theorem: newton_seq_dist
File: Mathlib/NumberTheory/Padics/Hensel.lean

tactic: have hex : ∃ m, k = n + m := exists_eq_add_of_le hnk
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
F : Polynomial ℤ_[p]
a : ℤ_[p]
hnorm : ‖Polynomial.eval a F‖ < ‖Polynomial.eval a (↑Polynomial.derivative F)‖ ^ 2
hnsol : Polynomial.eval a F ≠ 0
n k : ℕ
hnk : n ≤ k
⊢ ‖newton_seq k - newton_seq n‖ ≤ ‖Polynomial.eval a (↑Polynomial.derivative F)‖ * T_gen p F a ^ 2 ^ n

tactic: let ⟨_, hex'⟩ := hex
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
F : Polynomial ℤ_[p]
a : ℤ_[p]
hnorm : ‖Polynomial.eval a F‖ < ‖Polynomial.eval a (↑Polynomial.derivative F)‖ ^ 2
hnsol : Polynomial.eval a F ≠ 0
n k : ℕ
hnk : n ≤ k
hex : ∃ m, k = n + m
⊢ ‖newton_seq k - newton_seq n‖ ≤ ‖Polynomial.eval a (↑Polynomial.derivative F)‖ * T_gen p F a ^ 2 ^ n

tactic: rw [hex']
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
F : Polynomial ℤ_[p]
a : ℤ_[p]
hnorm : ‖Polynomial.eval a F‖ < ‖Polynomial.eval a (↑Polynomial.derivative F)‖ ^ 2
hnsol : Polynomial.eval a F ≠ 0
n k : ℕ
hnk : n ≤ k
hex : ∃ m, k = n + m
w✝ : ℕ
hex' : k = n + w✝
⊢ ‖newton_seq k - newton_seq n‖ ≤ ‖Polynomial.eval a (↑Polynomial.derivative F)‖ * T_gen p F a ^ 2 ^ n

tactic: apply newton_seq_dist_aux
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
F : Polynomial ℤ_[p]
a : ℤ_[p]
hnorm : ‖Polynomial.eval a F‖ < ‖Polynomial.eval a (↑Polynomial.derivative F)‖ ^ 2
hnsol : Polynomial.eval a F ≠ 0
n k : ℕ
hnk : n ≤ k
hex : ∃ m, k = n + m
w✝ : ℕ
hex' : k = n + w✝
⊢ ‖newton_seq (n + w✝) - newton_seq n‖ ≤ ‖Polynomial.eval a (↑Polynomial.derivative F)‖ * T_gen p F a ^ 2 ^ n
Theorem: Polynomial.taylor_C
File: Mathlib/Data/Polynomial/Taylor.lean

tactic: simp only [taylor_apply, C_comp]
state_before: R : Type u_1
inst✝ : Semiring R
r : R
f : R[X]
x : R
⊢ ↑(taylor r) (↑C x) = ↑C x
Theorem: ZMod.nat_cast_self'
File: Mathlib/Data/ZMod/Basic.lean

tactic: rw [← Nat.cast_add_one, nat_cast_self (n + 1)]
state_before: n : ℕ
⊢ ↑n + 1 = 0
Theorem: MvPolynomial.coeff_eq_zero_of_totalDegree_lt
File: Mathlib/Data/MvPolynomial/Variables.lean

tactic: rw [totalDegree, Finset.sup_lt_iff] at h
state_before: R : Type u
S : Type v
σ : Type u_1
τ : Type ?u.477178
r : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝ : CommSemiring R
p q f : MvPolynomial σ R
d : σ →₀ ℕ
h : totalDegree f < ∑ i in d.support, ↑d i
⊢ coeff d f = 0

tactic: specialize h d
state_before: R : Type u
S : Type v
σ : Type u_1
τ : Type ?u.477178
r : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝ : CommSemiring R
p q f : MvPolynomial σ R
d : σ →₀ ℕ
h : ∀ (b : σ →₀ ℕ), b ∈ support f → (sum b fun x e => e) < ∑ i in d.support, ↑d i
⊢ coeff d f = 0

tactic: rw [mem_support_iff] at h
state_before: R : Type u
S : Type v
σ : Type u_1
τ : Type ?u.477178
r : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝ : CommSemiring R
p q f : MvPolynomial σ R
d : σ →₀ ℕ
h : d ∈ support f → (sum d fun x e => e) < ∑ i in d.support, ↑d i
⊢ coeff d f = 0

tactic: refine' not_not.mp (mt h _)
state_before: R : Type u
S : Type v
σ : Type u_1
τ : Type ?u.477178
r : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝ : CommSemiring R
p q f : MvPolynomial σ R
d : σ →₀ ℕ
h : coeff d f ≠ 0 → (sum d fun x e => e) < ∑ i in d.support, ↑d i
⊢ coeff d f = 0

tactic: exact lt_irrefl _
state_before: R : Type u
S : Type v
σ : Type u_1
τ : Type ?u.477178
r : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝ : CommSemiring R
p q f : MvPolynomial σ R
d : σ →₀ ℕ
h : coeff d f ≠ 0 → (sum d fun x e => e) < ∑ i in d.support, ↑d i
⊢ ¬(sum d fun x e => e) < ∑ i in d.support, ↑d i

tactic: exact lt_of_le_of_lt (Nat.zero_le _) h
state_before: R : Type u
S : Type v
σ : Type u_1
τ : Type ?u.477178
r : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝ : CommSemiring R
p q f : MvPolynomial σ R
d : σ →₀ ℕ
h : (Finset.sup (support f) fun s => sum s fun x e => e) < ∑ i in d.support, ↑d i
⊢ ⊥ < ∑ i in d.support, ↑d i
Theorem: CategoryTheory.tensorLeftHomEquiv_symm_naturality
File: Mathlib/CategoryTheory/Monoidal/Rigid/Basic.lean

tactic: dsimp [tensorLeftHomEquiv]
state_before: C : Type u₁
inst✝² : Category C
inst✝¹ : MonoidalCategory C
X X' Y Y' Z : C
inst✝ : ExactPairing Y Y'
f : X ⟶ X'
g : X' ⟶ Y ⊗ Z
⊢ ↑(tensorLeftHomEquiv X Y Y' Z).symm (f ≫ g) = (𝟙 Y' ⊗ f) ≫ ↑(tensorLeftHomEquiv X' Y Y' Z).symm g

tactic: simp only [id_tensor_comp, Category.assoc]
state_before: C : Type u₁
inst✝² : Category C
inst✝¹ : MonoidalCategory C
X X' Y Y' Z : C
inst✝ : ExactPairing Y Y'
f : X ⟶ X'
g : X' ⟶ Y ⊗ Z
⊢ (𝟙 Y' ⊗ f ≫ g) ≫ (α_ Y' Y Z).inv ≫ (ε_ Y Y' ⊗ 𝟙 Z) ≫ (λ_ Z).hom =
    (𝟙 Y' ⊗ f) ≫ (𝟙 Y' ⊗ g) ≫ (α_ Y' Y Z).inv ≫ (ε_ Y Y' ⊗ 𝟙 Z) ≫ (λ_ Z).hom
Theorem: Nat.mul_sub_left_distrib
File: src/lean/Init/Data/Nat/Basic.lean

tactic: rw [Nat.mul_comm, Nat.mul_sub_right_distrib, Nat.mul_comm m n, Nat.mul_comm n k]
state_before: n m k : Nat
⊢ n * (m - k) = n * m - n * k
Theorem: HasStrictFDerivAt.const_sub
File: Mathlib/Analysis/Calculus/FDeriv/Add.lean

tactic: simpa only [sub_eq_add_neg] using hf.neg.const_add c
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.527248
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.527343
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
hf : HasStrictFDerivAt f f' x
c : F
⊢ HasStrictFDerivAt (fun x => c - f x) (-f') x
Theorem: HomogeneousIdeal.toIdeal_injective
File: Mathlib/RingTheory/GradedAlgebra/HomogeneousIdeal.lean

tactic: simp [h]
state_before: ι : Type u_2
σ : Type u_3
R : Type ?u.8097
A : Type u_1
inst✝⁵ : Semiring A
inst✝⁴ : SetLike σ A
inst✝³ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝² : DecidableEq ι
inst✝¹ : AddMonoid ι
inst✝ : GradedRing 𝒜
I : Ideal A
x✝¹ x✝ : HomogeneousIdeal 𝒜
x : Submodule A A
hx : Ideal.IsHomogeneous 𝒜 x
y : Submodule A A
hy : Ideal.IsHomogeneous 𝒜 y
h : x = y
⊢ { toSubmodule := x, is_homogeneous' := hx } = { toSubmodule := y, is_homogeneous' := hy }
Theorem: IsOpen.lowerSemicontinuous_indicator
File: Mathlib/Topology/Semicontinuous.lean

tactic: intro x z hz
state_before: α : Type u_1
inst✝² : TopologicalSpace α
β : Type u_2
inst✝¹ : Preorder β
f g : α → β
x : α
s t : Set α
y z : β
inst✝ : Zero β
hs : IsOpen s
hy : 0 ≤ y
⊢ LowerSemicontinuous (indicator s fun _x => y)

tactic: by_cases h : x ∈ s <;> simp [h] at hz
state_before: α : Type u_1
inst✝² : TopologicalSpace α
β : Type u_2
inst✝¹ : Preorder β
f g : α → β
x✝ : α
s t : Set α
y z✝ : β
inst✝ : Zero β
hs : IsOpen s
hy : 0 ≤ y
x : α
z : β
hz : z < indicator s (fun _x => y) x
⊢ ∀ᶠ (x' : α) in 𝓝 x, z < indicator s (fun _x => y) x'

tactic: filter_upwards [hs.mem_nhds h]
state_before: case pos
α : Type u_1
inst✝² : TopologicalSpace α
β : Type u_2
inst✝¹ : Preorder β
f g : α → β
x✝ : α
s t : Set α
y z✝ : β
inst✝ : Zero β
hs : IsOpen s
hy : 0 ≤ y
x : α
z : β
h : x ∈ s
hz : z < y
⊢ ∀ᶠ (x' : α) in 𝓝 x, z < indicator s (fun _x => y) x'

tactic: simp (config := { contextual := true }) [hz]
state_before: case h
α : Type u_1
inst✝² : TopologicalSpace α
β : Type u_2
inst✝¹ : Preorder β
f g : α → β
x✝ : α
s t : Set α
y z✝ : β
inst✝ : Zero β
hs : IsOpen s
hy : 0 ≤ y
x : α
z : β
h : x ∈ s
hz : z < y
⊢ ∀ (a : α), a ∈ s → z < indicator s (fun _x => y) a

tactic: refine Filter.eventually_of_forall fun x' => ?_
state_before: case neg
α : Type u_1
inst✝² : TopologicalSpace α
β : Type u_2
inst✝¹ : Preorder β
f g : α → β
x✝ : α
s t : Set α
y z✝ : β
inst✝ : Zero β
hs : IsOpen s
hy : 0 ≤ y
x : α
z : β
h : ¬x ∈ s
hz : z < 0
⊢ ∀ᶠ (x' : α) in 𝓝 x, z < indicator s (fun _x => y) x'

tactic: by_cases h' : x' ∈ s <;> simp [h', hz.trans_le hy, hz]
state_before: case neg
α : Type u_1
inst✝² : TopologicalSpace α
β : Type u_2
inst✝¹ : Preorder β
f g : α → β
x✝ : α
s t : Set α
y z✝ : β
inst✝ : Zero β
hs : IsOpen s
hy : 0 ≤ y
x : α
z : β
h : ¬x ∈ s
hz : z < 0
x' : α
⊢ z < indicator s (fun _x => y) x'
Theorem: rothNumberNat_isBigOWith_id
File: Mathlib/Combinatorics/Additive/SalemSpencer.lean

tactic: simpa only [Real.norm_coe_nat, Nat.cast_le] using rothNumberNat_le
state_before: F : Type ?u.197857
α : Type ?u.197860
β : Type ?u.197863
𝕜 : Type ?u.197866
E : Type ?u.197869
s : Finset ℕ
k n : ℕ
⊢ ∀ (x : ℕ), ‖↑(↑rothNumberNat x)‖ ≤ ‖↑x‖
Theorem: Basis.index_nonempty
File: Mathlib/LinearAlgebra/Basis.lean

tactic: obtain ⟨x, y, ne⟩ : ∃ x y : M, x ≠ y := Nontrivial.exists_pair_ne
state_before: ι : Type u_1
ι' : Type ?u.464205
R : Type u_2
R₂ : Type ?u.464211
K : Type ?u.464214
M : Type u_3
M' : Type ?u.464220
M'' : Type ?u.464223
V : Type u
V' : Type ?u.464228
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
b : Basis ι R M
inst✝ : Nontrivial M
⊢ Nonempty ι

tactic: obtain ⟨i, _⟩ := not_forall.mp (mt b.ext_elem_iff.2 ne)
state_before: case intro.intro
ι : Type u_1
ι' : Type ?u.464205
R : Type u_2
R₂ : Type ?u.464211
K : Type ?u.464214
M : Type u_3
M' : Type ?u.464220
M'' : Type ?u.464223
V : Type u
V' : Type ?u.464228
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
b : Basis ι R M
inst✝ : Nontrivial M
x y : M
ne : x ≠ y
⊢ Nonempty ι

tactic: exact ⟨i⟩
state_before: case intro.intro.intro
ι : Type u_1
ι' : Type ?u.464205
R : Type u_2
R₂ : Type ?u.464211
K : Type ?u.464214
M : Type u_3
M' : Type ?u.464220
M'' : Type ?u.464223
V : Type u
V' : Type ?u.464228
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
b : Basis ι R M
inst✝ : Nontrivial M
x y : M
ne : x ≠ y
i : ι
h✝ : ¬↑(↑b.repr x) i = ↑(↑b.repr y) i
⊢ Nonempty ι
Theorem: symmDiff_sdiff_inf
File: Mathlib/Order/SymmDiff.lean

tactic: rw [symmDiff_sdiff]
state_before: ι : Type ?u.27143
α : Type u_1
β : Type ?u.27149
π : ι → Type ?u.27154
inst✝ : GeneralizedCoheytingAlgebra α
a b c d : α
⊢ a ∆ b \ (a ⊓ b) = a ∆ b

tactic: simp [symmDiff]
state_before: ι : Type ?u.27143
α : Type u_1
β : Type ?u.27149
π : ι → Type ?u.27154
inst✝ : GeneralizedCoheytingAlgebra α
a b c d : α
⊢ a \ (b ⊔ a ⊓ b) ⊔ b \ (a ⊔ a ⊓ b) = a ∆ b
Theorem: Sum.isLeft_eq_false
File: Mathlib/Data/Sum/Basic.lean

tactic: cases x <;> simp
state_before: α : Type u
α' : Type w
β : Type v
β' : Type x
γ : Type ?u.6615
δ : Type ?u.6618
x y : α ⊕ β
⊢ isLeft x = false ↔ isRight x = true
Theorem: List.filter_eq
File: Mathlib/Data/List/Count.lean

tactic: simpa only [eq_comm] using filter_eq' l a
state_before: α : Type u_1
l✝ : List α
inst✝ : DecidableEq α
l : List α
a : α
⊢ filter (fun x => decide (a = x)) l = replicate (count a l) a
Theorem: Polynomial.toFinsupp_eq_zero
File: Mathlib/Data/Polynomial/Basic.lean

tactic: rw [← toFinsupp_zero, toFinsupp_inj]
state_before: R : Type u
a✝ b : R
m n : ℕ
inst✝ : Semiring R
p q a : R[X]
⊢ a.toFinsupp = 0 ↔ a = 0
Theorem: IsBoundedLinearMap.tendsto
File: Mathlib/Analysis/NormedSpace/BoundedLinearMaps.lean

tactic: rw [(hf.mk' _).map_sub e 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.56525
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
f g : E → F
x : E
hf✝ : IsBoundedLinearMap 𝕜 f
hf : IsLinearMap 𝕜 f
M : ℝ
left✝ : 0 < M
hM : ∀ (x : E), ‖f x‖ ≤ M * ‖x‖
e : E
⊢ ‖f e - f x‖ = ‖↑(IsLinearMap.mk' f hf) (e - x)‖

tactic: rfl
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.56525
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
f g : E → F
x : E
hf✝ : IsBoundedLinearMap 𝕜 f
hf : IsLinearMap 𝕜 f
M : ℝ
left✝ : 0 < M
hM : ∀ (x : E), ‖f x‖ ≤ M * ‖x‖
e : E
⊢ ‖f e - f x‖ = ‖↑(IsLinearMap.mk' f hf) e - ↑(IsLinearMap.mk' f hf) x‖

tactic: simpa
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.56525
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
f g : E → F
x : E
hf✝ : IsBoundedLinearMap 𝕜 f
hf : IsLinearMap 𝕜 f
M : ℝ
left✝ : 0 < M
hM : ∀ (x : E), ‖f x‖ ≤ M * ‖x‖
this : Tendsto (fun e => M * ‖e - x‖) (𝓝 x) (𝓝 (M * 0))
⊢ Tendsto (fun e => M * ‖e - x‖) (𝓝 x) (𝓝 0)
Theorem: Codisjoint.ne
File: Mathlib/Order/Disjoint.lean

tactic: rwa [← h] at hab
state_before: α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : OrderTop α
a b c d : α
ha : a ≠ ⊤
hab : Codisjoint a b
h : a = b
⊢ Codisjoint a a
Theorem: Finsupp.filter_apply
File: Mathlib/Data/Finsupp/Basic.lean

tactic: rw [Subsingleton.elim D] <;> rfl
state_before: α : Type u_2
β : Type ?u.357626
γ : Type ?u.357629
ι : Type ?u.357632
M : Type u_1
M' : Type ?u.357638
N : Type ?u.357641
P : Type ?u.357644
G : Type ?u.357647
H : Type ?u.357650
R : Type ?u.357653
S : Type ?u.357656
inst✝ : Zero M
p : α → Prop
f : α →₀ M
a : α
D : Decidable (p a)
⊢ ↑(filter p f) a = if p a then ↑f a else 0
Theorem: Finsupp.support_single_subset
File: Mathlib/Data/Finsupp/Defs.lean

tactic: classical show ite _ _ _ ⊆ _; split_ifs <;> [exact empty_subset _; exact Subset.refl _]
state_before: α : Type u_1
β : Type ?u.46826
γ : Type ?u.46829
ι : Type ?u.46832
M : Type u_2
M' : Type ?u.46838
N : Type ?u.46841
P : Type ?u.46844
G : Type ?u.46847
H : Type ?u.46850
R : Type ?u.46853
S : Type ?u.46856
inst✝ : Zero M
a a' : α
b : M
⊢ (single a b).support ⊆ {a}

tactic: show ite _ _ _ ⊆ _
state_before: α : Type u_1
β : Type ?u.46826
γ : Type ?u.46829
ι : Type ?u.46832
M : Type u_2
M' : Type ?u.46838
N : Type ?u.46841
P : Type ?u.46844
G : Type ?u.46847
H : Type ?u.46850
R : Type ?u.46853
S : Type ?u.46856
inst✝ : Zero M
a a' : α
b : M
⊢ (single a b).support ⊆ {a}

tactic: split_ifs <;> [exact empty_subset _; exact Subset.refl _]
state_before: α : Type u_1
β : Type ?u.46826
γ : Type ?u.46829
ι : Type ?u.46832
M : Type u_2
M' : Type ?u.46838
N : Type ?u.46841
P : Type ?u.46844
G : Type ?u.46847
H : Type ?u.46850
R : Type ?u.46853
S : Type ?u.46856
inst✝ : Zero M
a a' : α
b : M
⊢ (if b = 0 then ∅ else {a}) ⊆ {a}
Theorem: convexIndependent_set_iff_inter_convexHull_subset
File: Mathlib/Analysis/Convex/Independent.lean

tactic: constructor
state_before: 𝕜 : Type u_2
E : Type u_1
ι : Type ?u.39598
inst✝² : OrderedSemiring 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s✝ t s : Set E
⊢ ConvexIndependent 𝕜 Subtype.val ↔ ∀ (t : Set E), t ⊆ s → s ∩ ↑(convexHull 𝕜).toOrderHom t ⊆ t

tactic: rintro hc t h x ⟨hxs, hxt⟩
state_before: case mp
𝕜 : Type u_2
E : Type u_1
ι : Type ?u.39598
inst✝² : OrderedSemiring 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s✝ t s : Set E
⊢ ConvexIndependent 𝕜 Subtype.val → ∀ (t : Set E), t ⊆ s → s ∩ ↑(convexHull 𝕜).toOrderHom t ⊆ t

tactic: refine' hc { x | ↑x ∈ t } ⟨x, hxs⟩ _
state_before: case mp.intro
𝕜 : Type u_2
E : Type u_1
ι : Type ?u.39598
inst✝² : OrderedSemiring 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s✝ t✝ s : Set E
hc : ConvexIndependent 𝕜 Subtype.val
t : Set E
h : t ⊆ s
x : E
hxs : x ∈ s
hxt : x ∈ ↑(convexHull 𝕜).toOrderHom t
⊢ x ∈ t

tactic: rw [Subtype.coe_image_of_subset h]
state_before: case mp.intro
𝕜 : Type u_2
E : Type u_1
ι : Type ?u.39598
inst✝² : OrderedSemiring 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s✝ t✝ s : Set E
hc : ConvexIndependent 𝕜 Subtype.val
t : Set E
h : t ⊆ s
x : E
hxs : x ∈ s
hxt : x ∈ ↑(convexHull 𝕜).toOrderHom t
⊢ ↑{ val := x, property := hxs } ∈ ↑(convexHull 𝕜).toOrderHom (Subtype.val '' {x | ↑x ∈ t})

tactic: exact hxt
state_before: case mp.intro
𝕜 : Type u_2
E : Type u_1
ι : Type ?u.39598
inst✝² : OrderedSemiring 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s✝ t✝ s : Set E
hc : ConvexIndependent 𝕜 Subtype.val
t : Set E
h : t ⊆ s
x : E
hxs : x ∈ s
hxt : x ∈ ↑(convexHull 𝕜).toOrderHom t
⊢ ↑{ val := x, property := hxs } ∈ ↑(convexHull 𝕜).toOrderHom t

tactic: intro hc t x h
state_before: case mpr
𝕜 : Type u_2
E : Type u_1
ι : Type ?u.39598
inst✝² : OrderedSemiring 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s✝ t s : Set E
⊢ (∀ (t : Set E), t ⊆ s → s ∩ ↑(convexHull 𝕜).toOrderHom t ⊆ t) → ConvexIndependent 𝕜 Subtype.val

tactic: rw [← Subtype.coe_injective.mem_set_image]
state_before: case mpr
𝕜 : Type u_2
E : Type u_1
ι : Type ?u.39598
inst✝² : OrderedSemiring 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s✝ t✝ s : Set E
hc : ∀ (t : Set E), t ⊆ s → s ∩ ↑(convexHull 𝕜).toOrderHom t ⊆ t
t : Set { x // x ∈ s }
x : { x // x ∈ s }
h : ↑x ∈ ↑(convexHull 𝕜).toOrderHom (Subtype.val '' t)
⊢ x ∈ t

tactic: exact hc (t.image ((↑) : s → E)) (Subtype.coe_image_subset s t) ⟨x.prop, h⟩
state_before: case mpr
𝕜 : Type u_2
E : Type u_1
ι : Type ?u.39598
inst✝² : OrderedSemiring 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s✝ t✝ s : Set E
hc : ∀ (t : Set E), t ⊆ s → s ∩ ↑(convexHull 𝕜).toOrderHom t ⊆ t
t : Set { x // x ∈ s }
x : { x // x ∈ s }
h : ↑x ∈ ↑(convexHull 𝕜).toOrderHom (Subtype.val '' t)
⊢ ↑x ∈ (fun a => ↑a) '' t