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

tactic: by_cases hf : Integrable f μ
state_before: α : Type u_2
E : Type u_1
F : Type ?u.960408
𝕜 : Type ?u.960411
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : CompleteSpace E
inst✝⁵ : NontriviallyNormedField 𝕜
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : SMulCommClass ℝ 𝕜 E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace F
f✝ g : α → E
m : MeasurableSpace α
μ : Measure α
f : α → E
⊢ ‖∫ (a : α), f a ∂μ‖ ≤ ENNReal.toReal (∫⁻ (a : α), ENNReal.ofReal ‖f a‖ ∂μ)

tactic: rw [integral_eq f hf, ← Integrable.norm_toL1_eq_lintegral_norm f hf]
state_before: case pos
α : Type u_2
E : Type u_1
F : Type ?u.960408
𝕜 : Type ?u.960411
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : CompleteSpace E
inst✝⁵ : NontriviallyNormedField 𝕜
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : SMulCommClass ℝ 𝕜 E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace F
f✝ g : α → E
m : MeasurableSpace α
μ : Measure α
f : α → E
hf : Integrable f
⊢ ‖∫ (a : α), f a ∂μ‖ ≤ ENNReal.toReal (∫⁻ (a : α), ENNReal.ofReal ‖f a‖ ∂μ)

tactic: exact L1.norm_integral_le _
state_before: case pos
α : Type u_2
E : Type u_1
F : Type ?u.960408
𝕜 : Type ?u.960411
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : CompleteSpace E
inst✝⁵ : NontriviallyNormedField 𝕜
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : SMulCommClass ℝ 𝕜 E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace F
f✝ g : α → E
m : MeasurableSpace α
μ : Measure α
f : α → E
hf : Integrable f
⊢ ‖L1.integral (Integrable.toL1 f hf)‖ ≤ ‖Integrable.toL1 f hf‖

tactic: rw [integral_undef hf, norm_zero]
state_before: case neg
α : Type u_2
E : Type u_1
F : Type ?u.960408
𝕜 : Type ?u.960411
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : CompleteSpace E
inst✝⁵ : NontriviallyNormedField 𝕜
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : SMulCommClass ℝ 𝕜 E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace F
f✝ g : α → E
m : MeasurableSpace α
μ : Measure α
f : α → E
hf : ¬Integrable f
⊢ ‖∫ (a : α), f a ∂μ‖ ≤ ENNReal.toReal (∫⁻ (a : α), ENNReal.ofReal ‖f a‖ ∂μ)

tactic: exact toReal_nonneg
state_before: case neg
α : Type u_2
E : Type u_1
F : Type ?u.960408
𝕜 : Type ?u.960411
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : CompleteSpace E
inst✝⁵ : NontriviallyNormedField 𝕜
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : SMulCommClass ℝ 𝕜 E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace F
f✝ g : α → E
m : MeasurableSpace α
μ : Measure α
f : α → E
hf : ¬Integrable f
⊢ 0 ≤ ENNReal.toReal (∫⁻ (a : α), ENNReal.ofReal ‖f a‖ ∂μ)
Theorem: LieSubalgebra.submodule_span_le_lieSpan
File: Mathlib/Algebra/Lie/Subalgebra.lean

tactic: rw [Submodule.span_le]
state_before: R : Type u
L : Type v
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
L₂ : Type w
inst✝¹ : LieRing L₂
inst✝ : LieAlgebra R L₂
f : L →ₗ⁅R⁆ L₂
K K' : LieSubalgebra R L
K₂ : LieSubalgebra R L₂
s : Set L
⊢ Submodule.span R s ≤ (lieSpan R L s).toSubmodule

tactic: apply subset_lieSpan
state_before: R : Type u
L : Type v
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
L₂ : Type w
inst✝¹ : LieRing L₂
inst✝ : LieAlgebra R L₂
f : L →ₗ⁅R⁆ L₂
K K' : LieSubalgebra R L
K₂ : LieSubalgebra R L₂
s : Set L
⊢ s ⊆ ↑(lieSpan R L s).toSubmodule
Theorem: nonempty_interior_of_iUnion_of_closed
File: Mathlib/Topology/MetricSpace/Baire.lean

tactic: simpa using (dense_iUnion_interior_of_closed hc hU).nonempty
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.29633
ι : Type ?u.29636
inst✝³ : TopologicalSpace α
inst✝² : BaireSpace α
inst✝¹ : Nonempty α
inst✝ : Encodable β
f : β → Set α
hc : ∀ (s : β), IsClosed (f s)
hU : (⋃ (s : β), f s) = univ
⊢ ∃ s, Set.Nonempty (interior (f s))
Theorem: CategoryTheory.Limits.kernelSubobjectIsoComp_inv_arrow
File: Mathlib/CategoryTheory/Subobject/Limits.lean

