tasksource/leandojo huggingface dataset:
Theorem: CategoryTheory.Limits.IsZero.iff_isSplitMono_eq_zero
File: Mathlib/CategoryTheory/Limits/Shapes/ZeroMorphisms.lean

tactic: rw [iff_id_eq_zero]
state_before: C : Type u
inst✝³ : Category C
D : Type u'
inst✝² : Category D
inst✝¹ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
inst✝ : IsSplitMono f
⊢ IsZero X ↔ f = 0

tactic: constructor
state_before: C : Type u
inst✝³ : Category C
D : Type u'
inst✝² : Category D
inst✝¹ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
inst✝ : IsSplitMono f
⊢ 𝟙 X = 0 ↔ f = 0

tactic: intro h
state_before: case mp
C : Type u
inst✝³ : Category C
D : Type u'
inst✝² : Category D
inst✝¹ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
inst✝ : IsSplitMono f
⊢ 𝟙 X = 0 → f = 0

tactic: rw [← Category.id_comp f, h, zero_comp]
state_before: case mp
C : Type u
inst✝³ : Category C
D : Type u'
inst✝² : Category D
inst✝¹ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
inst✝ : IsSplitMono f
h : 𝟙 X = 0
⊢ f = 0

tactic: intro h
state_before: case mpr
C : Type u
inst✝³ : Category C
D : Type u'
inst✝² : Category D
inst✝¹ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
inst✝ : IsSplitMono f
⊢ f = 0 → 𝟙 X = 0

tactic: rw [← IsSplitMono.id f]
state_before: case mpr
C : Type u
inst✝³ : Category C
D : Type u'
inst✝² : Category D
inst✝¹ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
inst✝ : IsSplitMono f
h : f = 0
⊢ 𝟙 X = 0

tactic: simp [h]
state_before: case mpr
C : Type u
inst✝³ : Category C
D : Type u'
inst✝² : Category D
inst✝¹ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
inst✝ : IsSplitMono f
h : f = 0
⊢ f ≫ retraction f = 0
Theorem: Denumerable.lower_raise
File: Mathlib/Logic/Equiv/List.lean

tactic: rw [raise, lower, add_tsub_cancel_right, lower_raise l]
state_before: α : Type ?u.44179
β : Type ?u.44182
inst✝¹ : Denumerable α
inst✝ : Denumerable β
m : ℕ
l : List ℕ
n : ℕ
⊢ lower (raise (m :: l) n) n = m :: l
Theorem: Finset.image₂_union_left
File: Mathlib/Data/Finset/NAry.lean

