tasksource/leandojo huggingface dataset:
Theorem: Bornology.relativelyCompact.isBounded_iff
File: Mathlib/Topology/Separation.lean

tactic: change sᶜ ∈ Filter.coclosedCompact α ↔ _
state_before: α : Type u
β : Type v
inst✝¹ : TopologicalSpace α
inst✝ : T1Space α
s : Set α
⊢ IsBounded s ↔ IsCompact (closure s)

tactic: rw [Filter.mem_coclosedCompact]
state_before: α : Type u
β : Type v
inst✝¹ : TopologicalSpace α
inst✝ : T1Space α
s : Set α
⊢ sᶜ ∈ coclosedCompact α ↔ IsCompact (closure s)

tactic: constructor
state_before: α : Type u
β : Type v
inst✝¹ : TopologicalSpace α
inst✝ : T1Space α
s : Set α
⊢ (∃ t, IsClosed t ∧ IsCompact t ∧ tᶜ ⊆ sᶜ) ↔ IsCompact (closure s)

tactic: rintro ⟨t, ht₁, ht₂, hst⟩
state_before: case mp
α : Type u
β : Type v
inst✝¹ : TopologicalSpace α
inst✝ : T1Space α
s : Set α
⊢ (∃ t, IsClosed t ∧ IsCompact t ∧ tᶜ ⊆ sᶜ) → IsCompact (closure s)

tactic: rw [compl_subset_compl] at hst
state_before: case mp.intro.intro.intro
α : Type u
β : Type v
inst✝¹ : TopologicalSpace α
inst✝ : T1Space α
s t : Set α
ht₁ : IsClosed t
ht₂ : IsCompact t
hst : tᶜ ⊆ sᶜ
⊢ IsCompact (closure s)

tactic: exact isCompact_of_isClosed_subset ht₂ isClosed_closure (closure_minimal hst ht₁)
state_before: case mp.intro.intro.intro
α : Type u
β : Type v
inst✝¹ : TopologicalSpace α
inst✝ : T1Space α
s t : Set α
ht₁ : IsClosed t
ht₂ : IsCompact t
hst : s ⊆ t
⊢ IsCompact (closure s)

tactic: intro h
state_before: case mpr
α : Type u
β : Type v
inst✝¹ : TopologicalSpace α
inst✝ : T1Space α
s : Set α
⊢ IsCompact (closure s) → ∃ t, IsClosed t ∧ IsCompact t ∧ tᶜ ⊆ sᶜ

tactic: exact ⟨closure s, isClosed_closure, h, compl_subset_compl.mpr subset_closure⟩
state_before: case mpr
α : Type u
β : Type v
inst✝¹ : TopologicalSpace α
inst✝ : T1Space α
s : Set α
h : IsCompact (closure s)
⊢ ∃ t, IsClosed t ∧ IsCompact t ∧ tᶜ ⊆ sᶜ
Theorem: BoxIntegral.integral_smul
File: Mathlib/Analysis/BoxIntegral/Basic.lean

tactic: rcases eq_or_ne c 0 with (rfl | hc)
state_before: ι : Type u
E : Type v
F : Type w
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
I J : Box ι
π : TaggedPrepartition I
inst✝ : Fintype ι
l : IntegrationParams
f g : (ι → ℝ) → E
vol : ι →ᵇᵃ[⊤] E →L[ℝ] F
y y' : F
c : ℝ
⊢ integral I l (fun x => c • f x) vol = c • integral I l f vol

tactic: by_cases hf : Integrable I l f vol
state_before: case inr
ι : Type u
E : Type v
F : Type w
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
I J : Box ι
π : TaggedPrepartition I
inst✝ : Fintype ι
l : IntegrationParams
f g : (ι → ℝ) → E
vol : ι →ᵇᵃ[⊤] E →L[ℝ] F
y y' : F
c : ℝ
hc : c ≠ 0
⊢ integral I l (fun x => c • f x) vol = c • integral I l f vol

tactic: simp only [zero_smul, integral_zero]
state_before: case inl
ι : Type u
E : Type v
F : Type w
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
I J : Box ι
π : TaggedPrepartition I
inst✝ : Fintype ι
l : IntegrationParams
f g : (ι → ℝ) → E
vol : ι →ᵇᵃ[⊤] E →L[ℝ] F
y y' : F
⊢ integral I l (fun x => 0 • f x) vol = 0 • integral I l f vol