tactic: simp [kernelSubobjectIsoComp]
state_before: C : Type u
inst✝⁴ : Category C
X Y Z : C
inst✝³ : HasZeroMorphisms C
f✝ : X ⟶ Y
inst✝² : HasKernel f✝
X' : C
f : X' ⟶ X
inst✝¹ : IsIso f
g : X ⟶ Y
inst✝ : HasKernel g
⊢ (kernelSubobjectIsoComp f g).inv ≫ arrow (kernelSubobject (f ≫ g)) = arrow (kernelSubobject g) ≫ inv f
Theorem: Array.toArrayAux_eq
File: src/lean/Init/Data/Array/Basic.lean

tactic: induction as generalizing acc <;> simp [*, List.toArrayAux, Array.push, List.append_assoc, List.concat_eq_append]
state_before: α : Type u_1
as : List α
acc : Array α
⊢ (List.toArrayAux as acc).data = acc.data ++ as
Theorem: Matrix.IsHermitian.coe_re_apply_self
File: Mathlib/LinearAlgebra/Matrix/Hermitian.lean

tactic: rw [← conj_eq_iff_re, ← star_def, ← conjTranspose_apply, h.eq]
state_before: α : Type u_2
β : Type ?u.51699
m : Type ?u.51702
n : Type u_1
A✝ : Matrix n n α
inst✝¹ : IsROrC α
inst✝ : IsROrC β
A : Matrix n n α
h : IsHermitian A
i : n
⊢ ↑(↑re (A i i)) = A i i
Theorem: sup_sdiff_injOn
File: Mathlib/Combinatorics/SetFamily/Compression/UV.lean

tactic: rintro a ha b hb hab
state_before: α : Type u_1
inst✝ : GeneralizedBooleanAlgebra α
u v : α
⊢ Set.InjOn (fun x => (x ⊔ u) \ v) {x | Disjoint u x ∧ v ≤ x}

tactic: have h : ((a ⊔ u) \ v) \ u ⊔ v = ((b ⊔ u) \ v) \ u ⊔ v := by
  dsimp at hab
  rw [hab]
state_before: α : Type u_1
inst✝ : GeneralizedBooleanAlgebra α
u v a : α
ha : a ∈ {x | Disjoint u x ∧ v ≤ x}
b : α
hb : b ∈ {x | Disjoint u x ∧ v ≤ x}
hab : (fun x => (x ⊔ u) \ v) a = (fun x => (x ⊔ u) \ v) b
⊢ a = b

tactic: rwa [sdiff_sdiff_comm, ha.1.symm.sup_sdiff_cancel_right, sdiff_sdiff_comm,
  hb.1.symm.sup_sdiff_cancel_right, sdiff_sup_cancel ha.2, sdiff_sup_cancel hb.2] at h
state_before: α : Type u_1
inst✝ : GeneralizedBooleanAlgebra α
u v a : α
ha : a ∈ {x | Disjoint u x ∧ v ≤ x}
b : α
hb : b ∈ {x | Disjoint u x ∧ v ≤ x}
hab : (fun x => (x ⊔ u) \ v) a = (fun x => (x ⊔ u) \ v) b
h : ((a ⊔ u) \ v) \ u ⊔ v = ((b ⊔ u) \ v) \ u ⊔ v
⊢ a = b

tactic: dsimp at hab
state_before: α : Type u_1
inst✝ : GeneralizedBooleanAlgebra α
u v a : α
ha : a ∈ {x | Disjoint u x ∧ v ≤ x}
b : α
hb : b ∈ {x | Disjoint u x ∧ v ≤ x}
hab : (fun x => (x ⊔ u) \ v) a = (fun x => (x ⊔ u) \ v) b
⊢ ((a ⊔ u) \ v) \ u ⊔ v = ((b ⊔ u) \ v) \ u ⊔ v

tactic: rw [hab]
state_before: α : Type u_1
inst✝ : GeneralizedBooleanAlgebra α
u v a : α
ha : a ∈ {x | Disjoint u x ∧ v ≤ x}
b : α
hb : b ∈ {x | Disjoint u x ∧ v ≤ x}
hab : (a ⊔ u) \ v = (b ⊔ u) \ v
⊢ ((a ⊔ u) \ v) \ u ⊔ v = ((b ⊔ u) \ v) \ u ⊔ v
Theorem: convex_openSegment
File: Mathlib/Analysis/Convex/Basic.lean

