tasksource/leandojo huggingface dataset:
Theorem: MeasureTheory.L1.integral_neg
File: Mathlib/MeasureTheory/Integral/Bochner.lean

tactic: simp only [integral]
state_before: α : Type u_1
E : Type u_2
F : Type ?u.456950
𝕜 : Type ?u.456953
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) = -integral f

tactic: exact map_neg integralCLM f
state_before: α : Type u_1
E : Type u_2
F : Type ?u.456950
𝕜 : Type ?u.456953
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) = -↑integralCLM f
Theorem: Module.Baer.extensionOfMax_to_submodule_eq_top
File: Mathlib/Algebra/Module/Injective.lean

tactic: refine' Submodule.eq_top_iff'.mpr fun y => _
state_before: R : Type u
inst✝⁷ : Ring R
Q : TypeMax
inst✝⁶ : AddCommGroup Q
inst✝⁵ : Module R Q
M N : Type (max u v)
inst✝⁴ : AddCommGroup M
inst✝³ : AddCommGroup N
inst✝² : Module R M
inst✝¹ : Module R N
i : M →ₗ[R] N
f : M →ₗ[R] Q
inst✝ : Fact (Function.Injective ↑i)
h : Baer R Q
⊢ (extensionOfMax i f).toLinearPMap.domain = ⊤

tactic: dsimp
state_before: R : Type u
inst✝⁷ : Ring R
Q : TypeMax
inst✝⁶ : AddCommGroup Q
inst✝⁵ : Module R Q
M N : Type (max u v)
inst✝⁴ : AddCommGroup M
inst✝³ : AddCommGroup N
inst✝² : Module R M
inst✝¹ : Module R N
i : M →ₗ[R] N
f : M →ₗ[R] Q
inst✝ : Fact (Function.Injective ↑i)
h : Baer R Q
y : N
⊢ y ∈ (extensionOfMax i f).toLinearPMap.domain

tactic: rw [← extensionOfMax_is_max i f _ (extensionOfMax_le i f h), extensionOfMaxAdjoin,
  Submodule.mem_sup]
state_before: R : Type u
inst✝⁷ : Ring R
Q : TypeMax
inst✝⁶ : AddCommGroup Q
inst✝⁵ : Module R Q
M N : Type (max u v)
inst✝⁴ : AddCommGroup M
inst✝³ : AddCommGroup N
inst✝² : Module R M
inst✝¹ : Module R N
i : M →ₗ[R] N
f : M →ₗ[R] Q
inst✝ : Fact (Function.Injective ↑i)
h : Baer R Q
y : N
⊢ y ∈ (extensionOfMax i f).toLinearPMap.domain

tactic: exact ⟨0, Submodule.zero_mem _, y, Submodule.mem_span_singleton_self _, zero_add _⟩
state_before: R : Type u
inst✝⁷ : Ring R
Q : TypeMax
inst✝⁶ : AddCommGroup Q
inst✝⁵ : Module R Q
M N : Type (max u v)
inst✝⁴ : AddCommGroup M
inst✝³ : AddCommGroup N
inst✝² : Module R M
inst✝¹ : Module R N
i : M →ₗ[R] N
f : M →ₗ[R] Q
inst✝ : Fact (Function.Injective ↑i)
h : Baer R Q
y : N
⊢ ∃ y_1, y_1 ∈ (extensionOfMax i f).toLinearPMap.domain ∧ ∃ z, z ∈ Submodule.span R {?y} ∧ y_1 + z = y

case y
R : Type u
inst✝⁷ : Ring R
Q : TypeMax
inst✝⁶ : AddCommGroup Q
inst✝⁵ : Module R Q
M N : Type (max u v)
inst✝⁴ : AddCommGroup M
inst✝³ : AddCommGroup N
inst✝² : Module R M
inst✝¹ : Module R N
i : M →ₗ[R] N
f : M →ₗ[R] Q
inst✝ : Fact (Function.Injective ↑i)
h : Baer R Q
y : N
⊢ N