tactic: exact (hf.hasIntegral.smul c).integral_eq
state_before: case pos
ι : Type u
E : Type v
F : Type w
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
I J : Box ι
π : TaggedPrepartition I
inst✝ : Fintype ι
l : IntegrationParams
f g : (ι → ℝ) → E
vol : ι →ᵇᵃ[⊤] E →L[ℝ] F
y y' : F
c : ℝ
hc : c ≠ 0
hf : Integrable I l f vol
⊢ integral I l (fun x => c • f x) vol = c • integral I l f vol

tactic: have : ¬Integrable I l (fun x => c • f x) vol := mt (fun h => h.of_smul hc) hf
state_before: case neg
ι : Type u
E : Type v
F : Type w
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
I J : Box ι
π : TaggedPrepartition I
inst✝ : Fintype ι
l : IntegrationParams
f g : (ι → ℝ) → E
vol : ι →ᵇᵃ[⊤] E →L[ℝ] F
y y' : F
c : ℝ
hc : c ≠ 0
hf : ¬Integrable I l f vol
⊢ integral I l (fun x => c • f x) vol = c • integral I l f vol

tactic: rw [integral, integral, dif_neg hf, dif_neg this, smul_zero]
state_before: case neg
ι : Type u
E : Type v
F : Type w
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
I J : Box ι
π : TaggedPrepartition I
inst✝ : Fintype ι
l : IntegrationParams
f g : (ι → ℝ) → E
vol : ι →ᵇᵃ[⊤] E →L[ℝ] F
y y' : F
c : ℝ
hc : c ≠ 0
hf : ¬Integrable I l f vol
this : ¬Integrable I l (fun x => c • f x) vol
⊢ integral I l (fun x => c • f x) vol = c • integral I l f vol
Theorem: Multiset.toEmbedding_coeEquiv_trans
File: Mathlib/Data/Multiset/Fintype.lean

tactic: ext <;> rfl
state_before: α : Type u_1
inst✝ : DecidableEq α
m✝ m : Multiset α
⊢ Function.Embedding.trans (Equiv.toEmbedding (coeEquiv m)) (Function.Embedding.subtype fun x => x ∈ toEnumFinset m) =
    coeEmbedding m
Theorem: CategoryTheory.Adjunction.leftAdjointUniq_hom_app_counit
File: Mathlib/CategoryTheory/Adjunction/Opposites.lean

tactic: rw [← leftAdjointUniq_hom_counit adj1 adj2]
state_before: C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
F F' : C ⥤ D
G : D ⥤ C
adj1 : F ⊣ G
adj2 : F' ⊣ G
x : D
⊢ (leftAdjointUniq adj1 adj2).hom.app (G.obj x) ≫ adj2.counit.app x = adj1.counit.app x

tactic: rfl
state_before: C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
F F' : C ⥤ D
G : D ⥤ C
adj1 : F ⊣ G
adj2 : F' ⊣ G
x : D
⊢ (leftAdjointUniq adj1 adj2).hom.app (G.obj x) ≫ adj2.counit.app x =
    (whiskerLeft G (leftAdjointUniq adj1 adj2).hom ≫ adj2.counit).app x
Theorem: gcd_eq_right_iff
File: Mathlib/Algebra/GCDMonoid/Basic.lean

tactic: simpa only [gcd_comm a b] using gcd_eq_left_iff b a h
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : NormalizedGCDMonoid α
a b : α
h : ↑normalize b = b
⊢ gcd a b = b ↔ b ∣ a
Theorem: Vector.toList_map
File: Mathlib/Data/Vector/Basic.lean

tactic: cases v
state_before: n : ℕ
α : Type u_2
β : Type u_1
v : Vector α n
f : α → β
⊢ toList (map f v) = List.map f (toList v)

tactic: rfl
state_before: case mk
n : ℕ
α : Type u_2
β : Type u_1
f : α → β
val✝ : List α
property✝ : List.length val✝ = n
⊢ toList (map f { val := val✝, property := property✝ }) = List.map f (toList { val := val✝, property := property✝ })
Theorem: LinearMap.det_zero'
File: Mathlib/LinearAlgebra/Determinant.lean

