tasksource/leandojo huggingface dataset:
Theorem: nnnorm_mul_le
File: Mathlib/Analysis/Normed/Field/Basic.lean

tactic: simpa only [← norm_toNNReal, ← Real.toNNReal_mul (norm_nonneg _)] using
  Real.toNNReal_mono (norm_mul_le _ _)
state_before: α : Type u_1
β : Type ?u.12527
γ : Type ?u.12530
ι : Type ?u.12533
inst✝ : NonUnitalSeminormedRing α
a b : α
⊢ ‖a * b‖₊ ≤ ‖a‖₊ * ‖b‖₊
Theorem: MeasureTheory.FiniteMeasure.restrict_apply
File: Mathlib/MeasureTheory/Measure/FiniteMeasure.lean

tactic: apply congr_arg ENNReal.toNNReal
state_before: Ω : Type u_1
inst✝⁴ : MeasurableSpace Ω
R : Type ?u.38918
inst✝³ : SMul R ℝ≥0
inst✝² : SMul R ℝ≥0∞
inst✝¹ : IsScalarTower R ℝ≥0 ℝ≥0∞
inst✝ : IsScalarTower R ℝ≥0∞ ℝ≥0∞
μ : FiniteMeasure Ω
A s : Set Ω
s_mble : MeasurableSet s
⊢ (fun s => ENNReal.toNNReal (↑↑↑(restrict μ A) s)) s = (fun s => ENNReal.toNNReal (↑↑↑μ s)) (s ∩ A)

tactic: exact Measure.restrict_apply s_mble
state_before: Ω : Type u_1
inst✝⁴ : MeasurableSpace Ω
R : Type ?u.38918
inst✝³ : SMul R ℝ≥0
inst✝² : SMul R ℝ≥0∞
inst✝¹ : IsScalarTower R ℝ≥0 ℝ≥0∞
inst✝ : IsScalarTower R ℝ≥0∞ ℝ≥0∞
μ : FiniteMeasure Ω
A s : Set Ω
s_mble : MeasurableSet s
⊢ ↑↑↑(restrict μ A) s = ↑↑↑μ (s ∩ A)
Theorem: DirectSum.coe_decompose_mul_add_of_left_mem
File: Mathlib/RingTheory/GradedAlgebra/Basic.lean

tactic: lift a to 𝒜 i using a_mem
state_before: ι : Type u_1
R : Type ?u.154109
A : Type u_2
σ : Type u_3
inst✝⁵ : DecidableEq ι
inst✝⁴ : Semiring A
inst✝³ : SetLike σ A
inst✝² : AddSubmonoidClass σ A
𝒜 : ι → σ
i j : ι
inst✝¹ : AddLeftCancelMonoid ι
inst✝ : GradedRing 𝒜
a b : A
a_mem : a ∈ 𝒜 i
⊢ ↑(↑(↑(decompose 𝒜) (a * b)) (i + j)) = a * ↑(↑(↑(decompose 𝒜) b) j)