case y
R : Type u
inst✝⁷ : Ring R
Q : TypeMax
inst✝⁶ : AddCommGroup Q
inst✝⁵ : Module R Q
M N : Type (max u v)
inst✝⁴ : AddCommGroup M
inst✝³ : AddCommGroup N
inst✝² : Module R M
inst✝¹ : Module R N
i : M →ₗ[R] N
f : M →ₗ[R] Q
inst✝ : Fact (Function.Injective ↑i)
h : Baer R Q
y : N
⊢ N
Theorem: nhds_le_nhdsSet_iff
File: Mathlib/Topology/Separation.lean

tactic: rw [← nhdsSet_singleton, nhdsSet_le_iff, singleton_subset_iff]
state_before: α : Type u
β : Type v
inst✝¹ : TopologicalSpace α
inst✝ : T1Space α
s : Set α
x : α
⊢ 𝓝 x ≤ 𝓝ˢ s ↔ x ∈ s
Theorem: CauSeq.le_inf
File: Mathlib/Data/Real/CauSeq.lean

tactic: cases' hb with hb hb
state_before: α : Type u_1
inst✝ : LinearOrderedField α
a b c : CauSeq α abs
hb : a ≤ b
hc : a ≤ c
⊢ a ≤ b ⊓ c

tactic: cases' hc with hc hc
state_before: case inl
α : Type u_1
inst✝ : LinearOrderedField α
a b c : CauSeq α abs
hc : a ≤ c
hb : a < b
⊢ a ≤ b ⊓ c

tactic: exact Or.inl (CauSeq.lt_inf hb hc)
state_before: case inl.inl
α : Type u_1
inst✝ : LinearOrderedField α
a b c : CauSeq α abs
hb : a < b
hc : a < c
⊢ a ≤ b ⊓ c

tactic: replace hb := le_of_eq_of_le (Setoid.symm hc) hb.le
state_before: case inl.inr
α : Type u_1
inst✝ : LinearOrderedField α
a b c : CauSeq α abs
hb : a < b
hc : a ≈ c
⊢ a ≤ b ⊓ c

tactic: refine' le_of_eq_of_le hc (Or.inr _)
state_before: case inl.inr
α : Type u_1
inst✝ : LinearOrderedField α
a b c : CauSeq α abs
hc : a ≈ c
hb : c ≤ b
⊢ a ≤ b ⊓ c

tactic: exact Setoid.symm (CauSeq.inf_eq_right hb)
state_before: case inl.inr
α : Type u_1
inst✝ : LinearOrderedField α
a b c : CauSeq α abs
hc : a ≈ c
hb : c ≤ b
⊢ c ≈ b ⊓ c

tactic: replace hc := le_of_eq_of_le (Setoid.symm hb) hc
state_before: case inr
α : Type u_1
inst✝ : LinearOrderedField α
a b c : CauSeq α abs
hc : a ≤ c
hb : a ≈ b
⊢ a ≤ b ⊓ c

tactic: refine' le_of_eq_of_le hb (Or.inr _)
state_before: case inr
α : Type u_1
inst✝ : LinearOrderedField α
a b c : CauSeq α abs
hb : a ≈ b
hc : b ≤ c
⊢ a ≤ b ⊓ c

tactic: exact Setoid.symm (CauSeq.inf_eq_left hc)
state_before: case inr
α : Type u_1
inst✝ : LinearOrderedField α
a b c : CauSeq α abs
hb : a ≈ b
hc : b ≤ c
⊢ b ≈ b ⊓ c
Theorem: Equiv.Perm.support_le_prod_of_mem
File: Mathlib/GroupTheory/Perm/Support.lean

tactic: intro x hx
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
l : List (Perm α)
h : f ∈ l
hl : List.Pairwise Disjoint l
⊢ support f ≤ support (List.prod l)

tactic: rwa [mem_support, ← eq_on_support_mem_disjoint h hl _ hx, ← mem_support]
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
l : List (Perm α)
h : f ∈ l
hl : List.Pairwise Disjoint l
x : α
hx : x ∈ support f
⊢ x ∈ support (List.prod l)
Theorem: Metric.inseparable_iff
File: Mathlib/Topology/MetricSpace/Basic.lean