tactic: rw [convex_iff_openSegment_subset]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.185790
β : Type ?u.185793
inst✝² : StrictOrderedCommSemiring 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
a b : E
⊢ Convex 𝕜 (openSegment 𝕜 a b)

tactic: rintro p ⟨ap, bp, hap, hbp, habp, rfl⟩ q ⟨aq, bq, haq, hbq, habq, rfl⟩ z ⟨a, b, ha, hb, hab, rfl⟩
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.185790
β : Type ?u.185793
inst✝² : StrictOrderedCommSemiring 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
a b : E
⊢ ∀ ⦃x : E⦄, x ∈ openSegment 𝕜 a b → ∀ ⦃y : E⦄, y ∈ openSegment 𝕜 a b → openSegment 𝕜 x y ⊆ openSegment 𝕜 a b

tactic: refine' ⟨a * ap + b * aq, a * bp + b * bq, by positivity, by positivity, _, _⟩
state_before: case intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro
𝕜 : Type u_1
E : Type u_2
F : Type ?u.185790
β : Type ?u.185793
inst✝² : StrictOrderedCommSemiring 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
a✝ b✝ : E
ap bp : 𝕜
hap : 0 < ap
hbp : 0 < bp
habp : ap + bp = 1
aq bq : 𝕜
haq : 0 < aq
hbq : 0 < bq
habq : aq + bq = 1
a b : 𝕜
ha : 0 < a
hb : 0 < b
hab : a + b = 1
⊢ a • (ap • a✝ + bp • b✝) + b • (aq • a✝ + bq • b✝) ∈ openSegment 𝕜 a✝ b✝

tactic: positivity
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.185790
β : Type ?u.185793
inst✝² : StrictOrderedCommSemiring 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
a✝ b✝ : E
ap bp : 𝕜
hap : 0 < ap
hbp : 0 < bp
habp : ap + bp = 1
aq bq : 𝕜
haq : 0 < aq
hbq : 0 < bq
habq : aq + bq = 1
a b : 𝕜
ha : 0 < a
hb : 0 < b
hab : a + b = 1
⊢ 0 < a * ap + b * aq

tactic: positivity
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.185790
β : Type ?u.185793
inst✝² : StrictOrderedCommSemiring 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
a✝ b✝ : E
ap bp : 𝕜
hap : 0 < ap
hbp : 0 < bp
habp : ap + bp = 1
aq bq : 𝕜
haq : 0 < aq
hbq : 0 < bq
habq : aq + bq = 1
a b : 𝕜
ha : 0 < a
hb : 0 < b
hab : a + b = 1
⊢ 0 < a * bp + b * bq

tactic: rw [add_add_add_comm, ← mul_add, ← mul_add, habp, habq, mul_one, mul_one, hab]
state_before: case intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.refine'_1
𝕜 : Type u_1
E : Type u_2
F : Type ?u.185790
β : Type ?u.185793
inst✝² : StrictOrderedCommSemiring 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
a✝ b✝ : E
ap bp : 𝕜
hap : 0 < ap
hbp : 0 < bp
habp : ap + bp = 1
aq bq : 𝕜
haq : 0 < aq
hbq : 0 < bq
habq : aq + bq = 1
a b : 𝕜
ha : 0 < a
hb : 0 < b
hab : a + b = 1
⊢ a * ap + b * aq + (a * bp + b * bq) = 1

tactic: simp_rw [add_smul, mul_smul, smul_add, add_add_add_comm]
state_before: case intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.refine'_2
𝕜 : Type u_1
E : Type u_2
F : Type ?u.185790
β : Type ?u.185793
inst✝² : StrictOrderedCommSemiring 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
a✝ b✝ : E
ap bp : 𝕜
hap : 0 < ap
hbp : 0 < bp
habp : ap + bp = 1
aq bq : 𝕜
haq : 0 < aq
hbq : 0 < bq
habq : aq + bq = 1
a b : 𝕜
ha : 0 < a
hb : 0 < b
hab : a + b = 1
⊢ (a * ap + b * aq) • a✝ + (a * bp + b * bq) • b✝ = a • (ap • a✝ + bp • b✝) + b • (aq • a✝ + bq • b✝)
Theorem: CategoryTheory.Subobject.inf_map
File: Mathlib/CategoryTheory/Subobject/Lattice.lean