tactic: haveI := Classical.decEq ι
state_before: R : Type ?u.871535
inst✝¹¹ : CommRing R
M : Type u_3
inst✝¹⁰ : AddCommGroup M
inst✝⁹ : Module R M
M' : Type ?u.872126
inst✝⁸ : AddCommGroup M'
inst✝⁷ : Module R M'
ι✝ : Type ?u.872668
inst✝⁶ : DecidableEq ι✝
inst✝⁵ : Fintype ι✝
e : Basis ι✝ R M
A : Type u_2
inst✝⁴ : CommRing A
inst✝³ : Module A M
κ : Type ?u.873644
inst✝² : Fintype κ
ι : Type u_1
inst✝¹ : Finite ι
inst✝ : Nonempty ι
b : Basis ι A M
⊢ ↑LinearMap.det 0 = 0

tactic: cases nonempty_fintype ι
state_before: R : Type ?u.871535
inst✝¹¹ : CommRing R
M : Type u_3
inst✝¹⁰ : AddCommGroup M
inst✝⁹ : Module R M
M' : Type ?u.872126
inst✝⁸ : AddCommGroup M'
inst✝⁷ : Module R M'
ι✝ : Type ?u.872668
inst✝⁶ : DecidableEq ι✝
inst✝⁵ : Fintype ι✝
e : Basis ι✝ R M
A : Type u_2
inst✝⁴ : CommRing A
inst✝³ : Module A M
κ : Type ?u.873644
inst✝² : Fintype κ
ι : Type u_1
inst✝¹ : Finite ι
inst✝ : Nonempty ι
b : Basis ι A M
this : DecidableEq ι
⊢ ↑LinearMap.det 0 = 0

tactic: rwa [← det_toMatrix b, LinearEquiv.map_zero, det_zero]
state_before: case intro
R : Type ?u.871535
inst✝¹¹ : CommRing R
M : Type u_3
inst✝¹⁰ : AddCommGroup M
inst✝⁹ : Module R M
M' : Type ?u.872126
inst✝⁸ : AddCommGroup M'
inst✝⁷ : Module R M'
ι✝ : Type ?u.872668
inst✝⁶ : DecidableEq ι✝
inst✝⁵ : Fintype ι✝
e : Basis ι✝ R M
A : Type u_2
inst✝⁴ : CommRing A
inst✝³ : Module A M
κ : Type ?u.873644
inst✝² : Fintype κ
ι : Type u_1
inst✝¹ : Finite ι
inst✝ : Nonempty ι
b : Basis ι A M
this : DecidableEq ι
val✝ : Fintype ι
⊢ ↑LinearMap.det 0 = 0
Theorem: real_inner_self_eq_norm_sq
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

tactic: rw [pow_two, real_inner_self_eq_norm_mul_norm]
state_before: 𝕜 : Type ?u.2330841
E : Type ?u.2330844
F : Type u_1
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
dec_E : DecidableEq E
x : F
⊢ inner x x = ‖x‖ ^ 2
Theorem: Matrix.comp_equiv_dotProduct_comp_equiv
File: Mathlib/Data/Matrix/Basic.lean

tactic: rw [← dotProduct_comp_equiv_symm]
state_before: l : Type ?u.148579
m : Type u_1
n : Type u_2
o : Type ?u.148588
m' : o → Type ?u.148593
n' : o → Type ?u.148598
R : Type ?u.148601
S : Type ?u.148604
α : Type v
β : Type w
γ : Type ?u.148611
inst✝² : Fintype m
inst✝¹ : Fintype n
inst✝ : NonUnitalNonAssocSemiring α
u v w : m → α
x y : n → α
e : m ≃ n
⊢ x ∘ ↑e ⬝ᵥ y ∘ ↑e = x ⬝ᵥ y

tactic: simp only [Function.comp, Equiv.apply_symm_apply]
state_before: l : Type ?u.148579
m : Type u_1
n : Type u_2
o : Type ?u.148588
m' : o → Type ?u.148593
n' : o → Type ?u.148598
R : Type ?u.148601
S : Type ?u.148604
α : Type v
β : Type w
γ : Type ?u.148611
inst✝² : Fintype m
inst✝¹ : Fintype n
inst✝ : NonUnitalNonAssocSemiring α
u v w : m → α
x y : n → α
e : m ≃ n
⊢ x ⬝ᵥ (y ∘ ↑e) ∘ ↑e.symm = x ⬝ᵥ y
Theorem: LocalHomeomorph.eventually_nhdsWithin'
File: Mathlib/Topology/LocalHomeomorph.lean