tactic: rw [EMetric.inseparable_iff, edist_nndist, dist_nndist, ENNReal.coe_eq_zero, NNReal.coe_eq_zero]
state_before: α : Type u
β : Type v
X : Type ?u.166352
ι : Type ?u.166355
inst✝ : PseudoMetricSpace α
x y : α
⊢ Inseparable x y ↔ dist x y = 0
Theorem: rTensorHomEquivHomRTensor_apply
File: Mathlib/LinearAlgebra/Contraction.lean

tactic: rw [← LinearEquiv.coe_toLinearMap, rTensorHomEquivHomRTensor_toLinearMap]
state_before: ι : Type w
R : Type u
M : Type v₁
N : Type v₂
P : Type v₃
Q : Type v₄
inst✝¹³ : CommRing R
inst✝¹² : AddCommGroup M
inst✝¹¹ : AddCommGroup N
inst✝¹⁰ : AddCommGroup P
inst✝⁹ : AddCommGroup Q
inst✝⁸ : Module R M
inst✝⁷ : Module R N
inst✝⁶ : Module R P
inst✝⁵ : Module R Q
inst✝⁴ : Free R M
inst✝³ : Module.Finite R M
inst✝² : Free R N
inst✝¹ : Module.Finite R N
inst✝ : Nontrivial R
x : (M →ₗ[R] P) ⊗[R] Q
⊢ ↑(rTensorHomEquivHomRTensor R M P Q) x = ↑(rTensorHomToHomRTensor R M P Q) x
Theorem: ZMod.val_eq_ite_valMinAbs
File: Mathlib/Data/ZMod/Basic.lean

tactic: rw [valMinAbs_def_pos]
state_before: n : ℕ
inst✝ : NeZero n
a : ZMod n
⊢ ↑(val a) = valMinAbs a + ↑(if val a ≤ n / 2 then 0 else n)

tactic: split_ifs <;> simp [add_zero, sub_add_cancel]
state_before: n : ℕ
inst✝ : NeZero n
a : ZMod n
⊢ ↑(val a) = (if val a ≤ n / 2 then ↑(val a) else ↑(val a) - ↑n) + ↑(if val a ≤ n / 2 then 0 else n)
Theorem: Set.eval_preimage'
File: Mathlib/Data/Set/Prod.lean

tactic: ext
state_before: ι : Type u_1
α : ι → Type u_2
β : ι → Type ?u.161026
s✝ s₁ s₂ : Set ι
t t₁ t₂ : (i : ι) → Set (α i)
i : ι
inst✝ : DecidableEq ι
s : Set (α i)
⊢ eval i ⁻¹' s = pi {i} (update (fun i => univ) i s)

tactic: simp
state_before: case h
ι : Type u_1
α : ι → Type u_2
β : ι → Type ?u.161026
s✝ s₁ s₂ : Set ι
t t₁ t₂ : (i : ι) → Set (α i)
i : ι
inst✝ : DecidableEq ι
s : Set (α i)
x✝ : (x : ι) → α x
⊢ x✝ ∈ eval i ⁻¹' s ↔ x✝ ∈ pi {i} (update (fun i => univ) i s)
Theorem: ContDiffAt.fderiv
File: Mathlib/Analysis/Calculus/ContDiff.lean

tactic: simp_rw [← fderivWithin_univ]
state_before: 𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type ?u.1095737
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f✝ f₁ : E → F
g✝ : F → G
x x₀ : E
c : F
b : E × F → G
m n✝ : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
f : E → F → G
g : E → F
n : ℕ∞
hf : ContDiffAt 𝕜 n (uncurry f) (x₀, g x₀)
hg : ContDiffAt 𝕜 m g x₀
hmn : m + 1 ≤ n
⊢ ContDiffAt 𝕜 m (fun x => fderiv 𝕜 (f x) (g x)) x₀

tactic: refine (ContDiffWithinAt.fderivWithin hf.contDiffWithinAt hg.contDiffWithinAt uniqueDiffOn_univ
  hmn (mem_univ x₀) ?_).contDiffAt univ_mem
state_before: 𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type ?u.1095737
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f✝ f₁ : E → F
g✝ : F → G
x x₀ : E
c : F
b : E × F → G
m n✝ : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
f : E → F → G
g : E → F
n : ℕ∞
hf : ContDiffAt 𝕜 n (uncurry f) (x₀, g x₀)
hg : ContDiffAt 𝕜 m g x₀
hmn : m + 1 ≤ n
⊢ ContDiffAt 𝕜 m (fun x => fderivWithin 𝕜 (f x) univ (g x)) x₀