tactic: revert f₁
state_before: C : Type u₁
inst✝³ : Category C
X✝ Y✝ Z : C
D : Type u₂
inst✝² : Category D
inst✝¹ : HasPullbacks C
X Y : C
g : Y ⟶ X
inst✝ : Mono g
f₁ f₂ : Subobject Y
⊢ (map g).obj (f₁ ⊓ f₂) = (map g).obj f₁ ⊓ (map g).obj f₂

tactic: apply Quotient.ind'
state_before: C : Type u₁
inst✝³ : Category C
X✝ Y✝ Z : C
D : Type u₂
inst✝² : Category D
inst✝¹ : HasPullbacks C
X Y : C
g : Y ⟶ X
inst✝ : Mono g
f₂ : Subobject Y
⊢ ∀ (f₁ : Subobject Y), (map g).obj (f₁ ⊓ f₂) = (map g).obj f₁ ⊓ (map g).obj f₂

tactic: intro f₁
state_before: case h
C : Type u₁
inst✝³ : Category C
X✝ Y✝ Z : C
D : Type u₂
inst✝² : Category D
inst✝¹ : HasPullbacks C
X Y : C
g : Y ⟶ X
inst✝ : Mono g
f₂ : Subobject Y
⊢ ∀ (a : MonoOver Y), (map g).obj (Quotient.mk'' a ⊓ f₂) = (map g).obj (Quotient.mk'' a) ⊓ (map g).obj f₂

tactic: erw [inf_def, inf_def, inf_eq_map_pullback', inf_eq_map_pullback', ← map_comp]
state_before: case h
C : Type u₁
inst✝³ : Category C
X✝ Y✝ Z : C
D : Type u₂
inst✝² : Category D
inst✝¹ : HasPullbacks C
X Y : C
g : Y ⟶ X
inst✝ : Mono g
f₂ : Subobject Y
f₁ : MonoOver Y
⊢ (map g).obj (Quotient.mk'' f₁ ⊓ f₂) = (map g).obj (Quotient.mk'' f₁) ⊓ (map g).obj f₂

tactic: dsimp
state_before: case h
C : Type u₁
inst✝³ : Category C
X✝ Y✝ Z : C
D : Type u₂
inst✝² : Category D
inst✝¹ : HasPullbacks C
X Y : C
g : Y ⟶ X
inst✝ : Mono g
f₂ : Subobject Y
f₁ : MonoOver Y
⊢ (map (MonoOver.arrow f₁ ≫ g)).obj ((pullback (MonoOver.arrow f₁)).obj f₂) =
    (map (MonoOver.arrow ((MonoOver.map g).obj f₁))).obj
      ((pullback (MonoOver.arrow ((MonoOver.map g).obj f₁))).obj ((map g).obj f₂))

tactic: rw [pullback_comp, pullback_map_self]
state_before: case h
C : Type u₁
inst✝³ : Category C
X✝ Y✝ Z : C
D : Type u₂
inst✝² : Category D
inst✝¹ : HasPullbacks C
X Y : C
g : Y ⟶ X
inst✝ : Mono g
f₂ : Subobject Y
f₁ : MonoOver Y
⊢ (map (MonoOver.arrow f₁ ≫ g)).obj ((pullback (MonoOver.arrow f₁)).obj f₂) =
    (map (MonoOver.arrow f₁ ≫ g)).obj ((pullback (MonoOver.arrow f₁ ≫ g)).obj ((map g).obj f₂))
Theorem: Nat.coprime.gcd_mul_left_cancel
File: Std/Data/Nat/Gcd.lean

tactic: rw [coprime, Nat.gcd_assoc, H.symm.gcd_eq_one, gcd_one_right]
state_before: k n m : Nat
H : coprime k n
⊢ coprime (gcd (k * m) n) k
Theorem: Filter.prod_top
File: Mathlib/Order/Filter/Prod.lean

tactic: dsimp only [SProd.sprod]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.4998
δ : Type ?u.5001
ι : Sort ?u.5004
s : Set α
t : Set β
f✝ : Filter α
g : Filter β
f : Filter α
⊢ f ×ˢ ⊤ = comap Prod.fst f

tactic: rw [Filter.prod, comap_top, inf_top_eq]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.4998
δ : Type ?u.5001
ι : Sort ?u.5004
s : Set α
t : Set β
f✝ : Filter α
g : Filter β
f : Filter α
⊢ Filter.prod f ⊤ = comap Prod.fst f
Theorem: AddCommGroup.sub_modEq_zero
File: Mathlib/Algebra/ModEq.lean

