tasksource/leandojo huggingface dataset:
Theorem: List.tail_sum
File: Mathlib/Data/List/BigOperators/Basic.lean

tactic: rw [← headI_add_tail_sum L, add_comm, @add_tsub_cancel_right]
state_before: ι : Type ?u.161222
α : Type ?u.161225
M : Type ?u.161228
N : Type ?u.161231
P : Type ?u.161234
M₀ : Type ?u.161237
G : Type ?u.161240
R : Type ?u.161243
L : List ℕ
⊢ sum (tail L) = sum L - headI L
Theorem: MeasureTheory.isFiniteMeasure_withDensity
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

tactic: rwa [withDensity_apply _ MeasurableSet.univ, Measure.restrict_univ, lt_top_iff_ne_top]
state_before: α : Type u_1
β : Type ?u.1762622
γ : Type ?u.1762625
δ : Type ?u.1762628
m : MeasurableSpace α
μ ν : Measure α
f : α → ℝ≥0∞
hf : (∫⁻ (a : α), f a ∂μ) ≠ ⊤
⊢ ↑↑(withDensity μ f) univ < ⊤
Theorem: LocalHomeomorph.ofSet_trans
File: Mathlib/Topology/LocalHomeomorph.lean

tactic: simp [hs.interior_eq, inter_comm]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.72442
δ : Type ?u.72445
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
e : LocalHomeomorph α β
e' : LocalHomeomorph β γ
s : Set α
hs : IsOpen s
⊢ (LocalHomeomorph.trans (ofSet s hs) e).toLocalEquiv.source = (LocalHomeomorph.restr e s).toLocalEquiv.source
Theorem: MeasureTheory.L2.snorm_rpow_two_norm_lt_top
File: Mathlib/MeasureTheory/Function/L2Space.lean