tactic: rw [preimage_univ]
state_before: 𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type ?u.1095737
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f✝ f₁ : E → F
g✝ : F → G
x x₀ : E
c : F
b : E × F → G
m n✝ : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
f : E → F → G
g : E → F
n : ℕ∞
hf : ContDiffAt 𝕜 n (uncurry f) (x₀, g x₀)
hg : ContDiffAt 𝕜 m g x₀
hmn : m + 1 ≤ n
⊢ univ ⊆ g ⁻¹' univ
Theorem: CategoryTheory.isDetector_def
File: Mathlib/CategoryTheory/Generator.lean

tactic: obtain rfl := Set.mem_singleton_iff.1 hH
state_before: C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
G : C
hG : IsDetector G
X Y : C
f : X ⟶ Y
hf : ∀ (h : G ⟶ Y), ∃! h', h' ≫ f = h
H : C
hH : H ∈ {G}
h : H ⟶ Y
⊢ ∃! h', h' ≫ f = h

tactic: exact hf h
state_before: C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
X Y : C
f : X ⟶ Y
H : C
h : H ⟶ Y
hG : IsDetector H
hf : ∀ (h : H ⟶ Y), ∃! h', h' ≫ f = h
hH : H ∈ {H}
⊢ ∃! h', h' ≫ f = h
Theorem: MvPolynomial.eval₂Hom_bind₁
File: Mathlib/Data/MvPolynomial/Monad.lean

tactic: rw [hom_bind₁, eval₂Hom_comp_C]
state_before: σ : Type u_4
τ : Type u_3
R : Type u_1
S : Type u_2
T : Type ?u.930023
inst✝² : CommSemiring R
inst✝¹ : CommSemiring S
inst✝ : CommSemiring T
f✝ : σ → MvPolynomial τ R
f : R →+* S
g : τ → S
h : σ → MvPolynomial τ R
φ : MvPolynomial σ R
⊢ ↑(eval₂Hom f g) (↑(bind₁ h) φ) = ↑(eval₂Hom f fun i => ↑(eval₂Hom f g) (h i)) φ
Theorem: Language.le_mul_congr
File: Mathlib/Computability/Language.lean

tactic: intro h₁ h₂ x hx
state_before: α : Type u_1
β : Type ?u.90470
γ : Type ?u.90473
l m : Language α
a b x : List α
l₁ l₂ m₁ m₂ : Language α
⊢ l₁ ≤ m₁ → l₂ ≤ m₂ → l₁ * l₂ ≤ m₁ * m₂

tactic: simp only [mul_def, exists_and_left, mem_image2, image_prod] at hx⊢
state_before: α : Type u_1
β : Type ?u.90470
γ : Type ?u.90473
l m : Language α
a b x✝ : List α
l₁ l₂ m₁ m₂ : Language α
h₁ : l₁ ≤ m₁
h₂ : l₂ ≤ m₂
x : List α
hx : x ∈ l₁ * l₂
⊢ x ∈ m₁ * m₂

tactic: tauto
state_before: α : Type u_1
β : Type ?u.90470
γ : Type ?u.90473
l m : Language α
a b x✝ : List α
l₁ l₂ m₁ m₂ : Language α
h₁ : l₁ ≤ m₁
h₂ : l₂ ≤ m₂
x : List α
hx : ∃ a, a ∈ l₁ ∧ ∃ x_1, x_1 ∈ l₂ ∧ a ++ x_1 = x
⊢ ∃ a, a ∈ m₁ ∧ ∃ x_1, x_1 ∈ m₂ ∧ a ++ x_1 = x
Theorem: ne_neg_of_mem_sphere
File: Mathlib/Analysis/NormedSpace/BallAction.lean

tactic: conv_lhs => rw [h]
state_before: 𝕜 : Type ?u.441668
𝕜' : Type ?u.441671
E : Type u_1
inst✝⁵ : NormedField 𝕜
inst✝⁴ : NormedField 𝕜'
inst✝³ : SeminormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
inst✝¹ : NormedSpace 𝕜' E
r✝ : ℝ
inst✝ : CharZero 𝕜
r : ℝ
hr : r ≠ 0
x : ↑(sphere 0 r)
h : x = -x
⊢ ↑x = -↑x
Theorem: Int.sign_neg
File: Std/Data/Int/Lemmas.lean