tactic: simp [sub_modEq_iff_modEq_add]
state_before: α : Type u_1
inst✝ : AddCommGroup α
p a a₁ a₂ b b₁ b₂ c : α
n : ℕ
z : ℤ
⊢ a - b ≡ 0 [PMOD p] ↔ a ≡ b [PMOD p]
Theorem: CategoryTheory.Limits.isKernelCompMono_lift
File: Mathlib/CategoryTheory/Limits/Shapes/Kernels.lean

tactic: rw [← cancel_mono g, Category.assoc, ← hh]
state_before: C : Type u
inst✝¹ : Category C
inst✝ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
c : KernelFork f
i : IsLimit c
Z : C
g : Y ⟶ Z
hg : Mono g
h : X ⟶ Z
hh : h = f ≫ g
s : KernelFork h
⊢ Fork.ι s ≫ f = Fork.ι s ≫ 0

tactic: simp
state_before: C : Type u
inst✝¹ : Category C
inst✝ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
c : KernelFork f
i : IsLimit c
Z : C
g : Y ⟶ Z
hg : Mono g
h : X ⟶ Z
hh : h = f ≫ g
s : KernelFork h
⊢ Fork.ι s ≫ h = (Fork.ι s ≫ 0) ≫ g
Theorem: succ_ne_self
File: Mathlib/Algebra/Ring/Basic.lean

tactic: simp [h]
state_before: α : Type u_1
inst✝¹ : NonAssocRing α
inst✝ : Nontrivial α
a : α
h : a + 1 = a
⊢ a + 1 = a + 0
Theorem: MeasureTheory.Measure.restrict_union_add_inter'
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: simpa only [union_comm, inter_comm, add_comm] using restrict_union_add_inter t hs
state_before: α : Type u_1
β : Type ?u.295789
γ : Type ?u.295792
δ : Type ?u.295795
ι : Type ?u.295798
R : Type ?u.295801
R' : Type ?u.295804
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t✝ : Set α
hs : MeasurableSet s
t : Set α
⊢ restrict μ (s ∪ t) + restrict μ (s ∩ t) = restrict μ s + restrict μ t
Theorem: Nat.frequently_even
File: Mathlib/Order/Filter/ModEq.lean

tactic: simpa only [even_iff] using frequently_mod_eq zero_lt_two
state_before: ⊢ ∃ᶠ (m : ℕ) in atTop, Even m
Theorem: Finset.disjSups_empty_left
File: Mathlib/Data/Finset/Sups.lean

tactic: simp [disjSups]
state_before: α : Type u_1
inst✝³ : DecidableEq α
inst✝² : SemilatticeSup α
inst✝¹ : OrderBot α
inst✝ : DecidableRel Disjoint
s s₁ s₂ t t₁ t₂ u : Finset α
a b c : α
⊢ ∅ ○ t = ∅
Theorem: Submodule.prod_eq_bot_iff
File: Mathlib/LinearAlgebra/Prod.lean

tactic: simp only [eq_bot_iff, prod_le_iff, (gc_map_comap _).le_iff_le, comap_bot, ker_inl, ker_inr]
state_before: R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
M₅ : Type ?u.385373
M₆ : Type ?u.385376
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : AddCommMonoid M₂
inst✝¹ : Module R M
inst✝ : Module R M₂
p : Submodule R M
q : Submodule R M₂
p₁ : Submodule R M
p₂ : Submodule R M₂
⊢ prod p₁ p₂ = ⊥ ↔ p₁ = ⊥ ∧ p₂ = ⊥
Theorem: Quotient.eq_mk_iff_out
File: Mathlib/Data/Quot.lean

tactic: refine' Iff.trans _ Quotient.eq
state_before: α : Sort u_1
β : Sort ?u.34513
s : Setoid α
x : Quotient s
y : α
⊢ x = Quotient.mk s y ↔ out x ≈ y

tactic: rw [Quotient.out_eq x]
state_before: α : Sort u_1
β : Sort ?u.34513
s : Setoid α
x : Quotient s
y : α
⊢ x = Quotient.mk s y ↔ Quotient.mk s (out x) = Quotient.mk s y
Theorem: StructureGroupoid.LocalInvariantProp.liftPropOn_symm_of_mem_maximalAtlas
File: Mathlib/Geometry/Manifold/LocalInvariantProperties.lean

