tasksource/leandojo huggingface dataset:
Theorem: MeasureTheory.memℒp_finset_sum'
File: Mathlib/MeasureTheory/Function/LpSeminorm.lean

tactic: convert memℒp_finset_sum s hf using 1
state_before: α : Type u_3
E : Type u_2
F : Type ?u.5045186
G : Type ?u.5045189
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
ι : Type u_1
s : Finset ι
f : ι → α → E
hf : ∀ (i : ι), i ∈ s → Memℒp (f i) p
⊢ Memℒp (∑ i in s, f i) p

tactic: ext x
state_before: case h.e'_5
α : Type u_3
E : Type u_2
F : Type ?u.5045186
G : Type ?u.5045189
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
ι : Type u_1
s : Finset ι
f : ι → α → E
hf : ∀ (i : ι), i ∈ s → Memℒp (f i) p
⊢ ∑ i in s, f i = fun a => ∑ i in s, f i a

tactic: simp
state_before: case h.e'_5.h
α : Type u_3
E : Type u_2
F : Type ?u.5045186
G : Type ?u.5045189
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
ι : Type u_1
s : Finset ι
f : ι → α → E
hf : ∀ (i : ι), i ∈ s → Memℒp (f i) p
x : α
⊢ Finset.sum s (fun i => f i) x = ∑ i in s, f i x
Theorem: TypeVec.diag_sub_val
File: Mathlib/Data/TypeVec.lean

tactic: ext i x
state_before: n✝ n : ℕ
α : TypeVec n
⊢ subtypeVal (repeatEq α) ⊚ diagSub = prod.diag

tactic: induction' i with _ _ _ i_ih
state_before: case a.h
n✝ n : ℕ
α : TypeVec n
i : Fin2 n
x : α i
⊢ (subtypeVal (repeatEq α) ⊚ diagSub) i x = prod.diag i x

tactic: simp [prod.diag, diagSub, repeatEq, subtypeVal, comp]
state_before: case a.h.fz
n✝¹ n : ℕ
α✝ : TypeVec n
i : Fin2 n
x✝ : α✝ i
n✝ : ℕ
α : TypeVec (succ n✝)
x : α Fin2.fz
⊢ (subtypeVal (repeatEq α) ⊚ diagSub) Fin2.fz x = prod.diag Fin2.fz x

case a.h.fs
n✝¹ n : ℕ
α✝ : TypeVec n
i : Fin2 n
x✝ : α✝ i
n✝ : ℕ
a✝ : Fin2 n✝
i_ih : ∀ {α : TypeVec n✝} (x : α a✝), (subtypeVal (repeatEq α) ⊚ diagSub) a✝ x = prod.diag a✝ x
α : TypeVec (succ n✝)
x : α (Fin2.fs a✝)
⊢ (subtypeVal (repeatEq α) ⊚ diagSub) (Fin2.fs a✝) x = prod.diag (Fin2.fs a✝) x

tactic: apply @i_ih (drop α)
state_before: case a.h.fs
n✝¹ n : ℕ
α✝ : TypeVec n
i : Fin2 n
x✝ : α✝ i
n✝ : ℕ
a✝ : Fin2 n✝
i_ih : ∀ {α : TypeVec n✝} (x : α a✝), (subtypeVal (repeatEq α) ⊚ diagSub) a✝ x = prod.diag a✝ x
α : TypeVec (succ n✝)
x : α (Fin2.fs a✝)
⊢ (subtypeVal (repeatEq α) ⊚ diagSub) (Fin2.fs a✝) x = prod.diag (Fin2.fs a✝) x
Theorem: StrictConvex.add_smul_sub_mem
File: Mathlib/Analysis/Convex/Strict.lean

tactic: apply h.openSegment_subset hx hy hxy
state_before: 𝕜 : Type u_1
𝕝 : Type ?u.195310
E : Type u_2
F : Type ?u.195316
β : Type ?u.195319
inst✝⁶ : OrderedRing 𝕜
inst✝⁵ : TopologicalSpace E
inst✝⁴ : TopologicalSpace F
inst✝³ : AddCommGroup E
inst✝² : AddCommGroup F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
s t✝ : Set E
x y : E
h : StrictConvex 𝕜 s
hx : x ∈ s
hy : y ∈ s
hxy : x ≠ y
t : 𝕜
ht₀ : 0 < t
ht₁ : t < 1
⊢ x + t • (y - x) ∈ interior s