tactic: have h_two : ENNReal.ofReal (2 : ℝ) = 2 := by simp [zero_le_one]
state_before: α : Type u_1
E : Type ?u.42419
F : Type u_2
𝕜 : Type ?u.42425
inst✝⁴ : IsROrC 𝕜
inst✝³ : MeasurableSpace α
μ : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : InnerProductSpace 𝕜 E
inst✝ : NormedAddCommGroup F
f : { x // x ∈ Lp F 2 }
⊢ snorm (fun x => ‖↑↑f x‖ ^ 2) 1 μ < ⊤

tactic: rw [snorm_norm_rpow f zero_lt_two, one_mul, h_two]
state_before: α : Type u_1
E : Type ?u.42419
F : Type u_2
𝕜 : Type ?u.42425
inst✝⁴ : IsROrC 𝕜
inst✝³ : MeasurableSpace α
μ : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : InnerProductSpace 𝕜 E
inst✝ : NormedAddCommGroup F
f : { x // x ∈ Lp F 2 }
h_two : ENNReal.ofReal 2 = 2
⊢ snorm (fun x => ‖↑↑f x‖ ^ 2) 1 μ < ⊤

tactic: exact ENNReal.rpow_lt_top_of_nonneg zero_le_two (Lp.snorm_ne_top f)
state_before: α : Type u_1
E : Type ?u.42419
F : Type u_2
𝕜 : Type ?u.42425
inst✝⁴ : IsROrC 𝕜
inst✝³ : MeasurableSpace α
μ : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : InnerProductSpace 𝕜 E
inst✝ : NormedAddCommGroup F
f : { x // x ∈ Lp F 2 }
h_two : ENNReal.ofReal 2 = 2
⊢ snorm (↑↑f) 2 μ ^ 2 < ⊤

tactic: simp [zero_le_one]
state_before: α : Type u_1
E : Type ?u.42419
F : Type u_2
𝕜 : Type ?u.42425
inst✝⁴ : IsROrC 𝕜
inst✝³ : MeasurableSpace α
μ : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : InnerProductSpace 𝕜 E
inst✝ : NormedAddCommGroup F
f : { x // x ∈ Lp F 2 }
⊢ ENNReal.ofReal 2 = 2
Theorem: PrimeMultiset.prod_smul
File: Mathlib/Data/PNat/Factors.lean

tactic: induction' d with n ih
state_before: d : ℕ
u : PrimeMultiset
⊢ prod (d • u) = Pow.pow (prod u) d

tactic: rfl
state_before: case zero
u : PrimeMultiset
⊢ prod (Nat.zero • u) = Pow.pow (prod u) Nat.zero

tactic: have : ∀ n' : ℕ, Pow.pow (prod u) n' = Monoid.npow n' (prod u) := fun _ ↦ rfl
state_before: case succ
u : PrimeMultiset
n : ℕ
ih : prod (n • u) = Pow.pow (prod u) n
⊢ prod (Nat.succ n • u) = Pow.pow (prod u) (Nat.succ n)

tactic: rw [succ_nsmul, prod_add, ih, this, this, Monoid.npow_succ, mul_comm]
state_before: case succ
u : PrimeMultiset
n : ℕ
ih : prod (n • u) = Pow.pow (prod u) n
this : ∀ (n' : ℕ), Pow.pow (prod u) n' = Monoid.npow n' (prod u)
⊢ prod (Nat.succ n • u) = Pow.pow (prod u) (Nat.succ n)
Theorem: Complex.normSq_I
File: Mathlib/Data/Complex/Basic.lean

tactic: simp [normSq]
state_before: ⊢ ↑normSq I = 1
Theorem: Mathlib.Meta.NormNum.isRat_inv_zero
File: Mathlib/Tactic/NormNum/Basic.lean

tactic: simp
state_before: α : Type u_1
inst✝ : DivisionRing α
⊢ (↑0)⁻¹ = ↑0
Theorem: Asymptotics.isLittleO_const_left_of_ne
File: Mathlib/Analysis/Asymptotics/Asymptotics.lean

tactic: simp only [← isLittleO_one_left_iff ℝ]
state_before: α : Type u_2
β : Type ?u.607645
E : Type ?u.607648
F : Type u_3
G : Type ?u.607654
E' : Type ?u.607657
F' : Type ?u.607660
G' : Type ?u.607663
E'' : Type u_1
F'' : Type ?u.607669
G'' : Type ?u.607672
R : Type ?u.607675
R' : Type ?u.607678
𝕜 : Type ?u.607681
𝕜' : Type ?u.607684
inst✝¹² : Norm E
inst✝¹¹ : Norm F
inst✝¹⁰ : Norm G
inst✝⁹ : SeminormedAddCommGroup E'
inst✝⁸ : SeminormedAddCommGroup F'
inst✝⁷ : SeminormedAddCommGroup G'
inst✝⁶ : NormedAddCommGroup E''
inst✝⁵ : NormedAddCommGroup F''
inst✝⁴ : NormedAddCommGroup G''
inst✝³ : SeminormedRing R
inst✝² : SeminormedRing R'
inst✝¹ : NormedField 𝕜
inst✝ : NormedField 𝕜'
c✝ c' c₁ c₂ : ℝ
f : α → E
g : α → F
k : α → G
f' : α → E'
g' : α → F'
k' : α → G'
f'' : α → E''
g'' : α → F''
k'' : α → G''
l l' : Filter α
c : E''
hc : c ≠ 0
⊢ (fun _x => c) =o[l] g ↔ Tendsto (fun x => ‖g x‖) l atTop

tactic: exact ⟨(isBigO_const_const (1 : ℝ) hc l).trans_isLittleO,
  (isBigO_const_one ℝ c l).trans_isLittleO⟩
state_before: α : Type u_2
β : Type ?u.607645
E : Type ?u.607648
F : Type u_3
G : Type ?u.607654
E' : Type ?u.607657
F' : Type ?u.607660
G' : Type ?u.607663
E'' : Type u_1
F'' : Type ?u.607669
G'' : Type ?u.607672
R : Type ?u.607675
R' : Type ?u.607678
𝕜 : Type ?u.607681
𝕜' : Type ?u.607684
inst✝¹² : Norm E
inst✝¹¹ : Norm F
inst✝¹⁰ : Norm G
inst✝⁹ : SeminormedAddCommGroup E'
inst✝⁸ : SeminormedAddCommGroup F'
inst✝⁷ : SeminormedAddCommGroup G'
inst✝⁶ : NormedAddCommGroup E''
inst✝⁵ : NormedAddCommGroup F''
inst✝⁴ : NormedAddCommGroup G''
inst✝³ : SeminormedRing R
inst✝² : SeminormedRing R'
inst✝¹ : NormedField 𝕜
inst✝ : NormedField 𝕜'
c✝ c' c₁ c₂ : ℝ
f : α → E
g : α → F
k : α → G
f' : α → E'
g' : α → F'
k' : α → G'
f'' : α → E''
g'' : α → F''
k'' : α → G''
l l' : Filter α
c : E''
hc : c ≠ 0
⊢ (fun _x => c) =o[l] g ↔ (fun _x => 1) =o[l] fun x => g x
Theorem: FirstOrder.Language.LHom.onTheory_model
File: Mathlib/ModelTheory/Semantics.lean

tactic: simp [Theory.model_iff, LHom.onTheory]
state_before: L : Language
L' : Language
M : Type w
N : Type ?u.330070
P : Type ?u.330073
inst✝⁴ : Structure L M
inst✝³ : Structure L N
inst✝² : Structure L P
α : Type u'
β : Type v'
n : ℕ
T✝ : Theory L
inst✝¹ : Structure L' M
φ : L →ᴸ L'
inst✝ : IsExpansionOn φ M
T : Theory L
⊢ M ⊨ onTheory φ T ↔ M ⊨ T
Theorem: Units.inv_mul_eq_iff_eq_mul
File: Mathlib/Algebra/Group/Units.lean

tactic: rw [← h, mul_inv_cancel_left]
state_before: α : Type u
inst✝ : Monoid α
a b✝ c✝ u : αˣ
b c : α
h : ↑a⁻¹ * b = c
⊢ b = ↑a * c

tactic: rw [h, inv_mul_cancel_left]
state_before: α : Type u
inst✝ : Monoid α
a b✝ c✝ u : αˣ
b c : α
h : b = ↑a * c
⊢ ↑a⁻¹ * b = c
Theorem: eq_mul_inv_iff_mul_eq
File: Mathlib/Algebra/Group/Basic.lean

tactic: rw [h, inv_mul_cancel_right]
state_before: α : Type ?u.54177
β : Type ?u.54180
G : Type u_1
inst✝ : Group G
a b c d : G
h : a = b * c⁻¹
⊢ a * c = b

tactic: rw [← h, mul_inv_cancel_right]
state_before: α : Type ?u.54177
β : Type ?u.54180
G : Type u_1
inst✝ : Group G
a b c d : G
h : a * c = b
⊢ a = b * c⁻¹
Theorem: Finset.Ioc_subset_Ioo_right
File: Mathlib/Data/Finset/LocallyFinite.lean

tactic: rw [← coe_subset, coe_Ioc, coe_Ioo]
state_before: ι : Type ?u.22707
α : Type u_1
inst✝¹ : Preorder α
inst✝ : LocallyFiniteOrder α
a a₁ a₂ b b₁ b₂ c x : α
h : b₁ < b₂
⊢ Ioc a b₁ ⊆ Ioo a b₂

tactic: exact Set.Ioc_subset_Ioo_right h
state_before: ι : Type ?u.22707
α : Type u_1
inst✝¹ : Preorder α
inst✝ : LocallyFiniteOrder α
a a₁ a₂ b b₁ b₂ c x : α
h : b₁ < b₂
⊢ Set.Ioc a b₁ ⊆ Set.Ioo a b₂
Theorem: AffineSubspace.nonempty_of_affineSpan_eq_top
File: Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean

tactic: rw [Set.nonempty_iff_ne_empty]
state_before: k : Type u_2
V : Type u_3
P : Type u_1
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
p₁ p₂ : P
s : Set P
h : affineSpan k s = ⊤
⊢ Set.Nonempty s

tactic: rintro rfl
state_before: k : Type u_2
V : Type u_3
P : Type u_1
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
p₁ p₂ : P
s : Set P
h : affineSpan k s = ⊤
⊢ s ≠ ∅

tactic: rw [AffineSubspace.span_empty] at h
state_before: k : Type u_2
V : Type u_3
P : Type u_1
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
p₁ p₂ : P
h : affineSpan k ∅ = ⊤
⊢ False

tactic: exact bot_ne_top k V P h
state_before: k : Type u_2
V : Type u_3
P : Type u_1
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
p₁ p₂ : P
h : ⊥ = ⊤
⊢ False
Theorem: Bool.not_inj
File: Mathlib/Data/Bool/Basic.lean

tactic: decide
state_before: ⊢ ∀ {a b : Bool}, (!decide (a = !b)) = true → a = b
Theorem: Finsupp.zipWith_neLocus_eq_right
File: Mathlib/Data/Finsupp/NeLocus.lean

tactic: ext
state_before: α : Type u_4
M : Type u_1
N : Type u_3
P : Type u_2
inst✝⁵ : DecidableEq α
inst✝⁴ : DecidableEq M
inst✝³ : Zero M
inst✝² : DecidableEq P
inst✝¹ : Zero P
inst✝ : Zero N
F : M → N → P
F0 : F 0 0 = 0
f₁ f₂ : α →₀ M
g : α →₀ N
hF : ∀ (g : N), Function.Injective fun f => F f g
⊢ neLocus (zipWith F F0 f₁ g) (zipWith F F0 f₂ g) = neLocus f₁ f₂

tactic: simpa only [mem_neLocus] using (hF _).ne_iff
state_before: case a
α : Type u_4
M : Type u_1
N : Type u_3
P : Type u_2
inst✝⁵ : DecidableEq α
inst✝⁴ : DecidableEq M
inst✝³ : Zero M
inst✝² : DecidableEq P
inst✝¹ : Zero P
inst✝ : Zero N
F : M → N → P
F0 : F 0 0 = 0
f₁ f₂ : α →₀ M
g : α →₀ N
hF : ∀ (g : N), Function.Injective fun f => F f g
a✝ : α
⊢ a✝ ∈ neLocus (zipWith F F0 f₁ g) (zipWith F F0 f₂ g) ↔ a✝ ∈ neLocus f₁ f₂
Theorem: FiberPrebundle.continuous_proj
File: Mathlib/Topology/FiberBundle/Basic.lean

tactic: letI := a.totalSpaceTopology
state_before: ι : Type ?u.65338
B : Type u_1
F : Type u_3
X : Type ?u.65347
inst✝³ : TopologicalSpace X
E : B → Type u_2
inst✝² : TopologicalSpace B
inst✝¹ : TopologicalSpace F
inst✝ : (x : B) → TopologicalSpace (E x)
a : FiberPrebundle F E
e : Pretrivialization F TotalSpace.proj
⊢ Continuous TotalSpace.proj

tactic: letI := a.toFiberBundle
state_before: ι : Type ?u.65338
B : Type u_1
F : Type u_3
X : Type ?u.65347
inst✝³ : TopologicalSpace X
E : B → Type u_2
inst✝² : TopologicalSpace B
inst✝¹ : TopologicalSpace F
inst✝ : (x : B) → TopologicalSpace (E x)
a : FiberPrebundle F E
e : Pretrivialization F TotalSpace.proj
this : TopologicalSpace (TotalSpace E) := totalSpaceTopology a
⊢ Continuous TotalSpace.proj

tactic: exact FiberBundle.continuous_proj F E
state_before: ι : Type ?u.65338
B : Type u_1
F : Type u_3
X : Type ?u.65347
inst✝³ : TopologicalSpace X
E : B → Type u_2
inst✝² : TopologicalSpace B
inst✝¹ : TopologicalSpace F
inst✝ : (x : B) → TopologicalSpace (E x)
a : FiberPrebundle F E
e : Pretrivialization F TotalSpace.proj
this✝ : TopologicalSpace (TotalSpace E) := totalSpaceTopology a
this : FiberBundle F E := toFiberBundle a
⊢ Continuous TotalSpace.proj
Theorem: HahnSeries.ofPowerSeries_apply
File: Mathlib/RingTheory/HahnSeries.lean

tactic: simp only [Function.Embedding.coeFn_mk]
state_before: Γ : Type ?u.2177048
R : Type ?u.2177051
inst✝¹ : Semiring R
inst✝ : StrictOrderedSemiring Γ
x : PowerSeries R
⊢ ∀ {a b : ℕ},
    ↑{ toFun := Nat.cast, inj' := (_ : Injective Nat.cast) } a ≤
        ↑{ toFun := Nat.cast, inj' := (_ : Injective Nat.cast) } b ↔
      a ≤ b

tactic: exact Nat.cast_le
state_before: Γ : Type ?u.2177048
R : Type ?u.2177051
inst✝¹ : Semiring R
inst✝ : StrictOrderedSemiring Γ
x : PowerSeries R
⊢ ∀ {a b : ℕ}, ↑a ≤ ↑b ↔ a ≤ b
Theorem: CategoryTheory.Limits.biproduct.mapBiproduct_inv_map_desc
File: Mathlib/CategoryTheory/Limits/Preserves/Shapes/Biproducts.lean

tactic: apply biproduct.hom_ext'
state_before: C : Type u₁
inst✝⁶ : Category C
D : Type u₂
inst✝⁵ : Category D
inst✝⁴ : HasZeroMorphisms C
inst✝³ : HasZeroMorphisms D
F : C ⥤ D
inst✝² : PreservesZeroMorphisms F
J : Type w₁
f : J → C
inst✝¹ : HasBiproduct f
inst✝ : PreservesBiproduct f F
W : C
g : (j : J) → f j ⟶ W
⊢ (mapBiproduct F f).inv ≫ F.map (desc g) = desc fun j => F.map (g j)

tactic: intro j
state_before: case w
C : Type u₁
inst✝⁶ : Category C
D : Type u₂
inst✝⁵ : Category D
inst✝⁴ : HasZeroMorphisms C
inst✝³ : HasZeroMorphisms D
F : C ⥤ D
inst✝² : PreservesZeroMorphisms F
J : Type w₁
f : J → C
inst✝¹ : HasBiproduct f
inst✝ : PreservesBiproduct f F
W : C
g : (j : J) → f j ⟶ W
⊢ ∀ (j : J), ι (F.obj ∘ f) j ≫ (mapBiproduct F f).inv ≫ F.map (desc g) = ι (F.obj ∘ f) j ≫ desc fun j => F.map (g j)

tactic: dsimp [Function.comp]
state_before: case w
C : Type u₁
inst✝⁶ : Category C
D : Type u₂
inst✝⁵ : Category D
inst✝⁴ : HasZeroMorphisms C
inst✝³ : HasZeroMorphisms D
F : C ⥤ D
inst✝² : PreservesZeroMorphisms F
J : Type w₁
f : J → C
inst✝¹ : HasBiproduct f
inst✝ : PreservesBiproduct f F
W : C
g : (j : J) → f j ⟶ W
j : J
⊢ ι (F.obj ∘ f) j ≫ (mapBiproduct F f).inv ≫ F.map (desc g) = ι (F.obj ∘ f) j ≫ desc fun j => F.map (g j)

tactic: haveI : HasBiproduct fun j => F.obj (f j) := hasBiproduct_of_preserves F f
state_before: case w
C : Type u₁
inst✝⁶ : Category C
D : Type u₂
inst✝⁵ : Category D
inst✝⁴ : HasZeroMorphisms C
inst✝³ : HasZeroMorphisms D
F : C ⥤ D
inst✝² : PreservesZeroMorphisms F
J : Type w₁
f : J → C
inst✝¹ : HasBiproduct f
inst✝ : PreservesBiproduct f F
W : C
g : (j : J) → f j ⟶ W
j : J
⊢ ι (fun x => F.obj (f x)) j ≫ (mapBiproduct F f).inv ≫ F.map (desc g) =
    ι (fun x => F.obj (f x)) j ≫ desc fun j => F.map (g j)

tactic: simp only [mapBiproduct_inv, ← Category.assoc, biproduct.ι_desc ,← F.map_comp]
state_before: case w
C : Type u₁
inst✝⁶ : Category C
D : Type u₂
inst✝⁵ : Category D
inst✝⁴ : HasZeroMorphisms C
inst✝³ : HasZeroMorphisms D
F : C ⥤ D
inst✝² : PreservesZeroMorphisms F
J : Type w₁
f : J → C
inst✝¹ : HasBiproduct f
inst✝ : PreservesBiproduct f F
W : C
g : (j : J) → f j ⟶ W
j : J
this : HasBiproduct fun j => F.obj (f j)
⊢ ι (fun x => F.obj (f x)) j ≫ (mapBiproduct F f).inv ≫ F.map (desc g) =
    ι (fun x => F.obj (f x)) j ≫ desc fun j => F.map (g j)
Theorem: HomologicalComplex.eqToHom_comp_d
File: Mathlib/Algebra/Homology/HomologicalComplex.lean

tactic: obtain rfl := c.prev_eq rij rij'
state_before: ι : Type u_1
V : Type u
inst✝¹ : Category V
inst✝ : HasZeroMorphisms V
c : ComplexShape ι
C : HomologicalComplex V c
i i' j : ι
rij : ComplexShape.Rel c i j
rij' : ComplexShape.Rel c i' j
⊢ eqToHom (_ : X C i = X C i') ≫ d C i' j = d C i j

tactic: simp only [eqToHom_refl, id_comp]
state_before: ι : Type u_1
V : Type u
inst✝¹ : Category V
inst✝ : HasZeroMorphisms V
c : ComplexShape ι
C : HomologicalComplex V c
i j : ι
rij rij' : ComplexShape.Rel c i j
⊢ eqToHom (_ : X C i = X C i) ≫ d C i j = d C i j
Theorem: EReal.top_mul_of_pos
File: Mathlib/Data/Real/EReal.lean

tactic: rw [EReal.mul_comm]
state_before: x : EReal
h : 0 < x
⊢ ⊤ * x = ⊤

tactic: exact mul_top_of_pos h
state_before: x : EReal
h : 0 < x
⊢ x * ⊤ = ⊤
Theorem: Finset.map_add_left_Ico
File: Mathlib/Data/Finset/LocallyFinite.lean

tactic: rw [← coe_inj, coe_map, coe_Ico, coe_Ico]
state_before: ι : Type ?u.215992
α : Type u_1
inst✝² : OrderedCancelAddCommMonoid α
inst✝¹ : ExistsAddOfLE α
inst✝ : LocallyFiniteOrder α
a b c : α
⊢ map (addLeftEmbedding c) (Ico a b) = Ico (c + a) (c + b)

tactic: exact Set.image_const_add_Ico _ _ _
state_before: ι : Type ?u.215992
α : Type u_1
inst✝² : OrderedCancelAddCommMonoid α
inst✝¹ : ExistsAddOfLE α
inst✝ : LocallyFiniteOrder α
a b c : α
⊢ ↑(addLeftEmbedding c) '' Set.Ico a b = Set.Ico (c + a) (c + b)
Theorem: Int.dvd_trans
File: Std/Data/Int/DivMod.lean

tactic: rw [Int.mul_assoc]
state_before: a✝ d e : Int
⊢ a✝ * d * e = a✝ * (d * e)
Theorem: CategoryTheory.Groupoid.Free.freeGroupoidFunctor_comp
File: Mathlib/CategoryTheory/Groupoid/FreeGroupoid.lean

tactic: dsimp only [freeGroupoidFunctor]
state_before: V : Type u
inst✝² : Quiver V
V' : Type u'
inst✝¹ : Quiver V'
V'' : Type u''
inst✝ : Quiver V''
φ : V ⥤q V'
φ' : V' ⥤q V''
⊢ freeGroupoidFunctor (φ ⋙q φ') = freeGroupoidFunctor φ ⋙ freeGroupoidFunctor φ'

tactic: symm
state_before: V : Type u
inst✝² : Quiver V
V' : Type u'
inst✝¹ : Quiver V'
V'' : Type u''
inst✝ : Quiver V''
φ : V ⥤q V'
φ' : V' ⥤q V''
⊢ lift (φ ⋙q φ' ⋙q of V'') = lift (φ ⋙q of V') ⋙ lift (φ' ⋙q of V'')

tactic: apply lift_unique
state_before: V : Type u
inst✝² : Quiver V
V' : Type u'
inst✝¹ : Quiver V'
V'' : Type u''
inst✝ : Quiver V''
φ : V ⥤q V'
φ' : V' ⥤q V''
⊢ lift (φ ⋙q of V') ⋙ lift (φ' ⋙q of V'') = lift (φ ⋙q φ' ⋙q of V'')

tactic: rfl
state_before: case hΦ
V : Type u
inst✝² : Quiver V
V' : Type u'
inst✝¹ : Quiver V'
V'' : Type u''
inst✝ : Quiver V''
φ : V ⥤q V'
φ' : V' ⥤q V''
⊢ of V ⋙q (lift (φ ⋙q of V') ⋙ lift (φ' ⋙q of V'')).toPrefunctor = φ ⋙q φ' ⋙q of V''
Theorem: Matrix.reindexLinearEquiv_trans
File: Mathlib/LinearAlgebra/Matrix/Reindex.lean

tactic: ext
state_before: l : Type ?u.20354
m : Type u_1
n : Type u_3
o : Type ?u.20363
l' : Type ?u.20366
m' : Type u_2
n' : Type u_4
o' : Type ?u.20375
m'' : Type u_5
n'' : Type u_6
R : Type u_8
A : Type u_7
inst✝² : Semiring R
inst✝¹ : AddCommMonoid A
inst✝ : Module R A
e₁ : m ≃ m'
e₂ : n ≃ n'
e₁' : m' ≃ m''
e₂' : n' ≃ n''
⊢ LinearEquiv.trans (reindexLinearEquiv R A e₁ e₂) (reindexLinearEquiv R A e₁' e₂') =
    reindexLinearEquiv R A (e₁.trans e₁') (e₂.trans e₂')

tactic: rfl
state_before: case h.a.h
l : Type ?u.20354
m : Type u_1
n : Type u_3
o : Type ?u.20363
l' : Type ?u.20366
m' : Type u_2
n' : Type u_4
o' : Type ?u.20375
m'' : Type u_5
n'' : Type u_6
R : Type u_8
A : Type u_7
inst✝² : Semiring R
inst✝¹ : AddCommMonoid A
inst✝ : Module R A
e₁ : m ≃ m'
e₂ : n ≃ n'
e₁' : m' ≃ m''
e₂' : n' ≃ n''
x✝¹ : Matrix m n A
i✝ : m''
x✝ : n''
⊢ ↑(LinearEquiv.trans (reindexLinearEquiv R A e₁ e₂) (reindexLinearEquiv R A e₁' e₂')) x✝¹ i✝ x✝ =
    ↑(reindexLinearEquiv R A (e₁.trans e₁') (e₂.trans e₂')) x✝¹ i✝ x✝
Theorem: eq_cosets_of_normal
File: Mathlib/GroupTheory/Coset.lean

tactic: simp [mem_leftCoset_iff, mem_rightCoset_iff]
state_before: α : Type u_1
inst✝ : Group α
s : Subgroup α
N : Normal s
g a : α
⊢ a ∈ g *l ↑s ↔ a ∈ ↑s *r g

tactic: rw [N.mem_comm_iff]
state_before: α : Type u_1
inst✝ : Group α
s : Subgroup α
N : Normal s
g a : α
⊢ g⁻¹ * a ∈ s ↔ a * g⁻¹ ∈ s
Theorem: Real.volume_Ici
File: Mathlib/MeasureTheory/Measure/Lebesgue/Basic.lean

tactic: rw [← measure_congr Ioi_ae_eq_Ici]
state_before: ι : Type ?u.247709
inst✝ : Fintype ι
a : ℝ
⊢ ↑↑volume (Ici a) = ⊤

tactic: simp
state_before: ι : Type ?u.247709
inst✝ : Fintype ι
a : ℝ
⊢ ↑↑volume (Ioi a) = ⊤
Theorem: ProbabilityTheory.kernel.set_lintegral_deterministic'
File: Mathlib/Probability/Kernel/Basic.lean

tactic: rw [kernel.deterministic_apply, set_lintegral_dirac' hf hs]
state_before: α : Type u_1
β : Type u_2
ι : Type ?u.398685
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ : { x // x ∈ kernel α β }
f : β → ℝ≥0∞
g : α → β
a : α
hg : Measurable g
hf : Measurable f
s : Set β
hs : MeasurableSet s
inst✝ : Decidable (g a ∈ s)
⊢ (∫⁻ (x : β) in s, f x ∂↑(deterministic g hg) a) = if g a ∈ s then f (g a) else 0
Theorem: Nat.lxor'_zero
File: Mathlib/Data/Nat/Bitwise.lean

tactic: simp [lxor']
state_before: n : ℕ
⊢ lxor' n 0 = n
Theorem: Vector.mem_of_mem_tail
File: Mathlib/Data/Vector/Mem.lean

tactic: induction' n with n _
state_before: α : Type u_1
β : Type ?u.2767
n : ℕ
a a' : α
v : Vector α n
ha : a ∈ toList (tail v)
⊢ a ∈ toList v

tactic: exact False.elim (Vector.not_mem_zero a v.tail ha)
state_before: case zero
α : Type u_1
β : Type ?u.2767
n : ℕ
a a' : α
v✝ : Vector α n
ha✝ : a ∈ toList (tail v✝)
v : Vector α Nat.zero
ha : a ∈ toList (tail v)
⊢ a ∈ toList v

tactic: exact (mem_succ_iff a v).2 (Or.inr ha)
state_before: case succ
α : Type u_1
β : Type ?u.2767
n✝ : ℕ
a a' : α
v✝ : Vector α n✝
ha✝ : a ∈ toList (tail v✝)
n : ℕ
n_ih✝ : ∀ (v : Vector α n), a ∈ toList (tail v) → a ∈ toList v
v : Vector α (Nat.succ n)
ha : a ∈ toList (tail v)
⊢ a ∈ toList v
Theorem: Cardinal.eq_of_add_eq_of_aleph0_le
File: Mathlib/SetTheory/Cardinal/Ordinal.lean

tactic: apply le_antisymm
state_before: a b c : Cardinal
h : a + b = c
ha : a < c
hc : ℵ₀ ≤ c
⊢ b = c

tactic: rw [← not_lt]
state_before: case a
a b c : Cardinal
h : a + b = c
ha : a < c
hc : ℵ₀ ≤ c
⊢ c ≤ b

tactic: intro hb
state_before: case a
a b c : Cardinal
h : a + b = c
ha : a < c
hc : ℵ₀ ≤ c
⊢ ¬b < c

tactic: have : a + b < c := add_lt_of_lt hc ha hb
state_before: case a
a b c : Cardinal
h : a + b = c
ha : a < c
hc : ℵ₀ ≤ c
hb : b < c
⊢ False

tactic: simp [h, lt_irrefl] at this
state_before: case a
a b c : Cardinal
h : a + b = c
ha : a < c
hc : ℵ₀ ≤ c
hb : b < c
this : a + b < c
⊢ False

tactic: rw [← h]
state_before: case a
a b c : Cardinal
h : a + b = c
ha : a < c
hc : ℵ₀ ≤ c
⊢ b ≤ c

tactic: apply self_le_add_left
state_before: case a
a b c : Cardinal
h : a + b = c
ha : a < c
hc : ℵ₀ ≤ c
⊢ b ≤ a + b
Theorem: ciSup_mono
File: Mathlib/Order/ConditionallyCompleteLattice/Basic.lean

tactic: cases isEmpty_or_nonempty ι
state_before: α : Type u_1
β : Type ?u.55772
γ : Type ?u.55775
ι : Sort u_2
inst✝ : ConditionallyCompleteLattice α
s t : Set α
a b : α
f g : ι → α
B : BddAbove (range g)
H : ∀ (x : ι), f x ≤ g x
⊢ iSup f ≤ iSup g

tactic: rw [iSup_of_empty', iSup_of_empty']
state_before: case inl
α : Type u_1
β : Type ?u.55772
γ : Type ?u.55775
ι : Sort u_2
inst✝ : ConditionallyCompleteLattice α
s t : Set α
a b : α
f g : ι → α
B : BddAbove (range g)
H : ∀ (x : ι), f x ≤ g x
h✝ : IsEmpty ι
⊢ iSup f ≤ iSup g

tactic: exact ciSup_le fun x => le_ciSup_of_le B x (H x)
state_before: case inr
α : Type u_1
β : Type ?u.55772
γ : Type ?u.55775
ι : Sort u_2
inst✝ : ConditionallyCompleteLattice α
s t : Set α
a b : α
f g : ι → α
B : BddAbove (range g)
H : ∀ (x : ι), f x ≤ g x
h✝ : Nonempty ι
⊢ iSup f ≤ iSup g
Theorem: Submodule.sup_eq_range
File: Mathlib/LinearAlgebra/Prod.lean

tactic: simp [Submodule.mem_sup, SetLike.exists]
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.269908
M₆ : Type ?u.269911
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : AddCommMonoid M₂
inst✝¹ : Module R M
inst✝ : Module R M₂
p q : Submodule R M
x : M
⊢ x ∈ p ⊔ q ↔ x ∈ range (coprod (Submodule.subtype p) (Submodule.subtype q))
Theorem: isPrimePow_iff_pow_succ
File: Mathlib/Algebra/IsPrimePow.lean

tactic: rwa [Nat.sub_add_cancel hk]
state_before: R : Type u_1
inst✝ : CommMonoidWithZero R
n p✝ : R
k✝ : ℕ
x✝ : ∃ p k, Prime p ∧ 0 < k ∧ p ^ k = n
p : R
k : ℕ
hp : Prime p
hk : 0 < k
hn : p ^ k = n
⊢ p ^ (?m.56323 x✝ p k hp hk hn + 1) = n
Theorem: BoxIntegral.Prepartition.iUnion_single
File: Mathlib/Analysis/BoxIntegral/Partition/Basic.lean

tactic: simp [iUnion_def]
state_before: ι : Type u_1
I J J₁ J₂ : Box ι
π π₁ π₂ : Prepartition I
x : ι → ℝ
h : J ≤ I
⊢ Prepartition.iUnion (single I J h) = ↑J
Theorem: closedBall_pi
File: Mathlib/Topology/MetricSpace/Basic.lean

tactic: ext p
state_before: α : Type u
β : Type v
X : Type ?u.403409
ι : Type ?u.403412
inst✝² : PseudoMetricSpace α
π : β → Type u_1
inst✝¹ : Fintype β
inst✝ : (b : β) → PseudoMetricSpace (π b)
x : (b : β) → π b
r : ℝ
hr : 0 ≤ r
⊢ closedBall x r = Set.pi Set.univ fun b => closedBall (x b) r

tactic: simp [dist_pi_le_iff hr]
state_before: case h
α : Type u
β : Type v
X : Type ?u.403409
ι : Type ?u.403412
inst✝² : PseudoMetricSpace α
π : β → Type u_1
inst✝¹ : Fintype β
inst✝ : (b : β) → PseudoMetricSpace (π b)
x : (b : β) → π b
r : ℝ
hr : 0 ≤ r
p : (b : β) → π b
⊢ p ∈ closedBall x r ↔ p ∈ Set.pi Set.univ fun b => closedBall (x b) r
Theorem: Zsqrtd.le_total
File: Mathlib/NumberTheory/Zsqrtd/Basic.lean

tactic: have t := (b - a).nonneg_total
state_before: d : ℕ
a b : ℤ√↑d
⊢ a ≤ b ∨ b ≤ a

tactic: rwa [neg_sub] at t
state_before: d : ℕ
a b : ℤ√↑d
t : Nonneg (b - a) ∨ Nonneg (-(b - a))
⊢ a ≤ b ∨ b ≤ a