tactic: push_cast
state_before: α : Type u_1
α' : Type ?u.34144
β : Type u_3
β' : Type ?u.34150
γ : Type u_2
γ' : Type ?u.34156
δ : Type ?u.34159
δ' : Type ?u.34162
ε : Type ?u.34165
ε' : Type ?u.34168
ζ : Type ?u.34171
ζ' : Type ?u.34174
ν : Type ?u.34177
inst✝⁸ : DecidableEq α'
inst✝⁷ : DecidableEq β'
inst✝⁶ : DecidableEq γ
inst✝⁵ : DecidableEq γ'
inst✝⁴ : DecidableEq δ
inst✝³ : DecidableEq δ'
inst✝² : DecidableEq ε
inst✝¹ : DecidableEq ε'
f f' : α → β → γ
g g' : α → β → γ → δ
s s' : Finset α
t t' : Finset β
u u' : Finset γ
a a' : α
b b' : β
c : γ
inst✝ : DecidableEq α
⊢ ↑(image₂ f (s ∪ s') t) = ↑(image₂ f s t ∪ image₂ f s' t)

tactic: exact image2_union_left
state_before: α : Type u_1
α' : Type ?u.34144
β : Type u_3
β' : Type ?u.34150
γ : Type u_2
γ' : Type ?u.34156
δ : Type ?u.34159
δ' : Type ?u.34162
ε : Type ?u.34165
ε' : Type ?u.34168
ζ : Type ?u.34171
ζ' : Type ?u.34174
ν : Type ?u.34177
inst✝⁸ : DecidableEq α'
inst✝⁷ : DecidableEq β'
inst✝⁶ : DecidableEq γ
inst✝⁵ : DecidableEq γ'
inst✝⁴ : DecidableEq δ
inst✝³ : DecidableEq δ'
inst✝² : DecidableEq ε
inst✝¹ : DecidableEq ε'
f f' : α → β → γ
g g' : α → β → γ → δ
s s' : Finset α
t t' : Finset β
u u' : Finset γ
a a' : α
b b' : β
c : γ
inst✝ : DecidableEq α
⊢ image2 f (↑s ∪ ↑s') ↑t = image2 f ↑s ↑t ∪ image2 f ↑s' ↑t
Theorem: Complex.abs_cpow_real
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

tactic: rcases eq_or_ne x 0 with (rfl | hx) <;> [rcases eq_or_ne y 0 with (rfl | hy); skip] <;>
  simp [*, abs_cpow_of_ne_zero]
state_before: x : ℂ
y : ℝ
⊢ ↑abs (x ^ ↑y) = ↑abs x ^ y
Theorem: ContinuousLinearMap.isBoundedBilinearMap
File: Mathlib/Analysis/NormedSpace/BoundedLinearMaps.lean

tactic: apply_rules [mul_le_mul_of_nonneg_right, norm_nonneg, le_max_left]
state_before: 𝕜 : Type u_1
inst✝⁶ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
F : Type u_4
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
G : Type u_3
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
f✝ : E × F → G
f : E →L[𝕜] F →L[𝕜] G
x : E
y : F
⊢ ‖f‖ * ‖x‖ * ‖y‖ ≤ max ‖f‖ 1 * ‖x‖ * ‖y‖
Theorem: MeasureTheory.Measure.prod_apply_symm
File: Mathlib/MeasureTheory/Constructions/Prod/Basic.lean

tactic: rw [← prod_swap, map_apply measurable_swap hs, prod_apply (measurable_swap hs)]
state_before: α : Type u_2
α' : Type ?u.4457703
β : Type u_1
β' : Type ?u.4457709
γ : Type ?u.4457712
E : Type ?u.4457715
inst✝⁷ : MeasurableSpace α
inst✝⁶ : MeasurableSpace α'
inst✝⁵ : MeasurableSpace β
inst✝⁴ : MeasurableSpace β'
inst✝³ : MeasurableSpace γ
μ μ' : Measure α
ν ν' : Measure β
τ : Measure γ
inst✝² : NormedAddCommGroup E
inst✝¹ : SigmaFinite ν
inst✝ : SigmaFinite μ
s : Set (α × β)
hs : MeasurableSet s
⊢ ↑↑(Measure.prod μ ν) s = ∫⁻ (y : β), ↑↑μ ((fun x => (x, y)) ⁻¹' s) ∂ν

tactic: rfl
state_before: α : Type u_2
α' : Type ?u.4457703
β : Type u_1
β' : Type ?u.4457709
γ : Type ?u.4457712
E : Type ?u.4457715
inst✝⁷ : MeasurableSpace α
inst✝⁶ : MeasurableSpace α'
inst✝⁵ : MeasurableSpace β
inst✝⁴ : MeasurableSpace β'
inst✝³ : MeasurableSpace γ
μ μ' : Measure α
ν ν' : Measure β
τ : Measure γ
inst✝² : NormedAddCommGroup E
inst✝¹ : SigmaFinite ν
inst✝ : SigmaFinite μ
s : Set (α × β)
hs : MeasurableSet s
⊢ (∫⁻ (x : β), ↑↑μ (Prod.mk x ⁻¹' (Prod.swap ⁻¹' s)) ∂ν) = ∫⁻ (y : β), ↑↑μ ((fun x => (x, y)) ⁻¹' s) ∂ν
Theorem: ZNum.mul_to_int
File: Mathlib/Data/Num/Lemmas.lean

tactic: cases a <;> exact (MulZeroClass.zero_mul _).symm
state_before: α : Type ?u.929509
a : ZNum
⊢ ↑(0 * a) = ↑0 * ↑a

tactic: cases b <;> exact (MulZeroClass.mul_zero _).symm
state_before: α : Type ?u.929509
b : ZNum
⊢ ↑(b * 0) = ↑b * ↑0

tactic: rw [PosNum.cast_mul, neg_mul_eq_mul_neg]
state_before: α : Type ?u.929509
a b : PosNum
⊢ -↑(a * b) = ↑a * -↑b

tactic: rw [PosNum.cast_mul, neg_mul_eq_neg_mul]
state_before: α : Type ?u.929509
a b : PosNum
⊢ -↑(a * b) = -↑a * ↑b

tactic: rw [PosNum.cast_mul, neg_mul_neg]
state_before: α : Type ?u.929509
a b : PosNum
⊢ ↑(a * b) = -↑a * -↑b
Theorem: CategoryTheory.rightDistributor_inv
File: Mathlib/CategoryTheory/Monoidal/Preadditive.lean

tactic: ext
state_before: C : Type u_2
inst✝⁵ : Category C
inst✝⁴ : Preadditive C
inst✝³ : MonoidalCategory C
inst✝² : MonoidalPreadditive C
inst✝¹ : HasFiniteBiproducts C
J : Type
inst✝ : Fintype J
X : C
f : J → C
⊢ (rightDistributor X f).inv = ∑ j : J, biproduct.π (fun j => f j ⊗ X) j ≫ (biproduct.ι f j ⊗ 𝟙 X)

tactic: dsimp [rightDistributor, Functor.mapBiproduct, Functor.mapBicone]
state_before: case w
C : Type u_2
inst✝⁵ : Category C
inst✝⁴ : Preadditive C
inst✝³ : MonoidalCategory C
inst✝² : MonoidalPreadditive C
inst✝¹ : HasFiniteBiproducts C
J : Type
inst✝ : Fintype J
X : C
f : J → C
j✝ : J
⊢ biproduct.ι (fun j => f j ⊗ X) j✝ ≫ (rightDistributor X f).inv =
    biproduct.ι (fun j => f j ⊗ X) j✝ ≫ ∑ j : J, biproduct.π (fun j => f j ⊗ X) j ≫ (biproduct.ι f j ⊗ 𝟙 X)

tactic: simp only [biproduct.ι_desc, Preadditive.comp_sum, ne_eq, biproduct.ι_π_assoc, dite_comp,
  zero_comp, Finset.sum_dite_eq, Finset.mem_univ, eqToHom_refl, Category.id_comp, ite_true]
state_before: case w
C : Type u_2
inst✝⁵ : Category C
inst✝⁴ : Preadditive C
inst✝³ : MonoidalCategory C
inst✝² : MonoidalPreadditive C
inst✝¹ : HasFiniteBiproducts C
J : Type
inst✝ : Fintype J
X : C
f : J → C
j✝ : J
⊢ (biproduct.ι (fun j => f j ⊗ X) j✝ ≫ biproduct.desc fun j => biproduct.ι f j ⊗ 𝟙 X) =
    biproduct.ι (fun j => f j ⊗ X) j✝ ≫ ∑ j : J, biproduct.π (fun j => f j ⊗ X) j ≫ (biproduct.ι f j ⊗ 𝟙 X)
Theorem: finSuccEquiv'_above
File: Mathlib/Logic/Equiv/Fin.lean

tactic: rw [← Fin.succAbove_above _ _ h, finSuccEquiv'_succAbove]
state_before: m✝ n : ℕ
i : Fin (n + 1)
m : Fin n
h : i ≤ ↑Fin.castSucc m
⊢ ↑(finSuccEquiv' i) (Fin.succ m) = some m
Theorem: IsBoundedBilinearMap.isBigO
File: Mathlib/Analysis/NormedSpace/BoundedLinearMaps.lean

tactic: simpa [mul_assoc] using hC x y
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_4
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
f : E × F → G
h : IsBoundedBilinearMap 𝕜 f
C : ℝ
Cpos : C > 0
hC : ∀ (x : E) (y : F), ‖f (x, y)‖ ≤ C * ‖x‖ * ‖y‖
x✝ : E × F
x : E
y : F
⊢ ‖f (x, y)‖ ≤ ?m.295592 h C Cpos hC * ‖‖(x, y).fst‖ * ‖(x, y).snd‖‖
Theorem: CategoryTheory.balanced_opposite
File: Mathlib/CategoryTheory/Balanced.lean

tactic: rw [← Quiver.Hom.op_unop f]
state_before: C : Type u
inst✝¹ : Category C
inst✝ : Balanced C
X✝ Y✝ : Cᵒᵖ
f : X✝ ⟶ Y✝
fmono : Mono f
fepi : Epi f
⊢ IsIso f

tactic: exact isIso_of_op _
state_before: C : Type u
inst✝¹ : Category C
inst✝ : Balanced C
X✝ Y✝ : Cᵒᵖ
f : X✝ ⟶ Y✝
fmono : Mono f
fepi : Epi f
⊢ IsIso f.unop.op
Theorem: SeparationQuotient.map_mk_nhds
File: Mathlib/Topology/Inseparable.lean

tactic: rw [← comap_mk_nhds_mk, map_comap_of_surjective surjective_mk]
state_before: X : Type u_1
Y : Type ?u.60142
Z : Type ?u.60145
α : Type ?u.60148
ι : Type ?u.60151
π : ι → Type ?u.60156
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : TopologicalSpace Z
inst✝ : (i : ι) → TopologicalSpace (π i)
x y z : X
s : Set X
f : X → Y
t : Set (SeparationQuotient X)
⊢ Filter.map mk (𝓝 x) = 𝓝 (mk x)
Theorem: Finset.card_Ioo_eq_card_Icc_sub_two
File: Mathlib/Data/Finset/LocallyFinite.lean

tactic: rw [card_Ioo_eq_card_Ico_sub_one, card_Ico_eq_card_Icc_sub_one]
state_before: ι : Type ?u.112982
α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : LocallyFiniteOrder α
a✝ b✝ c a b : α
⊢ card (Ioo a b) = card (Icc a b) - 2

tactic: rfl
state_before: ι : Type ?u.112982
α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : LocallyFiniteOrder α
a✝ b✝ c a b : α
⊢ card (Icc a b) - 1 - 1 = card (Icc a b) - 2
Theorem: cycleType_finRotate_of_le
File: Mathlib/GroupTheory/Perm/Fin.lean

tactic: obtain ⟨m, rfl⟩ := exists_add_of_le h
state_before: n : ℕ
h : 2 ≤ n
⊢ cycleType (finRotate n) = {n}

tactic: rw [add_comm, cycleType_finRotate]
state_before: case intro
m : ℕ
h : 2 ≤ 2 + m
⊢ cycleType (finRotate (2 + m)) = {2 + m}
Theorem: String.extract.go₁_cons_addChar
File: Std/Data/String/Lemmas.lean

tactic: simp [go₁, Pos.ext_iff, Nat.ne_of_lt add_csize_pos]
state_before: c : Char
cs : List Char
b e : Pos
⊢ go₁ (c :: cs) 0 (b + c) (e + c) = go₁ cs 0 b e

tactic: apply go₁_add_right_cancel
state_before: c : Char
cs : List Char
b e : Pos
⊢ go₁ cs (0 + c) (b + c) (e + c) = go₁ cs 0 b e
Theorem: Nat.sum_range_choose_halfway
File: Mathlib/Data/Nat/Choose/Sum.lean

tactic: linarith [mem_range.1 hi]
state_before: R : Type ?u.146799
m i : ℕ
hi : i ∈ range (m + 1)
⊢ i ≤ 2 * m + 1

tactic: rw [two_mul, this]
state_before: R : Type ?u.146799
m : ℕ
this : ∑ i in range (m + 1), choose (2 * m + 1) (2 * m + 1 - i) = ∑ i in range (m + 1), choose (2 * m + 1) i
⊢ 2 * ∑ i in range (m + 1), choose (2 * m + 1) i =
    ∑ i in range (m + 1), choose (2 * m + 1) i + ∑ i in range (m + 1), choose (2 * m + 1) (2 * m + 1 - i)

tactic: congr
state_before: R : Type ?u.146799
m : ℕ
this : ∑ i in range (m + 1), choose (2 * m + 1) (2 * m + 1 - i) = ∑ i in range (m + 1), choose (2 * m + 1) i
⊢ ∑ i in Ico 0 (m + 1), choose (2 * m + 1) i +
      ∑ j in Ico (2 * m + 1 + 1 - (m + 1)) (2 * m + 1 + 1 - 0), choose (2 * m + 1) j =
    ∑ i in Ico 0 (m + 1), choose (2 * m + 1) i + ∑ i in Ico (m + 1) (2 * m + 2), choose (2 * m + 1) i

tactic: have A : m + 1 ≤ 2 * m + 1 := by linarith
state_before: case e_a.e_s.e_a
R : Type ?u.146799
m : ℕ
this : ∑ i in range (m + 1), choose (2 * m + 1) (2 * m + 1 - i) = ∑ i in range (m + 1), choose (2 * m + 1) i
⊢ 2 * m + 1 + 1 - (m + 1) = m + 1

tactic: rw [add_comm, add_tsub_assoc_of_le A, ← add_comm]
state_before: case e_a.e_s.e_a
R : Type ?u.146799
m : ℕ
this : ∑ i in range (m + 1), choose (2 * m + 1) (2 * m + 1 - i) = ∑ i in range (m + 1), choose (2 * m + 1) i
A : m + 1 ≤ 2 * m + 1
⊢ 2 * m + 1 + 1 - (m + 1) = m + 1

tactic: congr
state_before: case e_a.e_s.e_a
R : Type ?u.146799
m : ℕ
this : ∑ i in range (m + 1), choose (2 * m + 1) (2 * m + 1 - i) = ∑ i in range (m + 1), choose (2 * m + 1) i
A : m + 1 ≤ 2 * m + 1
⊢ 2 * m + 1 - (m + 1) + 1 = m + 1

tactic: rw [tsub_eq_iff_eq_add_of_le A]
state_before: case e_a.e_s.e_a.e_a
R : Type ?u.146799
m : ℕ
this : ∑ i in range (m + 1), choose (2 * m + 1) (2 * m + 1 - i) = ∑ i in range (m + 1), choose (2 * m + 1) i
A : m + 1 ≤ 2 * m + 1
⊢ 2 * m + 1 - (m + 1) = m

tactic: ring
state_before: case e_a.e_s.e_a.e_a
R : Type ?u.146799
m : ℕ
this : ∑ i in range (m + 1), choose (2 * m + 1) (2 * m + 1 - i) = ∑ i in range (m + 1), choose (2 * m + 1) i
A : m + 1 ≤ 2 * m + 1
⊢ 2 * m + 1 = m + (m + 1)

tactic: linarith
state_before: R : Type ?u.146799
m : ℕ
this : ∑ i in range (m + 1), choose (2 * m + 1) (2 * m + 1 - i) = ∑ i in range (m + 1), choose (2 * m + 1) i
⊢ m + 1 ≤ 2 * m + 1

tactic: linarith
state_before: case h
R : Type ?u.146799
m : ℕ
this : ∑ i in range (m + 1), choose (2 * m + 1) (2 * m + 1 - i) = ∑ i in range (m + 1), choose (2 * m + 1) i
⊢ m + 1 ≤ 2 * m + 1 + 1

tactic: linarith
state_before: R : Type ?u.146799
m : ℕ
this : ∑ i in range (m + 1), choose (2 * m + 1) (2 * m + 1 - i) = ∑ i in range (m + 1), choose (2 * m + 1) i
⊢ m + 1 ≤ 2 * m + 2

tactic: rw [pow_succ, pow_mul, mul_comm]
state_before: R : Type ?u.146799
m : ℕ
this : ∑ i in range (m + 1), choose (2 * m + 1) (2 * m + 1 - i) = ∑ i in range (m + 1), choose (2 * m + 1) i
⊢ 2 ^ (2 * m + 1) = 2 * 4 ^ m

tactic: rfl
state_before: R : Type ?u.146799
m : ℕ
this : ∑ i in range (m + 1), choose (2 * m + 1) (2 * m + 1 - i) = ∑ i in range (m + 1), choose (2 * m + 1) i
⊢ 2 * (2 ^ 2) ^ m = 2 * 4 ^ m
Theorem: Fin.card_filter_univ_eq_vector_get_eq_count
File: Mathlib/Data/Fintype/Fin.lean

tactic: induction' v using Vector.inductionOn with n x xs hxs
state_before: α : Type u_1
β : Type ?u.19015
n : ℕ
inst✝ : DecidableEq α
a : α
v : Vector α n
⊢ Finset.card (filter (fun i => a = Vector.get v i) univ) = List.count a (Vector.toList v)

tactic: simp
state_before: case h_nil
α : Type u_1
β : Type ?u.19015
n : ℕ
inst✝ : DecidableEq α
a : α
⊢ Finset.card (filter (fun i => a = Vector.get Vector.nil i) univ) = List.count a (Vector.toList Vector.nil)

tactic: simp_rw [card_filter_univ_succ', Vector.get_cons_zero, Vector.toList_cons, Function.comp,
  Vector.get_cons_succ, hxs, List.count_cons', add_comm (ite (a = x) 1 0)]
state_before: case h_cons
α : Type u_1
β : Type ?u.19015
n✝ : ℕ
inst✝ : DecidableEq α
a : α
n : ℕ
x : α
xs : Vector α n
hxs : Finset.card (filter (fun i => a = Vector.get xs i) univ) = List.count a (Vector.toList xs)
⊢ Finset.card (filter (fun i => a = Vector.get (x ::ᵥ xs) i) univ) = List.count a (Vector.toList (x ::ᵥ xs))
Theorem: MeasureTheory.StronglyMeasurable.measurableSet_mulSupport
File: Mathlib/MeasureTheory/Function/StronglyMeasurable/Basic.lean

tactic: borelize β
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.68690
ι : Type ?u.68693
inst✝³ : Countable ι
f g : α → β
m : MeasurableSpace α
inst✝² : One β
inst✝¹ : TopologicalSpace β
inst✝ : MetrizableSpace β
hf : StronglyMeasurable f
⊢ MeasurableSet (mulSupport f)

tactic: exact measurableSet_mulSupport hf.measurable
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.68690
ι : Type ?u.68693
inst✝³ : Countable ι
f g : α → β
m : MeasurableSpace α
inst✝² : One β
inst✝¹ : TopologicalSpace β
inst✝ : MetrizableSpace β
hf : StronglyMeasurable f
this✝¹ : MeasurableSpace β := borel β
this✝ : BorelSpace β
⊢ MeasurableSet (mulSupport f)
Theorem: one_lt_bit1
File: Mathlib/Algebra/Order/Ring/Defs.lean

tactic: rw [bit1, lt_add_iff_pos_left, bit0, ← two_mul, zero_lt_mul_left (zero_lt_two : 0 < (2 : α))]
state_before: α : Type u
β : Type ?u.137611
inst✝ : LinearOrderedSemiring α
a b c d : α
⊢ 1 < bit1 a ↔ 0 < a
Theorem: Commute.div_div_div_comm
File: Mathlib/Algebra/Group/Commute.lean

tactic: simp_rw [div_eq_mul_inv, mul_inv_rev, inv_inv, hbd.symm.eq, hcd.symm.eq,
  hbc.inv_inv.mul_mul_mul_comm]
state_before: G : Type u_1
inst✝ : DivisionMonoid G
a b c d : G
hbc : Commute b c
hbd : Commute b⁻¹ d
hcd : Commute c⁻¹ d
⊢ a / b / (c / d) = a / c / (b / d)
Theorem: CompositionSeries.Equivalent.snoc
File: Mathlib/Order/JordanHolder.lean

tactic: refine' Fin.lastCases _ _ i
state_before: X : Type u
inst✝¹ : Lattice X
inst✝ : JordanHolderLattice X
s₁ s₂ : CompositionSeries X
x₁ x₂ : X
hsat₁ : IsMaximal (top s₁) x₁
hsat₂ : IsMaximal (top s₂) x₂
hequiv : Equivalent s₁ s₂
htop : Iso (top s₁, x₁) (top s₂, x₂)
e : Fin (Nat.succ s₁.length) ≃ Fin (Nat.succ s₂.length) :=
  Trans.trans (Trans.trans finSuccEquivLast (Functor.mapEquiv Option (Exists.choose hequiv))) finSuccEquivLast.symm
i : Fin (snoc s₁ x₁ hsat₁).length
⊢ Iso (series (snoc s₁ x₁ hsat₁) (↑Fin.castSucc i), series (snoc s₁ x₁ hsat₁) (Fin.succ i))
    (series (snoc s₂ x₂ hsat₂) (↑Fin.castSucc (↑e i)), series (snoc s₂ x₂ hsat₂) (Fin.succ (↑e i)))

tactic: simpa [top] using htop
state_before: case refine'_1
X : Type u
inst✝¹ : Lattice X
inst✝ : JordanHolderLattice X
s₁ s₂ : CompositionSeries X
x₁ x₂ : X
hsat₁ : IsMaximal (top s₁) x₁
hsat₂ : IsMaximal (top s₂) x₂
hequiv : Equivalent s₁ s₂
htop : Iso (top s₁, x₁) (top s₂, x₂)
e : Fin (Nat.succ s₁.length) ≃ Fin (Nat.succ s₂.length) :=
  Trans.trans (Trans.trans finSuccEquivLast (Functor.mapEquiv Option (Exists.choose hequiv))) finSuccEquivLast.symm
i : Fin (snoc s₁ x₁ hsat₁).length
⊢ Iso
    (series (snoc s₁ x₁ hsat₁) (↑Fin.castSucc (Fin.last s₁.length)),
      series (snoc s₁ x₁ hsat₁) (Fin.succ (Fin.last s₁.length)))
    (series (snoc s₂ x₂ hsat₂) (↑Fin.castSucc (↑e (Fin.last s₁.length))),
      series (snoc s₂ x₂ hsat₂) (Fin.succ (↑e (Fin.last s₁.length))))

tactic: intro i
state_before: case refine'_2
X : Type u
inst✝¹ : Lattice X
inst✝ : JordanHolderLattice X
s₁ s₂ : CompositionSeries X
x₁ x₂ : X
hsat₁ : IsMaximal (top s₁) x₁
hsat₂ : IsMaximal (top s₂) x₂
hequiv : Equivalent s₁ s₂
htop : Iso (top s₁, x₁) (top s₂, x₂)
e : Fin (Nat.succ s₁.length) ≃ Fin (Nat.succ s₂.length) :=
  Trans.trans (Trans.trans finSuccEquivLast (Functor.mapEquiv Option (Exists.choose hequiv))) finSuccEquivLast.symm
i : Fin (snoc s₁ x₁ hsat₁).length
⊢ ∀ (i : Fin s₁.length),
    Iso
      (series (snoc s₁ x₁ hsat₁) (↑Fin.castSucc (↑Fin.castSucc i)),
        series (snoc s₁ x₁ hsat₁) (Fin.succ (↑Fin.castSucc i)))
      (series (snoc s₂ x₂ hsat₂) (↑Fin.castSucc (↑e (↑Fin.castSucc i))),
        series (snoc s₂ x₂ hsat₂) (Fin.succ (↑e (↑Fin.castSucc i))))

tactic: simpa [Fin.succ_castSucc] using hequiv.choose_spec i
state_before: case refine'_2
X : Type u
inst✝¹ : Lattice X
inst✝ : JordanHolderLattice X
s₁ s₂ : CompositionSeries X
x₁ x₂ : X
hsat₁ : IsMaximal (top s₁) x₁
hsat₂ : IsMaximal (top s₂) x₂
hequiv : Equivalent s₁ s₂
htop : Iso (top s₁, x₁) (top s₂, x₂)
e : Fin (Nat.succ s₁.length) ≃ Fin (Nat.succ s₂.length) :=
  Trans.trans (Trans.trans finSuccEquivLast (Functor.mapEquiv Option (Exists.choose hequiv))) finSuccEquivLast.symm
i✝ : Fin (snoc s₁ x₁ hsat₁).length
i : Fin s₁.length
⊢ Iso
    (series (snoc s₁ x₁ hsat₁) (↑Fin.castSucc (↑Fin.castSucc i)),
      series (snoc s₁ x₁ hsat₁) (Fin.succ (↑Fin.castSucc i)))
    (series (snoc s₂ x₂ hsat₂) (↑Fin.castSucc (↑e (↑Fin.castSucc i))),
      series (snoc s₂ x₂ hsat₂) (Fin.succ (↑e (↑Fin.castSucc i))))
Theorem: MeasureTheory.StronglyMeasurable.measurableSet_le
File: Mathlib/MeasureTheory/Function/StronglyMeasurable/Basic.lean

tactic: borelize (β × β)
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.227504
ι : Type ?u.227507
inst✝⁴ : Countable ι
f✝ g✝ : α → β
m : MeasurableSpace α
inst✝³ : TopologicalSpace β
inst✝² : Preorder β
inst✝¹ : OrderClosedTopology β
inst✝ : PseudoMetrizableSpace β
f g : α → β
hf : StronglyMeasurable f
hg : StronglyMeasurable g
⊢ MeasurableSet {a | f a ≤ g a}

tactic: exact (hf.prod_mk hg).measurable isClosed_le_prod.measurableSet
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.227504
ι : Type ?u.227507
inst✝⁴ : Countable ι
f✝ g✝ : α → β
m : MeasurableSpace α
inst✝³ : TopologicalSpace β
inst✝² : Preorder β
inst✝¹ : OrderClosedTopology β
inst✝ : PseudoMetrizableSpace β
f g : α → β
hf : StronglyMeasurable f
hg : StronglyMeasurable g
this✝¹ : MeasurableSpace (β × β) := borel (β × β)
this✝ : BorelSpace (β × β)
⊢ MeasurableSet {a | f a ≤ g a}
Theorem: PFun.preimage_asSubtype
File: Mathlib/Data/PFun.lean

tactic: ext x
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.51072
δ : Type ?u.51075
ε : Type ?u.51078
ι : Type ?u.51081
f✝ f : α →. β
s : Set β
⊢ asSubtype f ⁻¹' s = Subtype.val ⁻¹' preimage f s

tactic: simp only [Set.mem_preimage, Set.mem_setOf_eq, PFun.asSubtype, PFun.mem_preimage]
state_before: case h
α : Type u_1
β : Type u_2
γ : Type ?u.51072
δ : Type ?u.51075
ε : Type ?u.51078
ι : Type ?u.51081
f✝ f : α →. β
s : Set β
x : ↑(Dom f)
⊢ x ∈ asSubtype f ⁻¹' s ↔ x ∈ Subtype.val ⁻¹' preimage f s

tactic: show f.fn x.val _ ∈ s ↔ ∃ y ∈ s, y ∈ f x.val
state_before: case h
α : Type u_1
β : Type u_2
γ : Type ?u.51072
δ : Type ?u.51075
ε : Type ?u.51078
ι : Type ?u.51081
f✝ f : α →. β
s : Set β
x : ↑(Dom f)
⊢ fn f ↑x (_ : ↑x ∈ Dom f) ∈ s ↔ ∃ y, y ∈ s ∧ y ∈ f ↑x

tactic: exact
  Iff.intro (fun h => ⟨_, h, Part.get_mem _⟩) fun ⟨y, ys, fxy⟩ =>
    have : f.fn x.val x.property ∈ f x.val := Part.get_mem _
    Part.mem_unique fxy this ▸ ys
state_before: case h
α : Type u_1
β : Type u_2
γ : Type ?u.51072
δ : Type ?u.51075
ε : Type ?u.51078
ι : Type ?u.51081
f✝ f : α →. β
s : Set β
x : ↑(Dom f)
⊢ fn f ↑x (_ : ↑x ∈ Dom f) ∈ s ↔ ∃ y, y ∈ s ∧ y ∈ f ↑x
Theorem: Cardinal.lift_ord
File: Mathlib/SetTheory/Ordinal/Basic.lean

tactic: refine' le_antisymm (le_of_forall_lt fun a ha => _) _
state_before: α : Type ?u.229284
β : Type ?u.229287
γ : Type ?u.229290
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
c : Cardinal
⊢ Ordinal.lift (ord c) = ord (lift c)

tactic: rcases Ordinal.lt_lift_iff.1 ha with ⟨a, rfl, _⟩
state_before: case refine'_1
α : Type ?u.229284
β : Type ?u.229287
γ : Type ?u.229290
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
c : Cardinal
a : Ordinal
ha : a < Ordinal.lift (ord c)
⊢ a < ord (lift c)

tactic: rwa [lt_ord, ← lift_card, lift_lt, ← lt_ord, ← Ordinal.lift_lt]
state_before: case refine'_1.intro.intro
α : Type ?u.229284
β : Type ?u.229287
γ : Type ?u.229290
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
c : Cardinal
a : Ordinal
right✝ : a < ord c
ha : Ordinal.lift a < Ordinal.lift (ord c)
⊢ Ordinal.lift a < ord (lift c)

tactic: rw [ord_le, ← lift_card, card_ord]
state_before: case refine'_2
α : Type ?u.229284
β : Type ?u.229287
γ : Type ?u.229290
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
c : Cardinal
⊢ ord (lift c) ≤ Ordinal.lift (ord c)