tactic: rw [e.eventually_nhdsWithin _ hx]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.34648
δ : Type ?u.34651
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
e✝ : LocalHomeomorph α β
e' : LocalHomeomorph β γ
e : LocalHomeomorph α β
x : α
p : α → Prop
s : Set α
hx : x ∈ e.source
⊢ (∀ᶠ (y : β) in 𝓝[↑(LocalHomeomorph.symm e) ⁻¹' s] ↑e x, p (↑(LocalHomeomorph.symm e) y)) ↔ ∀ᶠ (x : α) in 𝓝[s] x, p x

tactic: refine'
  eventually_congr
    ((eventually_nhdsWithin_of_eventually_nhds <| e.eventually_left_inverse hx).mono fun y hy =>
      _)
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.34648
δ : Type ?u.34651
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
e✝ : LocalHomeomorph α β
e' : LocalHomeomorph β γ
e : LocalHomeomorph α β
x : α
p : α → Prop
s : Set α
hx : x ∈ e.source
⊢ (∀ᶠ (x : α) in 𝓝[s] x, p (↑(LocalHomeomorph.symm e) (↑e x))) ↔ ∀ᶠ (x : α) in 𝓝[s] x, p x

tactic: rw [hy]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.34648
δ : Type ?u.34651
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
e✝ : LocalHomeomorph α β
e' : LocalHomeomorph β γ
e : LocalHomeomorph α β
x : α
p : α → Prop
s : Set α
hx : x ∈ e.source
y : α
hy : ↑(LocalHomeomorph.symm e) (↑e y) = y
⊢ p (↑(LocalHomeomorph.symm e) (↑e y)) ↔ p y
Theorem: CategoryTheory.Limits.coprod.map_comp_id
File: Mathlib/CategoryTheory/Limits/Shapes/BinaryProducts.lean

tactic: simp
state_before: C : Type u
inst✝³ : Category C
X✝ Y✝ X Y Z W : C
f : X ⟶ Y
g : Y ⟶ Z
inst✝² : HasBinaryCoproduct Z W
inst✝¹ : HasBinaryCoproduct Y W
inst✝ : HasBinaryCoproduct X W
⊢ map (f ≫ g) (𝟙 W) = map f (𝟙 W) ≫ map g (𝟙 W)
Theorem: Equiv.Perm.inv_aux
File: Mathlib/GroupTheory/Perm/Basic.lean

tactic: simp_rw [f.apply_inv_self, Iff.comm]
state_before: α : Type u
β : Type v
p : α → Prop
f : Perm α
⊢ (∀ (x : α), p (↑f⁻¹ x) ↔ p (↑f (↑f⁻¹ x))) ↔ ∀ (x : α), p x ↔ p (↑f⁻¹ x)
Theorem: MeasureTheory.integral_fn_integral_sub
File: Mathlib/MeasureTheory/Constructions/Prod/Integral.lean

tactic: refine' integral_congr_ae _
state_before: α : Type u_1
α' : Type ?u.2419590
β : Type u_2
β' : Type ?u.2419596
γ : Type ?u.2419599
E : Type u_3
inst✝¹² : MeasurableSpace α
inst✝¹¹ : MeasurableSpace α'
inst✝¹⁰ : MeasurableSpace β
inst✝⁹ : MeasurableSpace β'
inst✝⁸ : MeasurableSpace γ
μ μ' : Measure α
ν ν' : Measure β
τ : Measure γ
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : SigmaFinite ν
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : CompleteSpace E
inst✝³ : SigmaFinite μ
E' : Type u_4
inst✝² : NormedAddCommGroup E'
inst✝¹ : CompleteSpace E'
inst✝ : NormedSpace ℝ E'
f g : α × β → E
F : E → E'
hf : Integrable f
hg : Integrable g
⊢ (∫ (x : α), F (∫ (y : β), f (x, y) - g (x, y) ∂ν) ∂μ) =
    ∫ (x : α), F ((∫ (y : β), f (x, y) ∂ν) - ∫ (y : β), g (x, y) ∂ν) ∂μ

tactic: filter_upwards [hf.prod_right_ae, hg.prod_right_ae] with _ h2f h2g
state_before: α : Type u_1
α' : Type ?u.2419590
β : Type u_2
β' : Type ?u.2419596
γ : Type ?u.2419599
E : Type u_3
inst✝¹² : MeasurableSpace α
inst✝¹¹ : MeasurableSpace α'
inst✝¹⁰ : MeasurableSpace β
inst✝⁹ : MeasurableSpace β'
inst✝⁸ : MeasurableSpace γ
μ μ' : Measure α
ν ν' : Measure β
τ : Measure γ
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : SigmaFinite ν
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : CompleteSpace E
inst✝³ : SigmaFinite μ
E' : Type u_4
inst✝² : NormedAddCommGroup E'
inst✝¹ : CompleteSpace E'
inst✝ : NormedSpace ℝ E'
f g : α × β → E
F : E → E'
hf : Integrable f
hg : Integrable g
⊢ (fun x => F (∫ (y : β), f (x, y) - g (x, y) ∂ν)) =ᶠ[ae μ] fun x =>
    F ((∫ (y : β), f (x, y) ∂ν) - ∫ (y : β), g (x, y) ∂ν)

tactic: simp [integral_sub h2f h2g]
state_before: case h
α : Type u_1
α' : Type ?u.2419590
β : Type u_2
β' : Type ?u.2419596
γ : Type ?u.2419599
E : Type u_3
inst✝¹² : MeasurableSpace α
inst✝¹¹ : MeasurableSpace α'
inst✝¹⁰ : MeasurableSpace β
inst✝⁹ : MeasurableSpace β'
inst✝⁸ : MeasurableSpace γ
μ μ' : Measure α
ν ν' : Measure β
τ : Measure γ
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : SigmaFinite ν
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : CompleteSpace E
inst✝³ : SigmaFinite μ
E' : Type u_4
inst✝² : NormedAddCommGroup E'
inst✝¹ : CompleteSpace E'
inst✝ : NormedSpace ℝ E'
f g : α × β → E
F : E → E'
hf : Integrable f
hg : Integrable g
a✝ : α
h2f : Integrable fun y => f (a✝, y)
h2g : Integrable fun y => g (a✝, y)
⊢ F (∫ (y : β), f (a✝, y) - g (a✝, y) ∂ν) = F ((∫ (y : β), f (a✝, y) ∂ν) - ∫ (y : β), g (a✝, y) ∂ν)
Theorem: List.Nodup.cyclicPermutations
File: Mathlib/Data/List/Rotate.lean

tactic: cases' l with x l
state_before: α : Type u
l✝ l' l : List α
hn : Nodup l
⊢ Nodup (List.cyclicPermutations l)

tactic: rw [nodup_iff_nthLe_inj]
state_before: case cons
α : Type u
l✝ l' : List α
x : α
l : List α
hn : Nodup (x :: l)
⊢ Nodup (List.cyclicPermutations (x :: l))

tactic: intro i j hi hj h
state_before: case cons
α : Type u
l✝ l' : List α
x : α
l : List α
hn : Nodup (x :: l)
⊢ ∀ (i j : ℕ) (h₁ : i < length (List.cyclicPermutations (x :: l))) (h₂ : j < length (List.cyclicPermutations (x :: l))),
    nthLe (List.cyclicPermutations (x :: l)) i h₁ = nthLe (List.cyclicPermutations (x :: l)) j h₂ → i = j

tactic: simp only [length_cyclicPermutations_cons] at hi hj
state_before: case cons
α : Type u
l✝ l' : List α
x : α
l : List α
hn : Nodup (x :: l)
i j : ℕ
hi : i < length (List.cyclicPermutations (x :: l))
hj : j < length (List.cyclicPermutations (x :: l))
h : nthLe (List.cyclicPermutations (x :: l)) i hi = nthLe (List.cyclicPermutations (x :: l)) j hj
⊢ i = j

tactic: rw [← mod_eq_of_lt hi, ← mod_eq_of_lt hj]
state_before: case cons
α : Type u
l✝ l' : List α
x : α
l : List α
hn : Nodup (x :: l)
i j : ℕ
hi✝ : i < length (List.cyclicPermutations (x :: l))
hj✝ : j < length (List.cyclicPermutations (x :: l))
h : nthLe (List.cyclicPermutations (x :: l)) i hi✝ = nthLe (List.cyclicPermutations (x :: l)) j hj✝
hi : i < length l + 1
hj : j < length l + 1
⊢ i = j

tactic: apply hn.rotate_congr
state_before: case cons
α : Type u
l✝ l' : List α
x : α
l : List α
hn : Nodup (x :: l)
i j : ℕ
hi✝ : i < length (List.cyclicPermutations (x :: l))
hj✝ : j < length (List.cyclicPermutations (x :: l))
h : nthLe (List.cyclicPermutations (x :: l)) i hi✝ = nthLe (List.cyclicPermutations (x :: l)) j hj✝
hi : i < length l + 1
hj : j < length l + 1
⊢ i % (length l + 1) = j % (length l + 1)

tactic: simp
state_before: case nil
α : Type u
l l' : List α
hn : Nodup []
⊢ Nodup (List.cyclicPermutations [])

tactic: simp
state_before: case cons.hn
α : Type u
l✝ l' : List α
x : α
l : List α
hn : Nodup (x :: l)
i j : ℕ
hi✝ : i < length (List.cyclicPermutations (x :: l))
hj✝ : j < length (List.cyclicPermutations (x :: l))
h : nthLe (List.cyclicPermutations (x :: l)) i hi✝ = nthLe (List.cyclicPermutations (x :: l)) j hj✝
hi : i < length l + 1
hj : j < length l + 1
⊢ x :: l ≠ []

tactic: simpa using h
state_before: case cons.h
α : Type u
l✝ l' : List α
x : α
l : List α
hn : Nodup (x :: l)
i j : ℕ
hi✝ : i < length (List.cyclicPermutations (x :: l))
hj✝ : j < length (List.cyclicPermutations (x :: l))
h : nthLe (List.cyclicPermutations (x :: l)) i hi✝ = nthLe (List.cyclicPermutations (x :: l)) j hj✝
hi : i < length l + 1
hj : j < length l + 1
⊢ rotate (x :: l) i = rotate (x :: l) j
Theorem: coe_setBasisOfLinearIndependentOfCardEqFinrank
File: Mathlib/LinearAlgebra/FiniteDimensional.lean

tactic: rw [setBasisOfLinearIndependentOfCardEqFinrank]
state_before: K : Type u
V : Type v
inst✝⁴ : DivisionRing K
inst✝³ : AddCommGroup V
inst✝² : Module K V
s : Set V
inst✝¹ : Nonempty ↑s
inst✝ : Fintype ↑s
lin_ind : LinearIndependent K Subtype.val
card_eq : Finset.card (Set.toFinset s) = finrank K V
⊢ ↑(setBasisOfLinearIndependentOfCardEqFinrank lin_ind card_eq) = Subtype.val

tactic: exact Basis.coe_mk _ _
state_before: K : Type u
V : Type v
inst✝⁴ : DivisionRing K
inst✝³ : AddCommGroup V
inst✝² : Module K V
s : Set V
inst✝¹ : Nonempty ↑s
inst✝ : Fintype ↑s
lin_ind : LinearIndependent K Subtype.val
card_eq : Finset.card (Set.toFinset s) = finrank K V
⊢ ↑(basisOfLinearIndependentOfCardEqFinrank lin_ind (_ : Fintype.card ↑s = finrank K V)) = Subtype.val
Theorem: MeasureTheory.OuterMeasure.boundedBy_apply
File: Mathlib/MeasureTheory/Measure/OuterMeasure.lean

tactic: simp [boundedBy, ofFunction_apply]
state_before: α : Type u_1
m : Set α → ℝ≥0∞
s : Set α
⊢ ↑(boundedBy m) s = ⨅ (t : ℕ → Set α) (_ : s ⊆ iUnion t), ∑' (n : ℕ), ⨆ (_ : Set.Nonempty (t n)), m (t n)
Theorem: LocalizedModule.smul'_mk
File: Mathlib/Algebra/Module/LocalizedModule.lean

tactic: erw [mk_smul_mk r m 1 s, one_mul]
state_before: R : Type u
inst✝² : CommSemiring R
S : Submonoid R
M : Type v
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
r : R
s : { x // x ∈ S }
m : M
⊢ r • mk m s = mk (r • m) s
Theorem: CategoryTheory.MorphismProperty.StableUnderComposition.epimorphisms
File: Mathlib/CategoryTheory/MorphismProperty.lean

tactic: rw [epimorphisms.iff] at hf hg⊢
state_before: C : Type u
inst✝¹ : Category C
D : Type ?u.64328
inst✝ : Category D
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
hf : MorphismProperty.epimorphisms C f
hg : MorphismProperty.epimorphisms C g
⊢ MorphismProperty.epimorphisms C (f ≫ g)

tactic: haveI := hf
state_before: C : Type u
inst✝¹ : Category C
D : Type ?u.64328
inst✝ : Category D
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
hf : Epi f
hg : Epi g
⊢ Epi (f ≫ g)

tactic: haveI := hg
state_before: C : Type u
inst✝¹ : Category C
D : Type ?u.64328
inst✝ : Category D
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
hf : Epi f
hg : Epi g
this : Epi f
⊢ Epi (f ≫ g)

tactic: apply epi_comp
state_before: C : Type u
inst✝¹ : Category C
D : Type ?u.64328
inst✝ : Category D
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
hf : Epi f
hg : Epi g
this✝ : Epi f
this : Epi g
⊢ Epi (f ≫ g)
Theorem: LinearMap.toMatrix_basis_equiv
File: Mathlib/LinearAlgebra/Matrix/ToLin.lean

tactic: ext (i j)
state_before: R : Type u_2
inst✝¹¹ : CommSemiring R
l : Type u_1
m : Type ?u.2073940
n : Type ?u.2073943
inst✝¹⁰ : Fintype n
inst✝⁹ : Fintype m
inst✝⁸ : DecidableEq n
M₁ : Type u_3
M₂ : Type u_4
inst✝⁷ : AddCommMonoid M₁
inst✝⁶ : AddCommMonoid M₂
inst✝⁵ : Module R M₁
inst✝⁴ : Module R M₂
v₁ : Basis n R M₁
v₂ : Basis m R M₂
M₃ : Type ?u.2074466
inst✝³ : AddCommMonoid M₃
inst✝² : Module R M₃
v₃ : Basis l R M₃
inst✝¹ : Fintype l
inst✝ : DecidableEq l
b : Basis l R M₁
b' : Basis l R M₂
⊢ ↑(toMatrix b' b) ↑(Basis.equiv b' b (Equiv.refl l)) = 1

tactic: simp [LinearMap.toMatrix_apply, Matrix.one_apply, Finsupp.single_apply, eq_comm]
state_before: case a.h
R : Type u_2
inst✝¹¹ : CommSemiring R
l : Type u_1
m : Type ?u.2073940
n : Type ?u.2073943
inst✝¹⁰ : Fintype n
inst✝⁹ : Fintype m
inst✝⁸ : DecidableEq n
M₁ : Type u_3
M₂ : Type u_4
inst✝⁷ : AddCommMonoid M₁
inst✝⁶ : AddCommMonoid M₂
inst✝⁵ : Module R M₁
inst✝⁴ : Module R M₂
v₁ : Basis n R M₁
v₂ : Basis m R M₂
M₃ : Type ?u.2074466
inst✝³ : AddCommMonoid M₃
inst✝² : Module R M₃
v₃ : Basis l R M₃
inst✝¹ : Fintype l
inst✝ : DecidableEq l
b : Basis l R M₁
b' : Basis l R M₂
i j : l
⊢ ↑(toMatrix b' b) (↑(Basis.equiv b' b (Equiv.refl l))) i j = OfNat.ofNat 1 i j
Theorem: Finmap.mem_replace
File: Mathlib/Data/Finmap.lean

tactic: simp
state_before: α : Type u
β : α → Type v
inst✝ : DecidableEq α
a a' : α
b : β a
s✝ : Finmap β
s : AList β
⊢ a' ∈ replace a b ⟦s⟧ ↔ a' ∈ ⟦s⟧
Theorem: List.zipWith_nil
File: Mathlib/Data/List/Basic.lean

tactic: cases l <;> rfl
state_before: ι : Type ?u.144456
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
f : α → β → γ
l : List α
⊢ zipWith f l [] = []
Theorem: MeasureTheory.UnifIntegrable.ae_eq
File: Mathlib/MeasureTheory/Function/UniformIntegrable.lean

tactic: intro ε hε
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace α
μ : Measure α
inst✝ : NormedAddCommGroup β
f g : ι → α → β
p : ℝ≥0∞
hf : UnifIntegrable f p μ
hfg : ∀ (n : ι), f n =ᵐ[μ] g n
⊢ UnifIntegrable g p μ

tactic: obtain ⟨δ, hδ_pos, hfδ⟩ := hf hε
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace α
μ : Measure α
inst✝ : NormedAddCommGroup β
f g : ι → α → β
p : ℝ≥0∞
hf : UnifIntegrable f p μ
hfg : ∀ (n : ι), f n =ᵐ[μ] g n
ε : ℝ
hε : 0 < ε
⊢ ∃ δ x,
    ∀ (i : ι) (s : Set α),
      MeasurableSet s → ↑↑μ s ≤ ENNReal.ofReal δ → snorm (Set.indicator s (g i)) p μ ≤ ENNReal.ofReal ε

tactic: refine' ⟨δ, hδ_pos, fun n s hs hμs => (le_of_eq <| snorm_congr_ae _).trans (hfδ n s hs hμs)⟩
state_before: case intro.intro
α : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace α
μ : Measure α
inst✝ : NormedAddCommGroup β
f g : ι → α → β
p : ℝ≥0∞
hf : UnifIntegrable f p μ
hfg : ∀ (n : ι), f n =ᵐ[μ] g n
ε : ℝ
hε : 0 < ε
δ : ℝ
hδ_pos : 0 < δ
hfδ :
  ∀ (i : ι) (s : Set α),
    MeasurableSet s → ↑↑μ s ≤ ENNReal.ofReal δ → snorm (Set.indicator s (f i)) p μ ≤ ENNReal.ofReal ε
⊢ ∃ δ x,
    ∀ (i : ι) (s : Set α),
      MeasurableSet s → ↑↑μ s ≤ ENNReal.ofReal δ → snorm (Set.indicator s (g i)) p μ ≤ ENNReal.ofReal ε

tactic: filter_upwards [hfg n] with x hx
state_before: case intro.intro
α : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace α
μ : Measure α
inst✝ : NormedAddCommGroup β
f g : ι → α → β
p : ℝ≥0∞
hf : UnifIntegrable f p μ
hfg : ∀ (n : ι), f n =ᵐ[μ] g n
ε : ℝ
hε : 0 < ε
δ : ℝ
hδ_pos : 0 < δ
hfδ :
  ∀ (i : ι) (s : Set α),
    MeasurableSet s → ↑↑μ s ≤ ENNReal.ofReal δ → snorm (Set.indicator s (f i)) p μ ≤ ENNReal.ofReal ε
n : ι
s : Set α
hs : MeasurableSet s
hμs : ↑↑μ s ≤ ENNReal.ofReal δ
⊢ Set.indicator s (g n) =ᵐ[μ] Set.indicator s (f n)

tactic: simp_rw [Set.indicator_apply, hx]
state_before: case h
α : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace α
μ : Measure α
inst✝ : NormedAddCommGroup β
f g : ι → α → β
p : ℝ≥0∞
hf : UnifIntegrable f p μ
hfg : ∀ (n : ι), f n =ᵐ[μ] g n
ε : ℝ
hε : 0 < ε
δ : ℝ
hδ_pos : 0 < δ
hfδ :
  ∀ (i : ι) (s : Set α),
    MeasurableSet s → ↑↑μ s ≤ ENNReal.ofReal δ → snorm (Set.indicator s (f i)) p μ ≤ ENNReal.ofReal ε
n : ι
s : Set α
hs : MeasurableSet s
hμs : ↑↑μ s ≤ ENNReal.ofReal δ
x : α
hx : f n x = g n x
⊢ Set.indicator s (g n) x = Set.indicator s (f n) x
Theorem: HasStrictFDerivAt.sub
File: Mathlib/Analysis/Calculus/FDeriv/Add.lean

tactic: simpa only [sub_eq_add_neg] using hf.add hg.neg
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.441700
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.441795
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
hg : HasStrictFDerivAt g g' x
⊢ HasStrictFDerivAt (fun x => f x - g x) (f' - g') x
Theorem: Multiset.mem_Ioo
File: Mathlib/Order/LocallyFinite.lean

tactic: rw [Ioo, ← Finset.mem_def, Finset.mem_Ioo]
state_before: α : Type u_1
β : Type ?u.33022
inst✝¹ : Preorder α
inst✝ : LocallyFiniteOrder α
a b x : α
⊢ x ∈ Ioo a b ↔ a < x ∧ x < b