tactic: rw [decompose_mul, decompose_coe, coe_of_mul_apply_add]
state_before: case intro
ι : Type u_1
R : Type ?u.154109
A : Type u_2
σ : Type u_3
inst✝⁵ : DecidableEq ι
inst✝⁴ : Semiring A
inst✝³ : SetLike σ A
inst✝² : AddSubmonoidClass σ A
𝒜 : ι → σ
i j : ι
inst✝¹ : AddLeftCancelMonoid ι
inst✝ : GradedRing 𝒜
b : A
a : { x // x ∈ 𝒜 i }
⊢ ↑(↑(↑(decompose 𝒜) (↑a * b)) (i + j)) = ↑a * ↑(↑(↑(decompose 𝒜) b) j)
Theorem: covby_sup_of_inf_covby_of_inf_covby_right
File: Mathlib/Order/ModularLattice.lean

tactic: rw [inf_comm, sup_comm]
state_before: α : Type u_1
inst✝¹ : Lattice α
inst✝ : IsWeakUpperModularLattice α
a b : α
⊢ a ⊓ b ⋖ a → a ⊓ b ⋖ b → b ⋖ a ⊔ b

tactic: exact fun ha hb => covby_sup_of_inf_covby_of_inf_covby_left hb ha
state_before: α : Type u_1
inst✝¹ : Lattice α
inst✝ : IsWeakUpperModularLattice α
a b : α
⊢ b ⊓ a ⋖ a → b ⊓ a ⋖ b → b ⋖ b ⊔ a
Theorem: Real.sin_sub
File: Mathlib/Data/Complex/Exponential.lean

tactic: simp [sub_eq_add_neg, sin_add, sin_neg, cos_neg]
state_before: x y : ℝ
⊢ sin (x - y) = sin x * cos y - cos x * sin y
Theorem: List.mem_lookupAll
File: Mathlib/Data/List/Sigma.lean

tactic: simp
state_before: α : Type u
β : α → Type v
l l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a : α
b : β a
⊢ b ∈ lookupAll a [] ↔ { fst := a, snd := b } ∈ []

tactic: by_cases h : a = a'
state_before: α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a : α
b : β a
a' : α
b' : β a'
l : List (Sigma β)
⊢ b ∈ lookupAll a ({ fst := a', snd := b' } :: l) ↔ { fst := a, snd := b } ∈ { fst := a', snd := b' } :: l

tactic: . simp [*, mem_lookupAll]
state_before: case neg
α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a : α
b : β a
a' : α
b' : β a'
l : List (Sigma β)
h : ¬a = a'
⊢ b ∈ lookupAll a ({ fst := a', snd := b' } :: l) ↔ { fst := a, snd := b } ∈ { fst := a', snd := b' } :: l

tactic: subst h
state_before: case pos
α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a : α
b : β a
a' : α
b' : β a'
l : List (Sigma β)
h : a = a'
⊢ b ∈ lookupAll a ({ fst := a', snd := b' } :: l) ↔ { fst := a, snd := b } ∈ { fst := a', snd := b' } :: l

tactic: simp [*, mem_lookupAll]
state_before: case pos
α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a : α
b : β a
l : List (Sigma β)
b' : β a
⊢ b ∈ lookupAll a ({ fst := a, snd := b' } :: l) ↔ { fst := a, snd := b } ∈ { fst := a, snd := b' } :: l

tactic: simp [*, mem_lookupAll]
state_before: case neg
α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a : α
b : β a
a' : α
b' : β a'
l : List (Sigma β)
h : ¬a = a'
⊢ b ∈ lookupAll a ({ fst := a', snd := b' } :: l) ↔ { fst := a, snd := b } ∈ { fst := a', snd := b' } :: l
Theorem: ENNReal.lt_add_right
File: Mathlib/Data/Real/ENNReal.lean

tactic: rwa [← pos_iff_ne_zero, ← ENNReal.add_lt_add_iff_left ha, add_zero] at hb
state_before: α : Type ?u.124501
β : Type ?u.124504
a b c d : ℝ≥0∞
r p q : ℝ≥0
ha : a ≠ ⊤
hb : b ≠ 0
⊢ a < a + b
Theorem: MeasurableSpace.generateFrom_insert_univ
File: Mathlib/MeasureTheory/MeasurableSpaceDef.lean

tactic: rw [insert_eq, ← generateFrom_sup_generateFrom, generateFrom_singleton_univ, bot_sup_eq]
state_before: α : Type u_1
β : Type ?u.22240
γ : Type ?u.22243
δ : Type ?u.22246
δ' : Type ?u.22249
ι : Sort ?u.22252
s t u : Set α
S : Set (Set α)
⊢ generateFrom (insert univ S) = generateFrom S
Theorem: CompositionSeries.append_succ_natAdd
File: Mathlib/Order/JordanHolder.lean

tactic: rw [coe_append, append_succ_natAdd_aux _ _ i]
state_before: X : Type u
inst✝¹ : Lattice X
inst✝ : JordanHolderLattice X
s₁ s₂ : CompositionSeries X
h : top s₁ = bot s₂
i : Fin s₂.length
⊢ series (append s₁ s₂ h) (Fin.succ (↑(Fin.natAdd s₁.length) i)) = series s₂ (Fin.succ i)
Theorem: Projectivization.independent_pair_iff_neq
File: Mathlib/LinearAlgebra/ProjectiveSpace/Independence.lean

tactic: rw [independent_iff_not_dependent, dependent_pair_iff_eq u v]
state_before: ι : Type ?u.40791
K : Type u_1
V : Type u_2
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : ι → ℙ K V
u v : ℙ K V
⊢ Independent ![u, v] ↔ u ≠ v
Theorem: TensorProduct.ite_tmul
File: Mathlib/LinearAlgebra/TensorProduct.lean

tactic: split_ifs <;> simp
state_before: R : Type u_3
inst✝¹⁷ : CommSemiring R
R' : Type ?u.442286
inst✝¹⁶ : Monoid R'
R'' : Type ?u.442292
inst✝¹⁵ : Semiring R''
M : Type u_1
N : Type u_2
P✝ : Type ?u.442304
Q : Type ?u.442307
S : Type ?u.442310
inst✝¹⁴ : AddCommMonoid M
inst✝¹³ : AddCommMonoid N
inst✝¹² : AddCommMonoid P✝
inst✝¹¹ : AddCommMonoid Q
inst✝¹⁰ : AddCommMonoid S
inst✝⁹ : Module R M
inst✝⁸ : Module R N
inst✝⁷ : Module R P✝
inst✝⁶ : Module R Q
inst✝⁵ : Module R S
inst✝⁴ : DistribMulAction R' M
inst✝³ : Module R'' M
inst✝² : SMulCommClass R R' M
inst✝¹ : SMulCommClass R R'' M
x₁ : M
x₂ : N
P : Prop
inst✝ : Decidable P
⊢ (if P then x₁ else 0) ⊗ₜ[R] x₂ = if P then x₁ ⊗ₜ[R] x₂ else 0
Theorem: Matrix.unitOfDetInvertible_eq_nonsingInvUnit
File: Mathlib/LinearAlgebra/Matrix/NonsingularInverse.lean

tactic: ext
state_before: l : Type ?u.255443
m : Type u
n : Type u'
α : Type v
inst✝³ : Fintype n
inst✝² : DecidableEq n
inst✝¹ : CommRing α
A B : Matrix n n α
inst✝ : Invertible (det A)
⊢ unitOfDetInvertible A = nonsingInvUnit A (_ : IsUnit (det A))

tactic: rfl
state_before: case a.a.h
l : Type ?u.255443
m : Type u
n : Type u'
α : Type v
inst✝³ : Fintype n
inst✝² : DecidableEq n
inst✝¹ : CommRing α
A B : Matrix n n α
inst✝ : Invertible (det A)
i✝ x✝ : n
⊢ ↑(unitOfDetInvertible A) i✝ x✝ = ↑(nonsingInvUnit A (_ : IsUnit (det A))) i✝ x✝
Theorem: LinearPMap.mem_inverse_graph
File: Mathlib/LinearAlgebra/LinearPMap.lean

tactic: simp only [inverse_graph, Submodule.mem_map, mem_graph_iff, Subtype.exists, exists_and_left,
  exists_eq_left, LinearEquiv.prodComm_apply, Prod.exists, Prod.swap_prod_mk, Prod.mk.injEq]
state_before: R : Type u_2
inst✝⁶ : Ring R
E : Type u_1
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type ?u.720040
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f : E →ₗ.[R] F
hf : LinearMap.ker f.toFun = ⊥
x : { x // x ∈ f.domain }
⊢ (↑f x, ↑x) ∈ graph (inverse hf)

tactic: exact ⟨(x : E), f x, ⟨x.2, Eq.refl _⟩, Eq.refl _, Eq.refl _⟩
state_before: R : Type u_2
inst✝⁶ : Ring R
E : Type u_1
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type ?u.720040
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f : E →ₗ.[R] F
hf : LinearMap.ker f.toFun = ⊥
x : { x // x ∈ f.domain }
⊢ ∃ a b, (∃ h, ↑f { val := a, property := (_ : (a, b).fst ∈ f.domain) } = b) ∧ b = ↑f x ∧ a = ↑x
Theorem: Filter.sup_join
File: Mathlib/Order/Filter/Basic.lean

tactic: simp only [mem_sup, mem_join]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type ?u.102736
ι : Sort x
f g : Filter α
s t : Set α
f₁ f₂ : Filter (Filter α)
x : Set α
⊢ x ∈ join f₁ ⊔ join f₂ ↔ x ∈ join (f₁ ⊔ f₂)
Theorem: LieSubmodule.lcs_add_le_iff
File: Mathlib/Algebra/Lie/Nilpotent.lean

tactic: induction' k with k ih generalizing l
state_before: R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
k✝ : ℕ
N N₁ N₂ : LieSubmodule R L M
l k : ℕ
⊢ lcs (l + k) N₁ ≤ N₂ ↔ lcs l N₁ ≤ ucs k N₂

tactic: rw [(by abel : l + (k + 1) = l + 1 + k), ih, ucs_succ, lcs_succ, top_lie_le_iff_le_normalizer]
state_before: case succ
R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
k✝ : ℕ
N N₁ N₂ : LieSubmodule R L M
l✝ k : ℕ
ih : ∀ (l : ℕ), lcs (l + k) N₁ ≤ N₂ ↔ lcs l N₁ ≤ ucs k N₂
l : ℕ
⊢ lcs (l + Nat.succ k) N₁ ≤ N₂ ↔ lcs l N₁ ≤ ucs (Nat.succ k) N₂

tactic: simp
state_before: case zero
R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
k : ℕ
N N₁ N₂ : LieSubmodule R L M
l✝ l : ℕ
⊢ lcs (l + Nat.zero) N₁ ≤ N₂ ↔ lcs l N₁ ≤ ucs Nat.zero N₂

tactic: abel
state_before: R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
k✝ : ℕ
N N₁ N₂ : LieSubmodule R L M
l✝ k : ℕ
ih : ∀ (l : ℕ), lcs (l + k) N₁ ≤ N₂ ↔ lcs l N₁ ≤ ucs k N₂
l : ℕ
⊢ l + (k + 1) = l + 1 + k
Theorem: AntitoneOn.sum_le_integral_Ico
File: Mathlib/Analysis/SumIntegralComparisons.lean

tactic: rw [(Nat.sub_add_cancel hab).symm, Nat.cast_add]
state_before: x₀ : ℝ
a b : ℕ
f : ℝ → ℝ
hab : a ≤ b
hf : AntitoneOn f (Icc ↑a ↑b)
⊢ ∑ i in Finset.Ico a b, f ↑(i + 1) ≤ ∫ (x : ℝ) in ↑a..↑b, f x

tactic: rw [← Finset.sum_Ico_add, Nat.Ico_zero_eq_range]
state_before: x₀ : ℝ
a b : ℕ
f : ℝ → ℝ
hab : a ≤ b
hf : AntitoneOn f (Icc ↑a ↑b)
⊢ ∑ i in Finset.Ico (0 + a) (b - a + a), f ↑(i + 1) ≤ ∫ (x : ℝ) in ↑a..↑a + ↑(b - a), f x

tactic: apply AntitoneOn.sum_le_integral
state_before: x₀ : ℝ
a b : ℕ
f : ℝ → ℝ
hab : a ≤ b
hf : AntitoneOn f (Icc ↑a ↑b)
⊢ ∑ x in Finset.range (b - a), f (↑a + ↑(x + 1)) ≤ ∫ (x : ℝ) in ↑a..↑a + ↑(b - a), f x

tactic: simp only [hf, hab, Nat.cast_sub, add_sub_cancel'_right]
state_before: case hf
x₀ : ℝ
a b : ℕ
f : ℝ → ℝ
hab : a ≤ b
hf : AntitoneOn f (Icc ↑a ↑b)
⊢ AntitoneOn f (Icc (↑a) (↑a + ↑(b - a)))
Theorem: FiniteDimensional.finrank_fin_fun
File: Mathlib/LinearAlgebra/Finrank.lean

tactic: simp
state_before: K : Type u
V : Type v
inst✝⁵ : Ring K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : StrongRankCondition K
n : ℕ
⊢ finrank K (Fin n → K) = n
Theorem: lineMap_mono_right
File: Mathlib/LinearAlgebra/AffineSpace/Ordered.lean

tactic: simp only [lineMap_apply_module]
state_before: k : Type u_2
E : Type u_1
PE : Type ?u.16391
inst✝³ : OrderedRing k
inst✝² : OrderedAddCommGroup E
inst✝¹ : Module k E
inst✝ : OrderedSMul k E
a a' b b' : E
r r' : k
hb : b ≤ b'
hr : 0 ≤ r
⊢ ↑(lineMap a b) r ≤ ↑(lineMap a b') r

tactic: exact add_le_add_left (smul_le_smul_of_nonneg hb hr) _
state_before: k : Type u_2
E : Type u_1
PE : Type ?u.16391
inst✝³ : OrderedRing k
inst✝² : OrderedAddCommGroup E
inst✝¹ : Module k E
inst✝ : OrderedSMul k E
a a' b b' : E
r r' : k
hb : b ≤ b'
hr : 0 ≤ r
⊢ (1 - r) • a + r • b ≤ (1 - r) • a + r • b'
Theorem: SemiconjBy.mul_left
File: Mathlib/Algebra/Group/Semiconj.lean

tactic: unfold SemiconjBy
state_before: S : Type u_1
inst✝ : Semigroup S
a b x y z x' y' : S
ha : SemiconjBy a y z
hb : SemiconjBy b x y
⊢ SemiconjBy (a * b) x z

tactic: rw [mul_assoc, hb.eq, ←mul_assoc, ha.eq, mul_assoc]
state_before: S : Type u_1
inst✝ : Semigroup S
a b x y z x' y' : S
ha : SemiconjBy a y z
hb : SemiconjBy b x y
⊢ a * b * x = z * (a * b)
Theorem: Set.ordConnected_iff_uIcc_subset_right
File: Mathlib/Data/Set/Intervals/OrdConnected.lean

tactic: simp_rw [ordConnected_iff_uIcc_subset_left hx, uIcc_comm]
state_before: α : Type u_1
inst✝ : LinearOrder α
s : Set α
x : α
hx : x ∈ s
⊢ OrdConnected s ↔ ∀ ⦃y : α⦄, y ∈ s → [[y, x]] ⊆ s
Theorem: MeasureTheory.L1.integral_eq_setToL1
File: Mathlib/MeasureTheory/Integral/Bochner.lean

tactic: simp only [integral]
state_before: α : Type u_1
E : Type u_2
F : Type ?u.419045
𝕜 : Type ?u.419048
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedAddCommGroup F
m : MeasurableSpace α
μ : Measure α
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : NontriviallyNormedField 𝕜
inst✝³ : NormedSpace 𝕜 E
inst✝² : SMulCommClass ℝ 𝕜 E
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace E
f : { x // x ∈ Lp E 1 }
⊢ integral f = ↑(setToL1 (_ : DominatedFinMeasAdditive μ (weightedSMul μ) 1)) f

tactic: rfl
state_before: α : Type u_1
E : Type u_2
F : Type ?u.419045
𝕜 : Type ?u.419048
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedAddCommGroup F
m : MeasurableSpace α
μ : Measure α
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : NontriviallyNormedField 𝕜
inst✝³ : NormedSpace 𝕜 E
inst✝² : SMulCommClass ℝ 𝕜 E
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace E
f : { x // x ∈ Lp E 1 }
⊢ ↑integralCLM f = ↑(setToL1 (_ : DominatedFinMeasAdditive μ (weightedSMul μ) 1)) f
Theorem: Set.Finite.convexHull_eq
File: Mathlib/Analysis/Convex/Combination.lean

tactic: simpa only [Set.Finite.coe_toFinset, Set.Finite.mem_toFinset, exists_prop] using
  hs.toFinset.convexHull_eq
state_before: R : Type u_2
E : Type u_1
F : Type ?u.235303
ι : Type ?u.235306
ι' : Type ?u.235309
α : Type ?u.235312
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
s : Set E
hs : Set.Finite s
⊢ ↑(convexHull R).toOrderHom s = {x | ∃ w x_1 x_2, centerMass (Finite.toFinset hs) w id = x}
Theorem: linearIndependent_subtype_disjoint
File: Mathlib/LinearAlgebra/LinearIndependent.lean

tactic: apply @linearIndependent_comp_subtype_disjoint _ _ _ id
state_before: ι : Type u'
ι' : Type ?u.201811
R : Type u_2
K : Type ?u.201817
M : Type u_1
M' : Type ?u.201823
M'' : Type ?u.201826
V : Type u
V' : Type ?u.201831
v : ι → M
inst✝⁶ : Semiring R
inst✝⁵ : AddCommMonoid M
inst✝⁴ : AddCommMonoid M'
inst✝³ : AddCommMonoid M''
inst✝² : Module R M
inst✝¹ : Module R M'
inst✝ : Module R M''
a b : R
x y : M
s : Set M
⊢ (LinearIndependent R fun x => ↑x) ↔ Disjoint (Finsupp.supported R R s) (LinearMap.ker (Finsupp.total M M R id))
Theorem: IsOpenMap.preimage_closure_subset_closure_preimage
File: Mathlib/Topology/Maps.lean

tactic: rw [← compl_subset_compl]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.195591
δ : Type ?u.195594
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : TopologicalSpace γ
f : α → β
hf : IsOpenMap f
s : Set β
⊢ f ⁻¹' closure s ⊆ closure (f ⁻¹' s)

tactic: simp only [← interior_compl, ← preimage_compl, hf.interior_preimage_subset_preimage_interior]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.195591
δ : Type ?u.195594
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : TopologicalSpace γ
f : α → β
hf : IsOpenMap f
s : Set β
⊢ closure (f ⁻¹' s)ᶜ ⊆ (f ⁻¹' closure s)ᶜ
Theorem: Function.Periodic.image_uIcc
File: Mathlib/Algebra/Periodic.lean

tactic: cases hc.lt_or_lt with
| inl hc =>
  rw [uIcc_of_ge (add_le_of_nonpos_right hc.le), ← h.neg.image_Icc (neg_pos.2 hc) (a + c),
    add_neg_cancel_right]
| inr hc => rw [uIcc_of_le (le_add_of_nonneg_right hc.le), h.image_Icc hc]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.128430
f g : α → β
c c₁ c₂ x : α
inst✝¹ : LinearOrderedAddCommGroup α
inst✝ : Archimedean α
h : Periodic f c
hc : c ≠ 0
a : α
⊢ f '' uIcc a (a + c) = range f

tactic: rw [uIcc_of_ge (add_le_of_nonpos_right hc.le), ← h.neg.image_Icc (neg_pos.2 hc) (a + c),
  add_neg_cancel_right]
state_before: case inl
α : Type u_1
β : Type u_2
γ : Type ?u.128430
f g : α → β
c c₁ c₂ x : α
inst✝¹ : LinearOrderedAddCommGroup α
inst✝ : Archimedean α
h : Periodic f c
hc✝ : c ≠ 0
a : α
hc : c < 0
⊢ f '' uIcc a (a + c) = range f

tactic: rw [uIcc_of_le (le_add_of_nonneg_right hc.le), h.image_Icc hc]
state_before: case inr
α : Type u_1
β : Type u_2
γ : Type ?u.128430
f g : α → β
c c₁ c₂ x : α
inst✝¹ : LinearOrderedAddCommGroup α
inst✝ : Archimedean α
h : Periodic f c
hc✝ : c ≠ 0
a : α
hc : 0 < c
⊢ f '' uIcc a (a + c) = range f
Theorem: sub_mul_add_eq_of_mul_add_eq_mul_add
File: Mathlib/Algebra/Ring/Defs.lean

tactic: simp [sub_mul, sub_add_eq_add_sub]
state_before: α : Type u
β : Type v
γ : Type w
R : Type x
inst✝ : NonUnitalNonAssocRing α
a b c d e : α
h : a * e + c = b * e + d
⊢ (a - b) * e + c = a * e + c - b * e

tactic: rw [h]
state_before: α : Type u
β : Type v
γ : Type w
R : Type x
inst✝ : NonUnitalNonAssocRing α
a b c d e : α
h : a * e + c = b * e + d
⊢ a * e + c - b * e = d

tactic: simp [@add_sub_cancel α]
state_before: α : Type u
β : Type v
γ : Type w
R : Type x
inst✝ : NonUnitalNonAssocRing α
a b c d e : α
h : a * e + c = b * e + d
⊢ b * e + d - b * e = d
Theorem: gramSchmidtOrthonormalBasis_inv_triangular'
File: Mathlib/Analysis/InnerProductSpace/GramSchmidtOrtho.lean

tactic: simpa [OrthonormalBasis.repr_apply_apply] using gramSchmidtOrthonormalBasis_inv_triangular h f hij
state_before: 𝕜 : Type u_2
E : Type u_3
inst✝⁷ : IsROrC 𝕜
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : InnerProductSpace 𝕜 E
ι : Type u_1
inst✝⁴ : LinearOrder ι
inst✝³ : LocallyFiniteOrderBot ι
inst✝² : IsWellOrder ι fun x x_1 => x < x_1
inst✝¹ : Fintype ι
inst✝ : FiniteDimensional 𝕜 E
h : finrank 𝕜 E = Fintype.card ι
f : ι → E
i j : ι
hij : i < j
⊢ ↑(gramSchmidtOrthonormalBasis h f).repr (f i) j = 0
Theorem: LieHom.le_ker_iff
File: Mathlib/Algebra/Lie/Submodule.lean

tactic: constructor <;> intro h x hx
state_before: R : Type u
L : Type v
L' : Type w₂
M : Type w
M' : Type w₁
inst✝¹² : CommRing R
inst✝¹¹ : LieRing L
inst✝¹⁰ : LieAlgebra R L
inst✝⁹ : LieRing L'
inst✝⁸ : LieAlgebra R L'
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
f : L →ₗ⁅R⁆ L'
I : LieIdeal R L
J : LieIdeal R L'
⊢ I ≤ ker f ↔ ∀ (x : L), x ∈ I → ↑f x = 0

tactic: specialize h hx
state_before: case mp
R : Type u
L : Type v
L' : Type w₂
M : Type w
M' : Type w₁
inst✝¹² : CommRing R
inst✝¹¹ : LieRing L
inst✝¹⁰ : LieAlgebra R L
inst✝⁹ : LieRing L'
inst✝⁸ : LieAlgebra R L'
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
f : L →ₗ⁅R⁆ L'
I : LieIdeal R L
J : LieIdeal R L'
h : I ≤ ker f
x : L
hx : x ∈ I
⊢ ↑f x = 0

tactic: rw [mem_ker] at h
state_before: case mp
R : Type u
L : Type v
L' : Type w₂
M : Type w
M' : Type w₁
inst✝¹² : CommRing R
inst✝¹¹ : LieRing L
inst✝¹⁰ : LieAlgebra R L
inst✝⁹ : LieRing L'
inst✝⁸ : LieAlgebra R L'
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
f : L →ₗ⁅R⁆ L'
I : LieIdeal R L
J : LieIdeal R L'
x : L
hx : x ∈ I
h : x ∈ ker f
⊢ ↑f x = 0

tactic: exact h
state_before: case mp
R : Type u
L : Type v
L' : Type w₂
M : Type w
M' : Type w₁
inst✝¹² : CommRing R
inst✝¹¹ : LieRing L
inst✝¹⁰ : LieAlgebra R L
inst✝⁹ : LieRing L'
inst✝⁸ : LieAlgebra R L'
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
f : L →ₗ⁅R⁆ L'
I : LieIdeal R L
J : LieIdeal R L'
x : L
hx : x ∈ I
h : ↑f x = 0
⊢ ↑f x = 0

tactic: rw [mem_ker]
state_before: case mpr
R : Type u
L : Type v
L' : Type w₂
M : Type w
M' : Type w₁
inst✝¹² : CommRing R
inst✝¹¹ : LieRing L
inst✝¹⁰ : LieAlgebra R L
inst✝⁹ : LieRing L'
inst✝⁸ : LieAlgebra R L'
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
f : L →ₗ⁅R⁆ L'
I : LieIdeal R L
J : LieIdeal R L'
h : ∀ (x : L), x ∈ I → ↑f x = 0
x : L
hx : x ∈ I
⊢ x ∈ ker f

tactic: apply h x hx
state_before: case mpr
R : Type u
L : Type v
L' : Type w₂
M : Type w
M' : Type w₁
inst✝¹² : CommRing R
inst✝¹¹ : LieRing L
inst✝¹⁰ : LieAlgebra R L
inst✝⁹ : LieRing L'
inst✝⁸ : LieAlgebra R L'
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
f : L →ₗ⁅R⁆ L'
I : LieIdeal R L
J : LieIdeal R L'
h : ∀ (x : L), x ∈ I → ↑f x = 0
x : L
hx : x ∈ I
⊢ ↑f x = 0
Theorem: SimpleGraph.not_cliqueFree_of_top_embedding
File: Mathlib/Combinatorics/SimpleGraph/Clique.lean

tactic: simp only [CliqueFree, isNClique_iff, isClique_iff_induce_eq, not_forall, Classical.not_not]
state_before: α : Type u_1
G H : SimpleGraph α
m n✝ : ℕ
s : Finset α
n : ℕ
f : ⊤ ↪g G
⊢ ¬CliqueFree G n

tactic: use Finset.univ.map f.toEmbedding
state_before: α : Type u_1
G H : SimpleGraph α
m n✝ : ℕ
s : Finset α
n : ℕ
f : ⊤ ↪g G
⊢ ∃ x, induce (↑x) G = ⊤ ∧ Finset.card x = n

tactic: simp only [card_map, Finset.card_fin, eq_self_iff_true, and_true_iff]
state_before: α : Type u_1
G H : SimpleGraph α
m n✝ : ℕ
s : Finset α
n : ℕ
f : ⊤ ↪g G
⊢ induce (↑(map f.toEmbedding univ)) G = ⊤ ∧ Finset.card (map f.toEmbedding univ) = n

tactic: ext ⟨v, hv⟩ ⟨w, hw⟩
state_before: α : Type u_1
G H : SimpleGraph α
m n✝ : ℕ
s : Finset α
n : ℕ
f : ⊤ ↪g G
⊢ induce (↑(map f.toEmbedding univ)) G = ⊤

tactic: simp only [coe_map, Set.mem_image, coe_univ, Set.mem_univ, true_and_iff] at hv hw
state_before: case Adj.h.mk.h.mk.a
α : Type u_1
G H : SimpleGraph α
m n✝ : ℕ
s : Finset α
n : ℕ
f : ⊤ ↪g G
v : α
hv : v ∈ ↑(map f.toEmbedding univ)
w : α
hw : w ∈ ↑(map f.toEmbedding univ)
⊢ Adj (induce (↑(map f.toEmbedding univ)) G) { val := v, property := hv } { val := w, property := hw } ↔
    Adj ⊤ { val := v, property := hv } { val := w, property := hw }

tactic: obtain ⟨v', rfl⟩ := hv
state_before: case Adj.h.mk.h.mk.a
α : Type u_1
G H : SimpleGraph α
m n✝ : ℕ
s : Finset α
n : ℕ
f : ⊤ ↪g G
v : α
hv✝ : v ∈ ↑(map f.toEmbedding univ)
w : α
hw✝ : w ∈ ↑(map f.toEmbedding univ)
hv : ∃ x, ↑f.toEmbedding x = v
hw : ∃ x, ↑f.toEmbedding x = w
⊢ Adj (induce (↑(map f.toEmbedding univ)) G) { val := v, property := hv✝ } { val := w, property := hw✝ } ↔
    Adj ⊤ { val := v, property := hv✝ } { val := w, property := hw✝ }

tactic: obtain ⟨w', rfl⟩ := hw
state_before: case Adj.h.mk.h.mk.a.intro
α : Type u_1
G H : SimpleGraph α
m n✝ : ℕ
s : Finset α
n : ℕ
f : ⊤ ↪g G
w : α
hw✝ : w ∈ ↑(map f.toEmbedding univ)
hw : ∃ x, ↑f.toEmbedding x = w
v' : Fin n
hv : ↑f.toEmbedding v' ∈ ↑(map f.toEmbedding univ)
⊢ Adj (induce (↑(map f.toEmbedding univ)) G) { val := ↑f.toEmbedding v', property := hv }
      { val := w, property := hw✝ } ↔
    Adj ⊤ { val := ↑f.toEmbedding v', property := hv } { val := w, property := hw✝ }

tactic: simp only [coe_sort_coe, RelEmbedding.coe_toEmbedding, comap_Adj, Function.Embedding.coe_subtype,
  f.map_adj_iff, top_adj, ne_eq, Subtype.mk.injEq, RelEmbedding.inj]
state_before: case Adj.h.mk.h.mk.a.intro.intro
α : Type u_1
G H : SimpleGraph α
m n✝ : ℕ
s : Finset α
n : ℕ
f : ⊤ ↪g G
v' : Fin n
hv : ↑f.toEmbedding v' ∈ ↑(map f.toEmbedding univ)
w' : Fin n
hw : ↑f.toEmbedding w' ∈ ↑(map f.toEmbedding univ)
⊢ Adj (induce (↑(map f.toEmbedding univ)) G) { val := ↑f.toEmbedding v', property := hv }
      { val := ↑f.toEmbedding w', property := hw } ↔
    Adj ⊤ { val := ↑f.toEmbedding v', property := hv } { val := ↑f.toEmbedding w', property := hw }