tactic: match z with | 0 | succ _ | -[_+1] => rfl
state_before: z : Int
⊢ sign (-z) = -sign z

tactic: rfl
state_before: z : Int
a✝ : Nat
⊢ sign (- -[a✝+1]) = -sign -[a✝+1]
Theorem: Finset.pred_card_le_card_erase
File: Mathlib/Data/Finset/Card.lean

tactic: by_cases h : a ∈ s
state_before: α : Type u_1
β : Type ?u.7358
s t : Finset α
a b : α
inst✝ : DecidableEq α
⊢ card s - 1 ≤ card (erase s a)

tactic: exact (card_erase_of_mem h).ge
state_before: case pos
α : Type u_1
β : Type ?u.7358
s t : Finset α
a b : α
inst✝ : DecidableEq α
h : a ∈ s
⊢ card s - 1 ≤ card (erase s a)

tactic: rw [erase_eq_of_not_mem h]
state_before: case neg
α : Type u_1
β : Type ?u.7358
s t : Finset α
a b : α
inst✝ : DecidableEq α
h : ¬a ∈ s
⊢ card s - 1 ≤ card (erase s a)

tactic: exact Nat.sub_le _ _
state_before: case neg
α : Type u_1
β : Type ?u.7358
s t : Finset α
a b : α
inst✝ : DecidableEq α
h : ¬a ∈ s
⊢ card s - 1 ≤ card s
Theorem: ext_nat
File: Mathlib/Data/Nat/Cast/Basic.lean

tactic: simp only [map_one f, map_one g]
state_before: α : Type ?u.58916
β : Type ?u.58919
R : Type u_2
S : Type ?u.58925
F : Type u_1
inst✝² : NonAssocSemiring R
inst✝¹ : NonAssocSemiring S
inst✝ : RingHomClass F ℕ R
f g : F
⊢ ↑f 1 = ↑g 1
Theorem: Continuous.continuousOn
File: Mathlib/Topology/ContinuousOn.lean

tactic: rw [continuous_iff_continuousOn_univ] at h
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.335557
δ : Type ?u.335560
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : α → β
s : Set α
h : Continuous f
⊢ ContinuousOn f s

tactic: exact h.mono (subset_univ _)
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.335557
δ : Type ?u.335560
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : α → β
s : Set α
h : ContinuousOn f univ
⊢ ContinuousOn f s
Theorem: Matrix.TransvectionStruct.toMatrix_reindexEquiv
File: Mathlib/LinearAlgebra/Matrix/Transvection.lean

tactic: rcases t with ⟨t_i, t_j, _⟩
state_before: n : Type u_1
p : Type u_2
R : Type u₂
𝕜 : Type ?u.77160
inst✝⁵ : Field 𝕜
inst✝⁴ : DecidableEq n
inst✝³ : DecidableEq p
inst✝² : CommRing R
i j : n
inst✝¹ : Fintype n
inst✝ : Fintype p
e : n ≃ p
t : TransvectionStruct n R
⊢ toMatrix (reindexEquiv e t) = ↑(reindexAlgEquiv R e) (toMatrix t)

tactic: ext (a b)
state_before: case mk
n : Type u_1
p : Type u_2
R : Type u₂
𝕜 : Type ?u.77160
inst✝⁵ : Field 𝕜
inst✝⁴ : DecidableEq n
inst✝³ : DecidableEq p
inst✝² : CommRing R
i j : n
inst✝¹ : Fintype n
inst✝ : Fintype p
e : n ≃ p
t_i t_j : n
hij✝ : t_i ≠ t_j
c✝ : R
⊢ toMatrix (reindexEquiv e { i := t_i, j := t_j, hij := hij✝, c := c✝ }) =
    ↑(reindexAlgEquiv R e) (toMatrix { i := t_i, j := t_j, hij := hij✝, c := c✝ })