tactic: intro x hx
state_before: H : Type u_1
M : Type u_2
H' : Type ?u.58167
M' : Type ?u.58170
X : Type ?u.58173
inst✝⁷ : TopologicalSpace H
inst✝⁶ : TopologicalSpace M
inst✝⁵ : ChartedSpace H M
inst✝⁴ : TopologicalSpace H'
inst✝³ : TopologicalSpace M'
inst✝² : ChartedSpace H' M'
inst✝¹ : TopologicalSpace X
G : StructureGroupoid H
G' : StructureGroupoid H'
e e' : LocalHomeomorph M H
f f' : LocalHomeomorph M' H'
P : (H → H') → Set H → H → Prop
g g' : M → M'
s t : Set M
x : M
Q : (H → H) → Set H → H → Prop
hG✝ : LocalInvariantProp G G' P
inst✝ : HasGroupoid M G
hG : LocalInvariantProp G G Q
hQ : ∀ (y : H), Q id univ y
he : e ∈ maximalAtlas M G
⊢ LiftPropOn Q (↑(LocalHomeomorph.symm e)) e.target

tactic: apply hG.liftPropWithinAt_of_liftPropAt_of_mem_nhds
  (hG.liftPropAt_symm_of_mem_maximalAtlas hQ he hx)
state_before: H : Type u_1
M : Type u_2
H' : Type ?u.58167
M' : Type ?u.58170
X : Type ?u.58173
inst✝⁷ : TopologicalSpace H
inst✝⁶ : TopologicalSpace M
inst✝⁵ : ChartedSpace H M
inst✝⁴ : TopologicalSpace H'
inst✝³ : TopologicalSpace M'
inst✝² : ChartedSpace H' M'
inst✝¹ : TopologicalSpace X
G : StructureGroupoid H
G' : StructureGroupoid H'
e e' : LocalHomeomorph M H
f f' : LocalHomeomorph M' H'
P : (H → H') → Set H → H → Prop
g g' : M → M'
s t : Set M
x✝ : M
Q : (H → H) → Set H → H → Prop
hG✝ : LocalInvariantProp G G' P
inst✝ : HasGroupoid M G
hG : LocalInvariantProp G G Q
hQ : ∀ (y : H), Q id univ y
he : e ∈ maximalAtlas M G
x : H
hx : x ∈ e.target
⊢ LiftPropWithinAt Q (↑(LocalHomeomorph.symm e)) e.target x

tactic: exact IsOpen.mem_nhds e.open_target hx
state_before: H : Type u_1
M : Type u_2
H' : Type ?u.58167
M' : Type ?u.58170
X : Type ?u.58173
inst✝⁷ : TopologicalSpace H
inst✝⁶ : TopologicalSpace M
inst✝⁵ : ChartedSpace H M
inst✝⁴ : TopologicalSpace H'
inst✝³ : TopologicalSpace M'
inst✝² : ChartedSpace H' M'
inst✝¹ : TopologicalSpace X
G : StructureGroupoid H
G' : StructureGroupoid H'
e e' : LocalHomeomorph M H
f f' : LocalHomeomorph M' H'
P : (H → H') → Set H → H → Prop
g g' : M → M'
s t : Set M
x✝ : M
Q : (H → H) → Set H → H → Prop
hG✝ : LocalInvariantProp G G' P
inst✝ : HasGroupoid M G
hG : LocalInvariantProp G G Q
hQ : ∀ (y : H), Q id univ y
he : e ∈ maximalAtlas M G
x : H
hx : x ∈ e.target
⊢ e.target ∈ 𝓝 x
Theorem: Equiv.sigmaCongrRight_sigmaEquivProd
File: Mathlib/Logic/Equiv/Basic.lean

tactic: ext ⟨a, b⟩ : 1
state_before: α₁ : Type u_3
β₁ : Type u_2
β₂ : Type u_1
e : α₁ → β₁ ≃ β₂
⊢ (sigmaCongrRight e).trans (sigmaEquivProd α₁ β₂) = (sigmaEquivProd α₁ β₁).trans (prodCongrRight e)

tactic: simp
state_before: case H.mk
α₁ : Type u_3
β₁ : Type u_2
β₂ : Type u_1
e : α₁ → β₁ ≃ β₂
a : α₁
b : β₁
⊢ ↑((sigmaCongrRight e).trans (sigmaEquivProd α₁ β₂)) { fst := a, snd := b } =
    ↑((sigmaEquivProd α₁ β₁).trans (prodCongrRight e)) { fst := a, snd := b }
Theorem: CategoryTheory.Discrete.functor_map_id
File: Mathlib/CategoryTheory/DiscreteCategory.lean

tactic: have h : f = 𝟙 j := by aesop_cat
state_before: J : Type v₁
C : Type u₂
inst✝ : Category C
F : Discrete J ⥤ C
j : Discrete J
f : j ⟶ j
⊢ F.map f = 𝟙 (F.obj j)

tactic: rw [h]
state_before: J : Type v₁
C : Type u₂
inst✝ : Category C
F : Discrete J ⥤ C
j : Discrete J
f : j ⟶ j
h : f = 𝟙 j
⊢ F.map f = 𝟙 (F.obj j)

tactic: simp
state_before: J : Type v₁
C : Type u₂
inst✝ : Category C
F : Discrete J ⥤ C
j : Discrete J
f : j ⟶ j
h : f = 𝟙 j
⊢ F.map (𝟙 j) = 𝟙 (F.obj j)

tactic: aesop_cat
state_before: J : Type v₁
C : Type u₂
inst✝ : Category C
F : Discrete J ⥤ C
j : Discrete J
f : j ⟶ j
⊢ f = 𝟙 j
Theorem: intervalIntegral.integral_comp_sub_mul
File: Mathlib/MeasureTheory/Integral/IntervalIntegral.lean

tactic: simp only [sub_eq_add_neg, neg_mul_eq_neg_mul]
state_before: ι : Type ?u.14923117
𝕜 : Type ?u.14923120
E : Type u_1
F : Type ?u.14923126
A : Type ?u.14923129
inst✝² : NormedAddCommGroup E
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
a b c d✝ : ℝ
f : ℝ → E
hc : c ≠ 0
d : ℝ
⊢ (∫ (x : ℝ) in a..b, f (d - c * x)) = c⁻¹ • ∫ (x : ℝ) in d - c * b..d - c * a, f x

tactic: rw [integral_comp_add_mul f (neg_ne_zero.mpr hc) d, integral_symm]
state_before: ι : Type ?u.14923117
𝕜 : Type ?u.14923120
E : Type u_1
F : Type ?u.14923126
A : Type ?u.14923129
inst✝² : NormedAddCommGroup E
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
a b c d✝ : ℝ
f : ℝ → E
hc : c ≠ 0
d : ℝ
⊢ (∫ (x : ℝ) in a..b, f (d + -c * x)) = c⁻¹ • ∫ (x : ℝ) in d + -c * b..d + -c * a, f x

tactic: simp only [inv_neg, smul_neg, neg_neg, neg_smul]
state_before: ι : Type ?u.14923117
𝕜 : Type ?u.14923120
E : Type u_1
F : Type ?u.14923126
A : Type ?u.14923129
inst✝² : NormedAddCommGroup E
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
a b c d✝ : ℝ
f : ℝ → E
hc : c ≠ 0
d : ℝ
⊢ ((-c)⁻¹ • -∫ (x : ℝ) in d + -c * b..d + -c * a, f x) = c⁻¹ • ∫ (x : ℝ) in d + -c * b..d + -c * a, f x
Theorem: CategoryTheory.Limits.coprod.map_id_comp
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 W X
inst✝¹ : HasBinaryCoproduct W Y
inst✝ : HasBinaryCoproduct W Z
⊢ map (𝟙 W) (f ≫ g) = map (𝟙 W) f ≫ map (𝟙 W) g
Theorem: Int.natAbs_eq_iff
File: Std/Data/Int/Lemmas.lean

tactic: rw [← Int.natAbs_eq_natAbs_iff, Int.natAbs_ofNat]
state_before: a : Int
n : Nat
⊢ natAbs a = n ↔ a = ↑n ∨ a = -↑n
Theorem: Equiv.Perm.isCycle_cycleOf
File: Mathlib/GroupTheory/Perm/Cycle/Basic.lean

tactic: rwa [SameCycle.rfl.cycleOf_apply]
state_before: ι : Type ?u.2439325
α : Type u_1
β : Type ?u.2439331
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f✝ g : Perm α
x y : α
f : Perm α
hx : ↑f x ≠ x
⊢ ↑(cycleOf f x) x ≠ x

tactic: rw [cycleOf_zpow_apply_self, hi]
state_before: ι : Type ?u.2439325
α : Type u_1
β : Type ?u.2439331
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f✝ g : Perm α
x y✝ : α
f : Perm α
hx : ↑f x ≠ x
this : ↑(cycleOf f x) x ≠ x
y : α
h : ↑(cycleOf f x) y ≠ y
hxy : SameCycle f x y
i : ℤ
hi : ↑(f ^ i) x = y
⊢ ↑(cycleOf f x ^ i) x = y

tactic: rw [cycleOf_apply_of_not_sameCycle hxy] at h
state_before: ι : Type ?u.2439325
α : Type u_1
β : Type ?u.2439331
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f✝ g : Perm α
x y✝ : α
f : Perm α
hx : ↑f x ≠ x
this : ↑(cycleOf f x) x ≠ x
y : α
h : ↑(cycleOf f x) y ≠ y
hxy : ¬SameCycle f x y
⊢ SameCycle (cycleOf f x) x y

tactic: exact (h rfl).elim
state_before: ι : Type ?u.2439325
α : Type u_1
β : Type ?u.2439331
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f✝ g : Perm α
x y✝ : α
f : Perm α
hx : ↑f x ≠ x
this : ↑(cycleOf f x) x ≠ x
y : α
h : y ≠ y
hxy : ¬SameCycle f x y
⊢ SameCycle (cycleOf f x) x y
Theorem: Set.sInter_prod
File: Mathlib/Data/Set/Lattice.lean

tactic: rw [← sInter_singleton t, sInter_prod_sInter hS (singleton_nonempty t), sInter_singleton]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.239402
ι : Sort ?u.239405
ι' : Sort ?u.239408
ι₂ : Sort ?u.239411
κ : ι → Sort ?u.239416
κ₁ : ι → Sort ?u.239421
κ₂ : ι → Sort ?u.239426
κ' : ι' → Sort ?u.239431
S : Set (Set α)
hS : Set.Nonempty S
t : Set β
⊢ ⋂₀ S ×ˢ t = ⋂ (s : Set α) (_ : s ∈ S), s ×ˢ t

tactic: simp_rw [prod_singleton, mem_image, iInter_exists, biInter_and', iInter_iInter_eq_right]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.239402
ι : Sort ?u.239405
ι' : Sort ?u.239408
ι₂ : Sort ?u.239411
κ : ι → Sort ?u.239416
κ₁ : ι → Sort ?u.239421
κ₂ : ι → Sort ?u.239426
κ' : ι' → Sort ?u.239431
S : Set (Set α)
hS : Set.Nonempty S
t : Set β
⊢ (⋂ (r : Set α × Set β) (_ : r ∈ S ×ˢ {t}), r.fst ×ˢ r.snd) = ⋂ (s : Set α) (_ : s ∈ S), s ×ˢ t
Theorem: Filter.HasBasis.isVonNBounded_basis_iff
File: Mathlib/Analysis/LocallyConvex/Bounded.lean

tactic: refine' ⟨fun hA i hi => hA (h.mem_of_mem hi), fun hA V hV => _⟩
state_before: 𝕜 : Type u_3
𝕜' : Type ?u.978
E : Type u_1
E' : Type ?u.984
F : Type ?u.987
ι : Type u_2
inst✝³ : SeminormedRing 𝕜
inst✝² : SMul 𝕜 E
inst✝¹ : Zero E
inst✝ : TopologicalSpace E
q : ι → Prop
s : ι → Set E
A : Set E
h : HasBasis (𝓝 0) q s
⊢ IsVonNBounded 𝕜 A ↔ ∀ (i : ι), q i → Absorbs 𝕜 (s i) A

tactic: rcases h.mem_iff.mp hV with ⟨i, hi, hV⟩
state_before: 𝕜 : Type u_3
𝕜' : Type ?u.978
E : Type u_1
E' : Type ?u.984
F : Type ?u.987
ι : Type u_2
inst✝³ : SeminormedRing 𝕜
inst✝² : SMul 𝕜 E
inst✝¹ : Zero E
inst✝ : TopologicalSpace E
q : ι → Prop
s : ι → Set E
A : Set E
h : HasBasis (𝓝 0) q s
hA : ∀ (i : ι), q i → Absorbs 𝕜 (s i) A
V : Set E
hV : V ∈ 𝓝 0
⊢ Absorbs 𝕜 V A

tactic: exact (hA i hi).mono_left hV
state_before: case intro.intro
𝕜 : Type u_3
𝕜' : Type ?u.978
E : Type u_1
E' : Type ?u.984
F : Type ?u.987
ι : Type u_2
inst✝³ : SeminormedRing 𝕜
inst✝² : SMul 𝕜 E
inst✝¹ : Zero E
inst✝ : TopologicalSpace E
q : ι → Prop
s : ι → Set E
A : Set E
h : HasBasis (𝓝 0) q s
hA : ∀ (i : ι), q i → Absorbs 𝕜 (s i) A
V : Set E
hV✝ : V ∈ 𝓝 0
i : ι
hi : q i
hV : s i ⊆ V
⊢ Absorbs 𝕜 V A