tactic: rw [openSegment_eq_image']
state_before: case a
𝕜 : Type u_1
𝕝 : Type ?u.195310
E : Type u_2
F : Type ?u.195316
β : Type ?u.195319
inst✝⁶ : OrderedRing 𝕜
inst✝⁵ : TopologicalSpace E
inst✝⁴ : TopologicalSpace F
inst✝³ : AddCommGroup E
inst✝² : AddCommGroup F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
s t✝ : Set E
x y : E
h : StrictConvex 𝕜 s
hx : x ∈ s
hy : y ∈ s
hxy : x ≠ y
t : 𝕜
ht₀ : 0 < t
ht₁ : t < 1
⊢ x + t • (y - x) ∈ openSegment 𝕜 x y

tactic: exact mem_image_of_mem _ ⟨ht₀, ht₁⟩
state_before: case a
𝕜 : Type u_1
𝕝 : Type ?u.195310
E : Type u_2
F : Type ?u.195316
β : Type ?u.195319
inst✝⁶ : OrderedRing 𝕜
inst✝⁵ : TopologicalSpace E
inst✝⁴ : TopologicalSpace F
inst✝³ : AddCommGroup E
inst✝² : AddCommGroup F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
s t✝ : Set E
x y : E
h : StrictConvex 𝕜 s
hx : x ∈ s
hy : y ∈ s
hxy : x ≠ y
t : 𝕜
ht₀ : 0 < t
ht₁ : t < 1
⊢ x + t • (y - x) ∈ (fun θ => x + θ • (y - x)) '' Ioo 0 1
Theorem: Finset.affineCombination_affineCombinationLineMapWeights
File: Mathlib/LinearAlgebra/AffineSpace/Combination.lean

tactic: rw [affineCombinationLineMapWeights, ← weightedVSub_vadd_affineCombination,
  weightedVSub_const_smul, s.affineCombination_affineCombinationSingleWeights k p hi,
  s.weightedVSub_weightedVSubVSubWeights k p hj hi, AffineMap.lineMap_apply]
state_before: k : Type u_3
V : Type u_4
P : Type u_2
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
S : AffineSpace V P
ι : Type u_1
s : Finset ι
ι₂ : Type ?u.457704
s₂ : Finset ι₂
inst✝ : DecidableEq ι
p : ι → P
i j : ι
hi : i ∈ s
hj : j ∈ s
c : k
⊢ ↑(affineCombination k s p) (affineCombinationLineMapWeights i j c) = ↑(AffineMap.lineMap (p i) (p j)) c
Theorem: List.dropLast_append_cons
File: Std/Data/List/Lemmas.lean

tactic: induction l₁ <;> simp [*]
state_before: α✝ : Type u_1
l₁ : List α✝
b : α✝
l₂ : List α✝
⊢ dropLast (l₁ ++ b :: l₂) = l₁ ++ dropLast (b :: l₂)
Theorem: Orthonormal.inner_right_finsupp
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

tactic: classical!
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.1906807
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
dec_E : DecidableEq E
ι : Type u_3
dec_ι : DecidableEq ι
v : ι → E
hv : Orthonormal 𝕜 v
l : ι →₀ 𝕜
i : ι
⊢ inner (v i) (↑(Finsupp.total ι E 𝕜 v) l) = ↑l i

tactic: simpa [Finsupp.total_apply, Finsupp.inner_sum, orthonormal_iff_ite.mp hv] using Eq.symm
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.1906807
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
dec_E : DecidableEq E
ι : Type u_3
dec_ι : DecidableEq ι
v : ι → E
hv : Orthonormal 𝕜 v
l : ι →₀ 𝕜
i : ι
em✝ : (a : Prop) → Decidable a
⊢ inner (v i) (↑(Finsupp.total ι E 𝕜 v) l) = ↑l i
Theorem: TopologicalSpace.nhds_mkOfNhds_single
File: Mathlib/Topology/Order.lean

tactic: refine' nhds_mkOfNhds _ _ (le_update_iff.mpr ⟨h, fun _ _ => le_rfl⟩) fun a s hs => _
state_before: α : Type u
inst✝ : DecidableEq α
a₀ : α
l : Filter α
h : pure a₀ ≤ l
b : α
⊢ 𝓝 b = update pure a₀ l b

tactic: rcases eq_or_ne a a₀ with (rfl | ha)
state_before: α : Type u
inst✝ : DecidableEq α
a₀ : α
l : Filter α
h : pure a₀ ≤ l
b a : α
s : Set α
hs : s ∈ update pure a₀ l a
⊢ ∃ t, t ∈ update pure a₀ l a ∧ t ⊆ s ∧ ∀ (a' : α), a' ∈ t → s ∈ update pure a₀ l a'

tactic: refine' ⟨s, hs, Subset.rfl, fun b hb => _⟩
state_before: case inl
α : Type u
inst✝ : DecidableEq α
l : Filter α
b a : α
s : Set α
h : pure a ≤ l
hs : s ∈ update pure a l a
⊢ ∃ t, t ∈ update pure a l a ∧ t ⊆ s ∧ ∀ (a' : α), a' ∈ t → s ∈ update pure a l a'

tactic: rcases eq_or_ne b a with (rfl | hb)
state_before: case inl
α : Type u
inst✝ : DecidableEq α
l : Filter α
b✝ a : α
s : Set α
h : pure a ≤ l
hs : s ∈ update pure a l a
b : α
hb : b ∈ s
⊢ s ∈ update pure a l b

tactic: exact hs
state_before: case inl.inl
α : Type u
inst✝ : DecidableEq α
l : Filter α
b✝ : α
s : Set α
b : α
hb : b ∈ s
h : pure b ≤ l
hs : s ∈ update pure b l b
⊢ s ∈ update pure b l b

tactic: rwa [update_noteq hb]
state_before: case inl.inr
α : Type u
inst✝ : DecidableEq α
l : Filter α
b✝ a : α
s : Set α
h : pure a ≤ l
hs : s ∈ update pure a l a
b : α
hb✝ : b ∈ s
hb : b ≠ a
⊢ s ∈ update pure a l b

tactic: have hs' := hs
state_before: case inr
α : Type u
inst✝ : DecidableEq α
a₀ : α
l : Filter α
h : pure a₀ ≤ l
b a : α
s : Set α
hs : s ∈ update pure a₀ l a
ha : a ≠ a₀
⊢ ∃ t, t ∈ update pure a₀ l a ∧ t ⊆ s ∧ ∀ (a' : α), a' ∈ t → s ∈ update pure a₀ l a'

tactic: rw [update_noteq ha] at hs⊢
state_before: case inr
α : Type u
inst✝ : DecidableEq α
a₀ : α
l : Filter α
h : pure a₀ ≤ l
b a : α
s : Set α
hs : s ∈ update pure a₀ l a
ha : a ≠ a₀
hs' : s ∈ update pure a₀ l a
⊢ ∃ t, t ∈ update pure a₀ l a ∧ t ⊆ s ∧ ∀ (a' : α), a' ∈ t → s ∈ update pure a₀ l a'

tactic: exact ⟨{a}, rfl, singleton_subset_iff.mpr hs, forall_eq.2 hs'⟩
state_before: case inr
α : Type u
inst✝ : DecidableEq α
a₀ : α
l : Filter α
h : pure a₀ ≤ l
b a : α
s : Set α
hs : s ∈ pure a
ha : a ≠ a₀
hs' : s ∈ update pure a₀ l a
⊢ ∃ t, t ∈ pure a ∧ t ⊆ s ∧ ∀ (a' : α), a' ∈ t → s ∈ update pure a₀ l a'
Theorem: isOpen_iff_forall_mem_open
File: Mathlib/Topology/Basic.lean

tactic: rw [← subset_interior_iff_isOpen]
state_before: α : Type u
β : Type v
ι : Sort w
a : α
s s₁ s₂ t : Set α
p p₁ p₂ : α → Prop
inst✝ : TopologicalSpace α
⊢ IsOpen s ↔ ∀ (x : α), x ∈ s → ∃ t, t ⊆ s ∧ IsOpen t ∧ x ∈ t

tactic: simp only [subset_def, mem_interior]
state_before: α : Type u
β : Type v
ι : Sort w
a : α
s s₁ s₂ t : Set α
p p₁ p₂ : α → Prop
inst✝ : TopologicalSpace α
⊢ s ⊆ interior s ↔ ∀ (x : α), x ∈ s → ∃ t, t ⊆ s ∧ IsOpen t ∧ x ∈ t
Theorem: Filter.coprod_bot
File: Mathlib/Order/Filter/Prod.lean

tactic: simp [Filter.coprod]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.58577
δ : Type ?u.58580
ι : Sort ?u.58583
f : Filter α
g : Filter β
l : Filter α
⊢ Filter.coprod l ⊥ = comap Prod.fst l
Theorem: OpenSubgroup.isClosed
File: Mathlib/Topology/Algebra/OpenSubgroup.lean

tactic: apply isOpen_compl_iff.1
state_before: G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
U✝ V : OpenSubgroup G
g : G
inst✝ : ContinuousMul G
U : OpenSubgroup G
⊢ IsClosed ↑U

tactic: refine' isOpen_iff_forall_mem_open.2 fun x hx => ⟨(fun y => y * x⁻¹) ⁻¹' U, _, _, _⟩
state_before: G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
U✝ V : OpenSubgroup G
g : G
inst✝ : ContinuousMul G
U : OpenSubgroup G
⊢ IsOpen (↑Uᶜ)

tactic: refine' fun u hux hu => hx _
state_before: case refine'_1
G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
U✝ V : OpenSubgroup G
g : G
inst✝ : ContinuousMul G
U : OpenSubgroup G
x : G
hx : x ∈ ↑Uᶜ
⊢ (fun y => y * x⁻¹) ⁻¹' ↑U ⊆ ↑Uᶜ

tactic: simp only [Set.mem_preimage, SetLike.mem_coe] at hux hu ⊢
state_before: case refine'_1
G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
U✝ V : OpenSubgroup G
g : G
inst✝ : ContinuousMul G
U : OpenSubgroup G
x : G
hx : x ∈ ↑Uᶜ
u : G
hux : u ∈ (fun y => y * x⁻¹) ⁻¹' ↑U
hu : u ∈ ↑U
⊢ x ∈ ↑U

tactic: convert U.mul_mem (U.inv_mem hux) hu
state_before: case refine'_1
G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
U✝ V : OpenSubgroup G
g : G
inst✝ : ContinuousMul G
U : OpenSubgroup G
x : G
hx : x ∈ ↑Uᶜ
u : G
hux : u * x⁻¹ ∈ U
hu : u ∈ U
⊢ x ∈ U

tactic: simp
state_before: case a
G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
U✝ V : OpenSubgroup G
g : G
inst✝ : ContinuousMul G
U : OpenSubgroup G
x : G
hx : x ∈ ↑Uᶜ
u : G
hux : u * x⁻¹ ∈ U
hu : u ∈ U
⊢ x ∈ U ↔ (u * x⁻¹)⁻¹ * u ∈ ↑U

tactic: exact U.isOpen.preimage (continuous_mul_right _)
state_before: case refine'_2
G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
U✝ V : OpenSubgroup G
g : G
inst✝ : ContinuousMul G
U : OpenSubgroup G
x : G
hx : x ∈ ↑Uᶜ
⊢ IsOpen ((fun y => y * x⁻¹) ⁻¹' ↑U)

tactic: simp [one_mem]
state_before: case refine'_3
G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
U✝ V : OpenSubgroup G
g : G
inst✝ : ContinuousMul G
U : OpenSubgroup G
x : G
hx : x ∈ ↑Uᶜ
⊢ x ∈ (fun y => y * x⁻¹) ⁻¹' ↑U
Theorem: List.length_dropLast
File: Mathlib/Data/List/Basic.lean

tactic: rw [dropLast, length_cons, length_cons, length_dropLast (b::l), succ_sub_one, length_cons,
  succ_sub_one]
state_before: ι : Type ?u.28091
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
a b : α
l : List α
⊢ length (dropLast (a :: b :: l)) = length (a :: b :: l) - 1

tactic: simp
state_before: case x_2
ι : Type ?u.28091
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
a b : α
l : List α
⊢ b :: l = [] → False
Theorem: Int.eq_mul_of_div_eq_right
File: Std/Data/Int/DivMod.lean

tactic: rw [← H2, Int.mul_div_cancel' H1]
state_before: a b c : Int
H1 : b ∣ a
H2 : div a b = c
⊢ a = b * c
Theorem: Relation.ReflGen.to_reflTransGen
File: Mathlib/Logic/Relation.lean

tactic: rfl
state_before: α : Type u_1
β : Type ?u.15353
γ : Type ?u.15356
δ : Type ?u.15359
r : α → α → Prop
a✝ b c d a : α
⊢ ReflTransGen r a a
Theorem: FreeCommRing.exists_finset_support
File: Mathlib/RingTheory/FreeCommRing.lean

tactic: rwa [Set.Finite.coe_toFinset]
state_before: α : Type u
β : Type v
f : α → β
x : FreeCommRing α
s : Set α
hfs : Set.Finite s
hxs : IsSupported x s
⊢ IsSupported x ↑(Set.Finite.toFinset hfs)
Theorem: Int.cast_le_neg_one_of_neg
File: Mathlib/Data/Int/Cast/Lemmas.lean

tactic: rw [← Int.cast_one, ← Int.cast_neg, cast_le]
state_before: F : Type ?u.27406
ι : Type ?u.27409
α : Type u_1
β : Type ?u.27415
inst✝ : LinearOrderedRing α
a b n : ℤ
h : a < 0
⊢ ↑a ≤ -1

tactic: exact Int.le_sub_one_of_lt h
state_before: F : Type ?u.27406
ι : Type ?u.27409
α : Type u_1
β : Type ?u.27415
inst✝ : LinearOrderedRing α
a b n : ℤ
h : a < 0
⊢ a ≤ -1
Theorem: Lean.Compiler.LCNF.Phase.le_refl
File: src/lean/Lean/Compiler/LCNF/PassManager.lean

tactic: cases p <;> decide
state_before: p : Phase
⊢ p ≤ p
Theorem: ENNReal.rpow_eq_zero_iff
File: Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean

tactic: cases' x with x
state_before: x : ℝ≥0∞
y : ℝ
⊢ x ^ y = 0 ↔ x = 0 ∧ 0 < y ∨ x = ⊤ ∧ y < 0

tactic: rcases lt_trichotomy y 0 with (H | H | H) <;>
  simp [H, top_rpow_of_neg, top_rpow_of_pos, le_of_lt]
state_before: case none
y : ℝ
⊢ none ^ y = 0 ↔ none = 0 ∧ 0 < y ∨ none = ⊤ ∧ y < 0

tactic: by_cases h : x = 0
state_before: case some
y : ℝ
x : ℝ≥0
⊢ Option.some x ^ y = 0 ↔ Option.some x = 0 ∧ 0 < y ∨ Option.some x = ⊤ ∧ y < 0

tactic: rcases lt_trichotomy y 0 with (H | H | H) <;>
  simp [h, H, zero_rpow_of_neg, zero_rpow_of_pos, le_of_lt]
state_before: case pos
y : ℝ
x : ℝ≥0
h : x = 0
⊢ Option.some x ^ y = 0 ↔ Option.some x = 0 ∧ 0 < y ∨ Option.some x = ⊤ ∧ y < 0

tactic: simp [coe_rpow_of_ne_zero h, h]
state_before: case neg
y : ℝ
x : ℝ≥0
h : ¬x = 0
⊢ Option.some x ^ y = 0 ↔ Option.some x = 0 ∧ 0 < y ∨ Option.some x = ⊤ ∧ y < 0
Theorem: Tuple.bubble_sort_induction'
File: Mathlib/Data/Fin/Tuple/BubbleSortInduction.lean

tactic: letI := @Preorder.lift _ (Lex (Fin n → α)) _ fun σ : Equiv.Perm (Fin n) => toLex (f ∘ σ)
state_before: n : ℕ
α : Type u_1
inst✝ : LinearOrder α
f : Fin n → α
P : (Fin n → α) → Prop
hf : P f
h :
  ∀ (σ : Equiv.Perm (Fin n)) (i j : Fin n),
    i < j → (f ∘ ↑σ) j < (f ∘ ↑σ) i → P (f ∘ ↑σ) → P (f ∘ ↑σ ∘ ↑(Equiv.swap i j))
⊢ P (f ∘ ↑(sort f))

tactic: refine'
  @WellFounded.induction_bot' _ _ _ (@Finite.Preorder.wellFounded_lt (Equiv.Perm (Fin n)) _ _)
    (Equiv.refl _) (sort f) P (fun σ => f ∘ σ) (fun σ hσ hfσ => _) hf
state_before: n : ℕ
α : Type u_1
inst✝ : LinearOrder α
f : Fin n → α
P : (Fin n → α) → Prop
hf : P f
h :
  ∀ (σ : Equiv.Perm (Fin n)) (i j : Fin n),
    i < j → (f ∘ ↑σ) j < (f ∘ ↑σ) i → P (f ∘ ↑σ) → P (f ∘ ↑σ ∘ ↑(Equiv.swap i j))
this : Preorder (Equiv.Perm (Fin n)) := Preorder.lift fun σ => ↑toLex (f ∘ ↑σ)
⊢ P (f ∘ ↑(sort f))

tactic: obtain ⟨i, j, hij₁, hij₂⟩ := antitone_pair_of_not_sorted' hσ
state_before: n : ℕ
α : Type u_1
inst✝ : LinearOrder α
f : Fin n → α
P : (Fin n → α) → Prop
hf : P f
h :
  ∀ (σ : Equiv.Perm (Fin n)) (i j : Fin n),
    i < j → (f ∘ ↑σ) j < (f ∘ ↑σ) i → P (f ∘ ↑σ) → P (f ∘ ↑σ ∘ ↑(Equiv.swap i j))
this : Preorder (Equiv.Perm (Fin n)) := Preorder.lift fun σ => ↑toLex (f ∘ ↑σ)
σ : Equiv.Perm (Fin n)
hσ : (fun σ => f ∘ ↑σ) σ ≠ (fun σ => f ∘ ↑σ) (sort f)
hfσ : P ((fun σ => f ∘ ↑σ) σ)
⊢ ∃ c, c < σ ∧ P ((fun σ => f ∘ ↑σ) c)

tactic: exact ⟨σ * Equiv.swap i j, Pi.lex_desc hij₁ hij₂, h σ i j hij₁ hij₂ hfσ⟩
state_before: case intro.intro.intro
n : ℕ
α : Type u_1
inst✝ : LinearOrder α
f : Fin n → α
P : (Fin n → α) → Prop
hf : P f
h :
  ∀ (σ : Equiv.Perm (Fin n)) (i j : Fin n),
    i < j → (f ∘ ↑σ) j < (f ∘ ↑σ) i → P (f ∘ ↑σ) → P (f ∘ ↑σ ∘ ↑(Equiv.swap i j))
this : Preorder (Equiv.Perm (Fin n)) := Preorder.lift fun σ => ↑toLex (f ∘ ↑σ)
σ : Equiv.Perm (Fin n)
hσ : (fun σ => f ∘ ↑σ) σ ≠ (fun σ => f ∘ ↑σ) (sort f)
hfσ : P ((fun σ => f ∘ ↑σ) σ)
i j : Fin n
hij₁ : i < j
hij₂ : (f ∘ ↑σ) j < (f ∘ ↑σ) i
⊢ ∃ c, c < σ ∧ P ((fun σ => f ∘ ↑σ) c)
Theorem: RatFunc.laurentAux_algebraMap
File: Mathlib/FieldTheory/Laurent.lean

tactic: rw [← mk_one, ← mk_one, mk_eq_div, laurentAux_div, mk_eq_div, taylor_one, map_one, map_one,
  map_one]
state_before: R : Type u
inst✝ : CommRing R
hdomain : IsDomain R
r s : R
p q : R[X]
f : RatFunc R
⊢ ↑(laurentAux r) (↑(algebraMap R[X] (RatFunc R)) p) = ↑(algebraMap ((fun x => R[X]) p) (RatFunc R)) (↑(taylor r) p)
Theorem: Sym2.map.injective
File: Mathlib/Data/Sym/Sym2.lean

tactic: intro z z'
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.17037
f : α → β
hinj : Injective f
⊢ Injective (map f)

tactic: refine' Quotient.ind₂ (fun z z' => _) z z'
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.17037
f : α → β
hinj : Injective f
z z' : Sym2 α
⊢ map f z = map f z' → z = z'

tactic: cases' z with x y
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.17037
f : α → β
hinj : Injective f
z✝ z'✝ : Sym2 α
z z' : α × α
⊢ map f (Quotient.mk (Rel.setoid α) z) = map f (Quotient.mk (Rel.setoid α) z') →
    Quotient.mk (Rel.setoid α) z = Quotient.mk (Rel.setoid α) z'

tactic: cases' z' with x' y'
state_before: case mk
α : Type u_1
β : Type u_2
γ : Type ?u.17037
f : α → β
hinj : Injective f
z z'✝ : Sym2 α
z' : α × α
x y : α
⊢ map f (Quotient.mk (Rel.setoid α) (x, y)) = map f (Quotient.mk (Rel.setoid α) z') →
    Quotient.mk (Rel.setoid α) (x, y) = Quotient.mk (Rel.setoid α) z'

tactic: repeat' rw [map_pair_eq, eq_iff]
state_before: case mk.mk
α : Type u_1
β : Type u_2
γ : Type ?u.17037
f : α → β
hinj : Injective f
z z' : Sym2 α
x y x' y' : α
⊢ map f (Quotient.mk (Rel.setoid α) (x, y)) = map f (Quotient.mk (Rel.setoid α) (x', y')) →
    Quotient.mk (Rel.setoid α) (x, y) = Quotient.mk (Rel.setoid α) (x', y')

tactic: rintro (h | h) <;> simp [hinj h.1, hinj h.2]
state_before: case mk.mk
α : Type u_1
β : Type u_2
γ : Type ?u.17037
f : α → β
hinj : Injective f
z z' : Sym2 α
x y x' y' : α
⊢ f x = f x' ∧ f y = f y' ∨ f x = f y' ∧ f y = f x' → x = x' ∧ y = y' ∨ x = y' ∧ y = x'

tactic: rw [map_pair_eq, eq_iff]
state_before: case mk.mk
α : Type u_1
β : Type u_2
γ : Type ?u.17037
f : α → β
hinj : Injective f
z z' : Sym2 α
x y x' y' : α
⊢ f x = f x' ∧ f y = f y' ∨ f x = f y' ∧ f y = f x' → x = x' ∧ y = y' ∨ x = y' ∧ y = x'
Theorem: Matrix.toLinearMap₂'_apply'
File: Mathlib/LinearAlgebra/Matrix/SesquilinearForm.lean

tactic: simp_rw [Matrix.toLinearMap₂'_apply, Matrix.dotProduct, Matrix.mulVec, Matrix.dotProduct]
state_before: R : Type u_3
R₁ : Type ?u.308004
R₂ : Type ?u.308007
M✝ : Type ?u.308010
M₁ : Type ?u.308013
M₂ : Type ?u.308016
M₁' : Type ?u.308019
M₂' : Type ?u.308022
n : Type u_1
m : Type u_2
n' : Type ?u.308031
m' : Type ?u.308034
ι : Type ?u.308037
inst✝⁶ : CommRing R
inst✝⁵ : CommRing R₁
inst✝⁴ : CommRing R₂
inst✝³ : Fintype n
inst✝² : Fintype m
inst✝¹ : DecidableEq n
inst✝ : DecidableEq m
σ₁ : R₁ →+* R
σ₂ : R₂ →+* R
M : Matrix n m R
v : n → R
w : m → R
⊢ ↑(↑(↑toLinearMap₂' M) v) w = v ⬝ᵥ mulVec M w

tactic: refine' Finset.sum_congr rfl fun _ _ => _
state_before: R : Type u_3
R₁ : Type ?u.308004
R₂ : Type ?u.308007
M✝ : Type ?u.308010
M₁ : Type ?u.308013
M₂ : Type ?u.308016
M₁' : Type ?u.308019
M₂' : Type ?u.308022
n : Type u_1
m : Type u_2
n' : Type ?u.308031
m' : Type ?u.308034
ι : Type ?u.308037
inst✝⁶ : CommRing R
inst✝⁵ : CommRing R₁
inst✝⁴ : CommRing R₂
inst✝³ : Fintype n
inst✝² : Fintype m
inst✝¹ : DecidableEq n
inst✝ : DecidableEq m
σ₁ : R₁ →+* R
σ₂ : R₂ →+* R
M : Matrix n m R
v : n → R
w : m → R
⊢ ∑ i : n, ∑ j : m, v i * M i j * w j = ∑ x : n, v x * ∑ x_1 : m, M x x_1 * w x_1

tactic: rw [Finset.mul_sum]
state_before: R : Type u_3
R₁ : Type ?u.308004
R₂ : Type ?u.308007
M✝ : Type ?u.308010
M₁ : Type ?u.308013
M₂ : Type ?u.308016
M₁' : Type ?u.308019
M₂' : Type ?u.308022
n : Type u_1
m : Type u_2
n' : Type ?u.308031
m' : Type ?u.308034
ι : Type ?u.308037
inst✝⁶ : CommRing R
inst✝⁵ : CommRing R₁
inst✝⁴ : CommRing R₂
inst✝³ : Fintype n
inst✝² : Fintype m
inst✝¹ : DecidableEq n
inst✝ : DecidableEq m
σ₁ : R₁ →+* R
σ₂ : R₂ →+* R
M : Matrix n m R
v : n → R
w : m → R
x✝¹ : n
x✝ : x✝¹ ∈ univ
⊢ ∑ j : m, v x✝¹ * M x✝¹ j * w j = v x✝¹ * ∑ x : m, M x✝¹ x * w x

tactic: refine' Finset.sum_congr rfl fun _ _ => _
state_before: R : Type u_3
R₁ : Type ?u.308004
R₂ : Type ?u.308007
M✝ : Type ?u.308010
M₁ : Type ?u.308013
M₂ : Type ?u.308016
M₁' : Type ?u.308019
M₂' : Type ?u.308022
n : Type u_1
m : Type u_2
n' : Type ?u.308031
m' : Type ?u.308034
ι : Type ?u.308037
inst✝⁶ : CommRing R
inst✝⁵ : CommRing R₁
inst✝⁴ : CommRing R₂
inst✝³ : Fintype n
inst✝² : Fintype m
inst✝¹ : DecidableEq n
inst✝ : DecidableEq m
σ₁ : R₁ →+* R
σ₂ : R₂ →+* R
M : Matrix n m R
v : n → R
w : m → R
x✝¹ : n
x✝ : x✝¹ ∈ univ
⊢ ∑ j : m, v x✝¹ * M x✝¹ j * w j = ∑ x : m, v x✝¹ * (M x✝¹ x * w x)

tactic: rw [← mul_assoc]
state_before: R : Type u_3
R₁ : Type ?u.308004
R₂ : Type ?u.308007
M✝ : Type ?u.308010
M₁ : Type ?u.308013
M₂ : Type ?u.308016
M₁' : Type ?u.308019
M₂' : Type ?u.308022
n : Type u_1
m : Type u_2
n' : Type ?u.308031
m' : Type ?u.308034
ι : Type ?u.308037
inst✝⁶ : CommRing R
inst✝⁵ : CommRing R₁
inst✝⁴ : CommRing R₂
inst✝³ : Fintype n
inst✝² : Fintype m
inst✝¹ : DecidableEq n
inst✝ : DecidableEq m
σ₁ : R₁ →+* R
σ₂ : R₂ →+* R
M : Matrix n m R
v : n → R
w : m → R
x✝³ : n
x✝² : x✝³ ∈ univ
x✝¹ : m
x✝ : x✝¹ ∈ univ
⊢ v x✝³ * M x✝³ x✝¹ * w x✝¹ = v x✝³ * (M x✝³ x✝¹ * w x✝¹)
Theorem: Finset.image_some_eraseNone
File: Mathlib/Data/Finset/Option.lean

tactic: ext (_ | x) <;> simp
state_before: α : Type u_1
β : Type ?u.13337
inst✝ : DecidableEq (Option α)
s : Finset (Option α)
⊢ image some (↑eraseNone s) = erase s none
Theorem: imaginaryPart_I_smul
File: Mathlib/Data/Complex/Module.lean

tactic: ext
state_before: A : Type u_1
inst✝³ : AddCommGroup A
inst✝² : Module ℂ A
inst✝¹ : StarAddMonoid A
inst✝ : StarModule ℂ A
a : A
⊢ ↑ℑ (I • a) = ↑ℜ a

tactic: rw [realPart_apply_coe, imaginaryPart_apply_coe, smul_comm]
state_before: case a
A : Type u_1
inst✝³ : AddCommGroup A
inst✝² : Module ℂ A
inst✝¹ : StarAddMonoid A
inst✝ : StarModule ℂ A
a : A
⊢ ↑(↑ℑ (I • a)) = ↑(↑ℜ a)

tactic: simp [←smul_assoc]
state_before: case a
A : Type u_1
inst✝³ : AddCommGroup A
inst✝² : Module ℂ A
inst✝¹ : StarAddMonoid A
inst✝ : StarModule ℂ A
a : A
⊢ 2⁻¹ • -I • (I • a - star (I • a)) = 2⁻¹ • (a + star a)
Theorem: uniformContinuous_of_continuousAt_one
File: Mathlib/Topology/Algebra/UniformGroup.lean

tactic: simpa using hf.tendsto
state_before: α : Type u_3
β : Type u_2
inst✝⁶ : UniformSpace α
inst✝⁵ : Group α
inst✝⁴ : UniformGroup α
hom : Type u_1
inst✝³ : UniformSpace β
inst✝² : Group β
inst✝¹ : UniformGroup β
inst✝ : MonoidHomClass hom α β
f : hom
hf : ContinuousAt (↑f) 1
⊢ Tendsto (↑f) (𝓝 1) (𝓝 1)
Theorem: Submonoid.leftInv_leftInv_eq
File: Mathlib/GroupTheory/Submonoid/Inverses.lean

tactic: refine' le_antisymm S.leftInv_leftInv_le _
state_before: M : Type u_1
inst✝ : Monoid M
S : Submonoid M
hS : S ≤ IsUnit.submonoid M
⊢ leftInv (leftInv S) = S

tactic: intro x hx
state_before: M : Type u_1
inst✝ : Monoid M
S : Submonoid M
hS : S ≤ IsUnit.submonoid M
⊢ S ≤ leftInv (leftInv S)

tactic: have : x = ((hS hx).unit⁻¹⁻¹ : Mˣ) := by
  rw [inv_inv (hS hx).unit]
  rfl
state_before: M : Type u_1
inst✝ : Monoid M
S : Submonoid M
hS : S ≤ IsUnit.submonoid M
x : M
hx : x ∈ S
⊢ x ∈ leftInv (leftInv S)

tactic: rw [this]
state_before: M : Type u_1
inst✝ : Monoid M
S : Submonoid M
hS : S ≤ IsUnit.submonoid M
x : M
hx : x ∈ S
this : x = ↑(IsUnit.unit (_ : x ∈ IsUnit.submonoid M))⁻¹⁻¹
⊢ x ∈ leftInv (leftInv S)

tactic: exact S.leftInv.unit_mem_leftInv _ (S.unit_mem_leftInv _ hx)
state_before: M : Type u_1
inst✝ : Monoid M
S : Submonoid M
hS : S ≤ IsUnit.submonoid M
x : M
hx : x ∈ S
this : x = ↑(IsUnit.unit (_ : x ∈ IsUnit.submonoid M))⁻¹⁻¹
⊢ ↑(IsUnit.unit (_ : x ∈ IsUnit.submonoid M))⁻¹⁻¹ ∈ leftInv (leftInv S)

tactic: rw [inv_inv (hS hx).unit]
state_before: M : Type u_1
inst✝ : Monoid M
S : Submonoid M
hS : S ≤ IsUnit.submonoid M
x : M
hx : x ∈ S
⊢ x = ↑(IsUnit.unit (_ : x ∈ IsUnit.submonoid M))⁻¹⁻¹

tactic: rfl
state_before: M : Type u_1
inst✝ : Monoid M
S : Submonoid M
hS : S ≤ IsUnit.submonoid M
x : M
hx : x ∈ S
⊢ x = ↑(IsUnit.unit (_ : x ∈ IsUnit.submonoid M))
Theorem: Set.image_neg_Iic
File: Mathlib/Data/Set/Pointwise/Interval.lean

tactic: simp
state_before: α : Type u_1
inst✝ : OrderedAddCommGroup α
a b c : α
⊢ Neg.neg '' Iic a = Ici (-a)