tactic: simp only [reindexEquiv, transvection, mul_boole, Algebra.id.smul_eq_mul, toMatrix_mk,
  submatrix_apply, reindex_apply, DMatrix.add_apply, Pi.smul_apply, reindexAlgEquiv_apply]
state_before: case mk.a.h
n : Type u_1
p : Type u_2
R : Type u₂
𝕜 : Type ?u.77160
inst✝⁵ : Field 𝕜
inst✝⁴ : DecidableEq n
inst✝³ : DecidableEq p
inst✝² : CommRing R
i j : n
inst✝¹ : Fintype n
inst✝ : Fintype p
e : n ≃ p
t_i t_j : n
hij✝ : t_i ≠ t_j
c✝ : R
a b : p
⊢ toMatrix (reindexEquiv e { i := t_i, j := t_j, hij := hij✝, c := c✝ }) a b =
    ↑(reindexAlgEquiv R e) (toMatrix { i := t_i, j := t_j, hij := hij✝, c := c✝ }) a b

tactic: by_cases ha : e t_i = a <;> by_cases hb : e t_j = b <;> by_cases hab : a = b <;>
  simp [ha, hb, hab, ← e.apply_eq_iff_eq_symm_apply, stdBasisMatrix]
state_before: case mk.a.h
n : Type u_1
p : Type u_2
R : Type u₂
𝕜 : Type ?u.77160
inst✝⁵ : Field 𝕜
inst✝⁴ : DecidableEq n
inst✝³ : DecidableEq p
inst✝² : CommRing R
i j : n
inst✝¹ : Fintype n
inst✝ : Fintype p
e : n ≃ p
t_i t_j : n
hij✝ : t_i ≠ t_j
c✝ : R
a b : p
⊢ (1 + stdBasisMatrix (↑e t_i) (↑e t_j) c✝) a b = (1 + stdBasisMatrix t_i t_j c✝) (↑e.symm a) (↑e.symm b)
Theorem: Multiset.mem_ndinter
File: Mathlib/Data/Multiset/FinsetOps.lean

tactic: simp [ndinter, mem_filter]
state_before: α : Type u_1
inst✝ : DecidableEq α
s✝ s t : Multiset α
a : α
⊢ a ∈ ndinter s t ↔ a ∈ s ∧ a ∈ t
Theorem: WType.leftInverse_list
File: Mathlib/Data/W/Constructions.lean

tactic: simp only [toList, ofList, mk.injEq, heq_eq_eq, true_and]
state_before: γ : Type u
f : Listβ γ Listα.nil → WType (Listβ γ)
⊢ ofList γ (toList γ (mk Listα.nil f)) = mk Listα.nil f

tactic: ext x
state_before: γ : Type u
f : Listβ γ Listα.nil → WType (Listβ γ)
⊢ PEmpty.elim = f

tactic: cases x
state_before: case h
γ : Type u
f : Listβ γ Listα.nil → WType (Listβ γ)
x : PEmpty
⊢ PEmpty.elim x = f x

tactic: simp only [ofList, leftInverse_list (f PUnit.unit), mk.injEq, heq_eq_eq, true_and]
state_before: γ : Type u
x : γ
f : Listβ γ (Listα.cons x) → WType (Listβ γ)
⊢ ofList γ (toList γ (mk (Listα.cons x) f)) = mk (Listα.cons x) f

tactic: rfl
state_before: γ : Type u
x : γ
f : Listβ γ (Listα.cons x) → WType (Listβ γ)
⊢ (fun x => f PUnit.unit) = f
Theorem: derivWithin_const_sub
File: Mathlib/Analysis/Calculus/Deriv/Add.lean

tactic: simp [derivWithin, fderivWithin_const_sub hxs]
state_before: 𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type v
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type w
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L : Filter 𝕜
hxs : UniqueDiffWithinAt 𝕜 s x
c : F
⊢ derivWithin (fun y => c - f y) s x = -derivWithin f s x
Theorem: Matrix.kroneckerMap_diagonal_left
File: Mathlib/Data/Matrix/Kronecker.lean

tactic: ext (⟨i₁, i₂⟩⟨j₁, j₂⟩)
state_before: R : Type ?u.13740
α : Type u_1
α' : Type ?u.13746
β : Type u_6
β' : Type ?u.13752
γ : Type u_2
γ' : Type ?u.13758
l : Type u_3
m : Type u_4
n : Type u_5
p : Type ?u.13770
q : Type ?u.13773
r : Type ?u.13776
l' : Type ?u.13779
m' : Type ?u.13782
n' : Type ?u.13785
p' : Type ?u.13788
inst✝² : Zero α
inst✝¹ : Zero γ
inst✝ : DecidableEq l
f : α → β → γ
hf : ∀ (b : β), f 0 b = 0
a : l → α
B : Matrix m n β
⊢ kroneckerMap f (diagonal a) B =
    ↑(reindex (Equiv.prodComm m l) (Equiv.prodComm n l)) (blockDiagonal fun i => map B fun b => f (a i) b)

tactic: simp [diagonal, blockDiagonal, apply_ite f, ite_apply, hf]
state_before: case a.mk.h.mk
R : Type ?u.13740
α : Type u_1
α' : Type ?u.13746
β : Type u_6
β' : Type ?u.13752
γ : Type u_2
γ' : Type ?u.13758
l : Type u_3
m : Type u_4
n : Type u_5
p : Type ?u.13770
q : Type ?u.13773
r : Type ?u.13776
l' : Type ?u.13779
m' : Type ?u.13782
n' : Type ?u.13785
p' : Type ?u.13788
inst✝² : Zero α
inst✝¹ : Zero γ
inst✝ : DecidableEq l
f : α → β → γ
hf : ∀ (b : β), f 0 b = 0
a : l → α
B : Matrix m n β
i₁ : l
i₂ : m
j₁ : l
j₂ : n
⊢ kroneckerMap f (diagonal a) B (i₁, i₂) (j₁, j₂) =
    ↑(reindex (Equiv.prodComm m l) (Equiv.prodComm n l)) (blockDiagonal fun i => map B fun b => f (a i) b) (i₁, i₂)
      (j₁, j₂)
Theorem: Wcovby.le_succ
File: Mathlib/Order/SuccPred/Basic.lean

tactic: obtain h | rfl := h.covby_or_eq
state_before: α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : SuccOrder α
a b : α
h : a ⩿ b
⊢ b ≤ succ a

tactic: exact (Covby.succ_eq h).ge
state_before: case inl
α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : SuccOrder α
a b : α
h✝ : a ⩿ b
h : a ⋖ b
⊢ b ≤ succ a

tactic: exact le_succ _
state_before: case inr
α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : SuccOrder α
a : α
h : a ⩿ a
⊢ a ≤ succ a
Theorem: CategoryTheory.Limits.Fork.ofCone_π
File: Mathlib/CategoryTheory/Limits/Shapes/Equalizers.lean

tactic: aesop
state_before: C : Type u
inst✝ : Category C
X Y : C
f g : X ⟶ Y
F : WalkingParallelPair ⥤ C
t : Cone F
j : WalkingParallelPair
⊢ F.obj j = (parallelPair (F.map left) (F.map right)).obj j
Theorem: MeasureTheory.norm_setToFun_le_mul_norm
File: Mathlib/MeasureTheory/Integral/SetToL1.lean

tactic: rw [L1.setToFun_eq_setToL1]
state_before: α : Type u_1
E : Type u_2
F : Type u_3
F' : Type ?u.1686680
G : Type ?u.1686683
𝕜 : Type ?u.1686686
p : ℝ≥0∞
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace ℝ F
inst✝³ : NormedAddCommGroup F'
inst✝² : NormedSpace ℝ F'
inst✝¹ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
inst✝ : CompleteSpace F
T T' T'' : Set α → E →L[ℝ] F
C C' C'' : ℝ
f✝ g : α → E
hT : DominatedFinMeasAdditive μ T C
f : { x // x ∈ Lp E 1 }
hC : 0 ≤ C
⊢ ‖setToFun μ T hT ↑↑f‖ ≤ C * ‖f‖

tactic: exact L1.norm_setToL1_le_mul_norm hT hC f
state_before: α : Type u_1
E : Type u_2
F : Type u_3
F' : Type ?u.1686680
G : Type ?u.1686683
𝕜 : Type ?u.1686686
p : ℝ≥0∞
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace ℝ F
inst✝³ : NormedAddCommGroup F'
inst✝² : NormedSpace ℝ F'
inst✝¹ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
inst✝ : CompleteSpace F
T T' T'' : Set α → E →L[ℝ] F
C C' C'' : ℝ
f✝ g : α → E
hT : DominatedFinMeasAdditive μ T C
f : { x // x ∈ Lp E 1 }
hC : 0 ≤ C
⊢ ‖↑(L1.setToL1 hT) f‖ ≤ C * ‖f‖
Theorem: exists_nat_ge
File: Mathlib/Algebra/Order/Archimedean.lean

tactic: nontriviality α
state_before: α : Type u_1
inst✝¹ : StrictOrderedSemiring α
inst✝ : Archimedean α
x : α
⊢ ∃ n, x ≤ ↑n

tactic: exact (exists_nat_gt x).imp fun n => le_of_lt
state_before: α : Type u_1
inst✝² : StrictOrderedSemiring α
inst✝¹ : Archimedean α
x : α
inst✝ : Nontrivial α
⊢ ∃ n, x ≤ ↑n
Theorem: dist_mul_mul_le
File: Mathlib/Analysis/Normed/Group/Basic.lean

tactic: simpa only [dist_mul_left, dist_mul_right] using dist_triangle (a₁ * a₂) (b₁ * a₂) (b₁ * b₂)
state_before: 𝓕 : Type ?u.641456
𝕜 : Type ?u.641459
α : Type ?u.641462
ι : Type ?u.641465
κ : Type ?u.641468
E : Type u_1
F : Type ?u.641474
G : Type ?u.641477
inst✝¹ : SeminormedCommGroup E
inst✝ : SeminormedCommGroup F
a a₁✝ a₂✝ b b₁✝ b₂✝ : E
r r₁ r₂ : ℝ
a₁ a₂ b₁ b₂ : E
⊢ dist (a₁ * a₂) (b₁ * b₂) ≤ dist a₁ b₁ + dist a₂ b₂
Theorem: LieIdeal.incl_isIdealMorphism
File: Mathlib/Algebra/Lie/Submodule.lean

tactic: rw [I.incl.isIdealMorphism_def, incl_idealRange]
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'
⊢ LieHom.IsIdealMorphism (incl I)

tactic: exact (I : LieSubalgebra R L).incl_range.symm
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'
⊢ ↑R L I = LieHom.range (incl I)
Theorem: Setoid.eqvGen_le
File: Mathlib/Data/Setoid/Basic.lean

tactic: rw [eqvGen_eq]
state_before: α : Type u_1
β : Type ?u.10696
r : α → α → Prop
s : Setoid α
h : ∀ (x y : α), r x y → Rel s x y
⊢ EqvGen.Setoid r ≤ s

tactic: exact sInf_le h
state_before: α : Type u_1
β : Type ?u.10696
r : α → α → Prop
s : Setoid α
h : ∀ (x y : α), r x y → Rel s x y
⊢ sInf {s | ∀ ⦃x y : α⦄, r x y → Rel s x y} ≤ s
Theorem: Ordnode.insert_eq_insertWith
File: Mathlib/Data/Ordmap/Ordset.lean

tactic: unfold Ordnode.insert insertWith
state_before: α : Type u_1
inst✝¹ : Preorder α
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
x : α
size✝ : ℕ
l : Ordnode α
y : α
r : Ordnode α
⊢ Ordnode.insert x (node size✝ l y r) = insertWith (fun x_1 => x) x (node size✝ l y r)

tactic: cases cmpLE x y <;> simp [insert_eq_insertWith]
state_before: α : Type u_1
inst✝¹ : Preorder α
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
x : α
size✝ : ℕ
l : Ordnode α
y : α
r : Ordnode α
⊢ (match cmpLE x y with
    | Ordering.lt => balanceL (Ordnode.insert x l) y r
    | Ordering.eq => node size✝ l x r
    | Ordering.gt => balanceR l y (Ordnode.insert x r)) =
    match cmpLE x y with
    | Ordering.lt => balanceL (insertWith (fun x_1 => x) x l) y r
    | Ordering.eq => node size✝ l x r
    | Ordering.gt => balanceR l y (insertWith (fun x_1 => x) x r)