1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: MeasureTheory.integrable_smul_measure
File: Mathlib/MeasureTheory/Function/L1Space.lean

tactic: simpa only [smul_smul, ENNReal.inv_mul_cancel h₁ h₂, one_smul] using
  h.smul_measure (ENNReal.inv_ne_top.2 h₁)
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → β
c : ℝ≥0∞
h₁ : c ≠ 0
h₂ : c ≠ ⊤
h : Integrable f (c • μ)
⊢ Integrable f μ
state_after: no goals
Theorem: CategoryTheory.ShortComplex.leftHomologyMap'_add
File: Mathlib/Algebra/Homology/ShortComplex/Preadditive.lean

tactic: have γ : LeftHomologyMapData φ h₁ h₂ := default
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Preadditive C
S₁ S₂ S₃ : ShortComplex C
φ φ' : S₁ ⟶ S₂
h₁ : S₁.LeftHomologyData
h₂ : S₂.LeftHomologyData
⊢ leftHomologyMap' (φ + φ') h₁ h₂ = leftHomologyMap' φ h₁ h₂ + leftHomologyMap' φ' h₁ h₂
state_after: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Preadditive C
S₁ S₂ S₃ : ShortComplex C
φ φ' : S₁ ⟶ S₂
h₁ : S₁.LeftHomologyData
h₂ : S₂.LeftHomologyData
γ : LeftHomologyMapData φ h₁ h₂
⊢ leftHomologyMap' (φ + φ') h₁ h₂ = leftHomologyMap' φ h₁ h₂ + leftHomologyMap' φ' h₁ h₂

tactic: have γ' : LeftHomologyMapData φ' h₁ h₂ := default
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Preadditive C
S₁ S₂ S₃ : ShortComplex C
φ φ' : S₁ ⟶ S₂
h₁ : S₁.LeftHomologyData
h₂ : S₂.LeftHomologyData
γ : LeftHomologyMapData φ h₁ h₂
⊢ leftHomologyMap' (φ + φ') h₁ h₂ = leftHomologyMap' φ h₁ h₂ + leftHomologyMap' φ' h₁ h₂
state_after: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Preadditive C
S₁ S₂ S₃ : ShortComplex C
φ φ' : S₁ ⟶ S₂
h₁ : S₁.LeftHomologyData
h₂ : S₂.LeftHomologyData
γ : LeftHomologyMapData φ h₁ h₂
γ' : LeftHomologyMapData φ' h₁ h₂
⊢ leftHomologyMap' (φ + φ') h₁ h₂ = leftHomologyMap' φ h₁ h₂ + leftHomologyMap' φ' h₁ h₂

tactic: simp only [γ.leftHomologyMap'_eq, γ'.leftHomologyMap'_eq,
  (γ.add γ').leftHomologyMap'_eq, LeftHomologyMapData.add_φH]
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Preadditive C
S₁ S₂ S₃ : ShortComplex C
φ φ' : S₁ ⟶ S₂
h₁ : S₁.LeftHomologyData
h₂ : S₂.LeftHomologyData
γ : LeftHomologyMapData φ h₁ h₂
γ' : LeftHomologyMapData φ' h₁ h₂
⊢ leftHomologyMap' (φ + φ') h₁ h₂ = leftHomologyMap' φ h₁ h₂ + leftHomologyMap' φ' h₁ h₂
state_after: no goals
Theorem: Int.alternating_sum_range_choose_of_ne
File: Mathlib/Data/Nat/Choose/Sum.lean

tactic: rw [Int.alternating_sum_range_choose, if_neg h0]
state_before: R : Type u_1
n : ℕ
h0 : n ≠ 0
⊢ ∑ m ∈ range (n + 1), (-1) ^ m * ↑(n.choose m) = 0
state_after: no goals
Theorem: List.zip_swap
File: Mathlib/Data/List/Zip.lean

tactic: rw [zip_nil_right]
state_before: α : Type u
β : Type u_1
γ : Type u_2
δ : Type u_3
ε : Type u_4
l₁ : List α
⊢ map Prod.swap (l₁.zip []) = [].zip l₁
state_after: α : Type u
β : Type u_1
γ : Type u_2
δ : Type u_3
ε : Type u_4
l₁ : List α
⊢ map Prod.swap [] = [].zip l₁

tactic: rfl
state_before: α : Type u
β : Type u_1
γ : Type u_2
δ : Type u_3
ε : Type u_4
l₁ : List α
⊢ map Prod.swap [] = [].zip l₁
state_after: no goals

tactic: simp only [zip_cons_cons, map_cons, zip_swap l₁ l₂, Prod.swap_prod_mk]
state_before: α : Type u
β : Type u_1
γ : Type u_2
δ : Type u_3
ε : Type u_4
a : α
l₁ : List α
b : β
l₂ : List β
⊢ map Prod.swap ((a :: l₁).zip (b :: l₂)) = (b :: l₂).zip (a :: l₁)
state_after: no goals
Theorem: Monoid.Coprod.mrange_lift
File: Mathlib/GroupTheory/Coprod/Basic.lean

tactic: simp [mrange_eq]
state_before: M : Type u_1
N : Type u_2
P : Type u_3
inst✝² : MulOneClass M
inst✝¹ : MulOneClass N
inst✝ : Monoid P
f : M →* P
g : N →* P
⊢ MonoidHom.mrange (lift f g) = MonoidHom.mrange f ⊔ MonoidHom.mrange g
state_after: no goals
Theorem: Nat.bodd_eq_one_and_ne_zero
File: Mathlib/Data/Nat/Bits.lean

tactic: simpa using bodd_eq_one_and_ne_zero n
state_before: m n✝ n : ℕ
⊢ (n + 2).bodd = (1 &&& n + 2 != 0)
state_after: no goals
Theorem: LieAlgebra.isRegular_iff_finrank_engel_eq_rank
File: Mathlib/Algebra/Lie/Rank.lean

tactic: rw [isRegular_iff_natTrailingDegree_charpoly_eq_rank, finrank_engel]
state_before: R : Type u_1
A : Type u_2
L✝ : Type u_3
M : Type u_4
ι : Type u_5
ιₘ : Type u_6
inst✝²¹ : CommRing R
inst✝²⁰ : Nontrivial R
inst✝¹⁹ : CommRing A
inst✝¹⁸ : Algebra R A
inst✝¹⁷ : LieRing L✝
inst✝¹⁶ : LieAlgebra R L✝
inst✝¹⁵ : Module.Finite R L✝
inst✝¹⁴ : Module.Free R L✝
inst✝¹³ : AddCommGroup M
inst✝¹² : Module R M
inst✝¹¹ : LieRingModule L✝ M
inst✝¹⁰ : LieModule R L✝ M
inst✝⁹ : Module.Finite R M
inst✝⁸ : Module.Free R M
inst✝⁷ : Fintype ι
inst✝⁶ : DecidableEq ι
inst✝⁵ : Fintype ιₘ
inst✝⁴ : DecidableEq ιₘ
b : Basis ι R L✝
bₘ : Basis ιₘ R M
x✝ : L✝
K : Type u_7
L : Type u_8
inst✝³ : Field K
inst✝² : LieRing L
inst✝¹ : LieAlgebra K L
inst✝ : Module.Finite K L
x : L
⊢ IsRegular K x ↔ finrank K ↥(engel K x) = rank K L
state_after: no goals
Theorem: Int.ediv_of_neg_of_pos
File: Mathlib/Data/Int/Defs.lean

tactic: rw [show (- -[m+1] : ℤ) = (m + 1 : ℤ) by rfl]
state_before: a✝ b✝ c d m✝ n✝ a b : ℤ
m n : ℕ
Ha : -[m+1] < 0
Hb : 0 < ↑n.succ
⊢ -[m+1].ediv ↑n.succ = -((- -[m+1] - 1) / ↑n.succ + 1)
state_after: a✝ b✝ c d m✝ n✝ a b : ℤ
m n : ℕ
Ha : -[m+1] < 0
Hb : 0 < ↑n.succ
⊢ -[m+1].ediv ↑n.succ = -((↑m + 1 - 1) / ↑n.succ + 1)

tactic: rw [Int.add_sub_cancel]
state_before: a✝ b✝ c d m✝ n✝ a b : ℤ
m n : ℕ
Ha : -[m+1] < 0
Hb : 0 < ↑n.succ
⊢ -[m+1].ediv ↑n.succ = -((↑m + 1 - 1) / ↑n.succ + 1)
state_after: a✝ b✝ c d m✝ n✝ a b : ℤ
m n : ℕ
Ha : -[m+1] < 0
Hb : 0 < ↑n.succ
⊢ -[m+1].ediv ↑n.succ = -(↑m / ↑n.succ + 1)

tactic: rfl
state_before: a✝ b✝ c d m✝ n✝ a b : ℤ
m n : ℕ
Ha : -[m+1] < 0
Hb : 0 < ↑n.succ
⊢ -[m+1].ediv ↑n.succ = -(↑m / ↑n.succ + 1)
state_after: no goals

tactic: rfl
state_before: a✝ b✝ c d m✝ n✝ a b : ℤ
m n : ℕ
Ha : -[m+1] < 0
Hb : 0 < ↑n.succ
⊢ - -[m+1] = ↑m + 1
state_after: no goals
Theorem: Real.rpow_zero
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

tactic: simp [rpow_def]
state_before: x✝ y z x : ℝ
⊢ x ^ 0 = 1
state_after: no goals
Theorem: Polynomial.abs_div_tendsto_atTop_of_degree_gt
File: Mathlib/Analysis/SpecialFunctions/Polynomials.lean

tactic: by_cases h : 0 ≤ P.leadingCoeff / Q.leadingCoeff
state_before: 𝕜 : Type u_1
inst✝¹ : NormedLinearOrderedField 𝕜
P Q : 𝕜[X]
inst✝ : OrderTopology 𝕜
hdeg : Q.degree < P.degree
hQ : Q ≠ 0
⊢ Tendsto (fun x => |eval x P / eval x Q|) atTop atTop
state_after: case pos
𝕜 : Type u_1
inst✝¹ : NormedLinearOrderedField 𝕜
P Q : 𝕜[X]
inst✝ : OrderTopology 𝕜
hdeg : Q.degree < P.degree
hQ : Q ≠ 0
h : 0 ≤ P.leadingCoeff / Q.leadingCoeff
⊢ Tendsto (fun x => |eval x P / eval x Q|) atTop atTop

case neg
𝕜 : Type u_1
inst✝¹ : NormedLinearOrderedField 𝕜
P Q : 𝕜[X]
inst✝ : OrderTopology 𝕜
hdeg : Q.degree < P.degree
hQ : Q ≠ 0
h : ¬0 ≤ P.leadingCoeff / Q.leadingCoeff
⊢ Tendsto (fun x => |eval x P / eval x Q|) atTop atTop

tactic: exact tendsto_abs_atTop_atTop.comp (P.div_tendsto_atTop_of_degree_gt Q hdeg hQ h)
state_before: case pos
𝕜 : Type u_1
inst✝¹ : NormedLinearOrderedField 𝕜
P Q : 𝕜[X]
inst✝ : OrderTopology 𝕜
hdeg : Q.degree < P.degree
hQ : Q ≠ 0
h : 0 ≤ P.leadingCoeff / Q.leadingCoeff
⊢ Tendsto (fun x => |eval x P / eval x Q|) atTop atTop
state_after: no goals

tactic: push_neg at h
state_before: case neg
𝕜 : Type u_1
inst✝¹ : NormedLinearOrderedField 𝕜
P Q : 𝕜[X]
inst✝ : OrderTopology 𝕜
hdeg : Q.degree < P.degree
hQ : Q ≠ 0
h : ¬0 ≤ P.leadingCoeff / Q.leadingCoeff
⊢ Tendsto (fun x => |eval x P / eval x Q|) atTop atTop
state_after: case neg
𝕜 : Type u_1
inst✝¹ : NormedLinearOrderedField 𝕜
P Q : 𝕜[X]
inst✝ : OrderTopology 𝕜
hdeg : Q.degree < P.degree
hQ : Q ≠ 0
h : P.leadingCoeff / Q.leadingCoeff < 0
⊢ Tendsto (fun x => |eval x P / eval x Q|) atTop atTop

tactic: exact tendsto_abs_atBot_atTop.comp (P.div_tendsto_atBot_of_degree_gt Q hdeg hQ h.le)
state_before: case neg
𝕜 : Type u_1
inst✝¹ : NormedLinearOrderedField 𝕜
P Q : 𝕜[X]
inst✝ : OrderTopology 𝕜
hdeg : Q.degree < P.degree
hQ : Q ≠ 0
h : P.leadingCoeff / Q.leadingCoeff < 0
⊢ Tendsto (fun x => |eval x P / eval x Q|) atTop atTop
state_after: no goals
Theorem: smul_one_mul
File: Mathlib/Algebra/Group/Action/Defs.lean

tactic: rw [smul_mul_assoc, one_mul]
state_before: M✝ : Type u_1
N✝ : Type u_2
G : Type u_3
A : Type u_4
B : Type u_5
α : Type u_6
β : Type u_7
γ : Type u_8
δ : Type u_9
M : Type u_10
N : Type u_11
inst✝² : MulOneClass N
inst✝¹ : SMul M N
inst✝ : IsScalarTower M N N
x : M
y : N
⊢ x • 1 * y = x • y
state_after: no goals
Theorem: CategoryTheory.hasCoproduct_fin
File: Mathlib/CategoryTheory/Limits/Constructions/FiniteProductsOfBinaryProducts.lean

tactic: letI : HasColimitsOfShape (Discrete (Fin 0)) C :=
  hasColimitsOfShape_of_equivalence (Discrete.equivalence.{0} finZeroEquiv'.symm)
state_before: J : Type v
inst✝⁴ : SmallCategory J
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasBinaryCoproducts C
inst✝ : HasInitial C
f : Fin 0 → C
⊢ HasCoproduct f
state_after: J : Type v
inst✝⁴ : SmallCategory J
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasBinaryCoproducts C
inst✝ : HasInitial C
f : Fin 0 → C
this : HasColimitsOfShape (Discrete (Fin 0)) C :=
  hasColimitsOfShape_of_equivalence (Discrete.equivalence finZeroEquiv'.symm)
⊢ HasCoproduct f

tactic: infer_instance
state_before: J : Type v
inst✝⁴ : SmallCategory J
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasBinaryCoproducts C
inst✝ : HasInitial C
f : Fin 0 → C
this : HasColimitsOfShape (Discrete (Fin 0)) C :=
  hasColimitsOfShape_of_equivalence (Discrete.equivalence finZeroEquiv'.symm)
⊢ HasCoproduct f
state_after: no goals

tactic: haveI := hasCoproduct_fin n
state_before: J : Type v
inst✝⁴ : SmallCategory J
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasBinaryCoproducts C
inst✝ : HasInitial C
n : ℕ
f : Fin (n + 1) → C
⊢ HasCoproduct f
state_after: J : Type v
inst✝⁴ : SmallCategory J
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasBinaryCoproducts C
inst✝ : HasInitial C
n : ℕ
f : Fin (n + 1) → C
this : ∀ (f : Fin n → C), HasCoproduct f
⊢ HasCoproduct f

tactic: apply
  HasColimit.mk ⟨_, extendCofanIsColimit f (colimit.isColimit _) (colimit.isColimit _)⟩
state_before: J : Type v
inst✝⁴ : SmallCategory J
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasBinaryCoproducts C
inst✝ : HasInitial C
n : ℕ
f : Fin (n + 1) → C
this : ∀ (f : Fin n → C), HasCoproduct f
⊢ HasCoproduct f
state_after: no goals
Theorem: Asymptotics.superpolynomialDecay_iff_superpolynomialDecay_abs
File: Mathlib/Analysis/Asymptotics/SuperpolynomialDecay.lean

tactic: simp_rw [SuperpolynomialDecay, abs_mul, abs_pow]
state_before: α : Type u_1
β : Type u_2
l : Filter α
k f g g' : α → β
inst✝² : TopologicalSpace β
inst✝¹ : LinearOrderedCommRing β
inst✝ : OrderTopology β
⊢ (∀ (n : ℕ), Tendsto (fun a => |k a ^ n * f a|) l (𝓝 0)) ↔ SuperpolynomialDecay l (fun a => |k a|) fun a => |f a|
state_after: no goals
Theorem: Function.Injective.sigma_map
File: Mathlib/Data/Sigma/Basic.lean

tactic: obtain rfl : i = j := h₁ (Sigma.mk.inj_iff.mp h).1
state_before: α : Type u_1
α₁ : Type u_2
α₂ : Type u_3
β : α → Type u_4
β₁ : α₁ → Type u_5
β₂ : α₂ → Type u_6
f₁ : α₁ → α₂
f₂ : (a : α₁) → β₁ a → β₂ (f₁ a)
h₁ : Injective f₁
h₂ : ∀ (a : α₁), Injective (f₂ a)
i : α₁
x : β₁ i
j : α₁
y : β₁ j
h : Sigma.map f₁ f₂ ⟨i, x⟩ = Sigma.map f₁ f₂ ⟨j, y⟩
⊢ ⟨i, x⟩ = ⟨j, y⟩
state_after: α : Type u_1
α₁ : Type u_2
α₂ : Type u_3
β : α → Type u_4
β₁ : α₁ → Type u_5
β₂ : α₂ → Type u_6
f₁ : α₁ → α₂
f₂ : (a : α₁) → β₁ a → β₂ (f₁ a)
h₁ : Injective f₁
h₂ : ∀ (a : α₁), Injective (f₂ a)
i : α₁
x y : β₁ i
h : Sigma.map f₁ f₂ ⟨i, x⟩ = Sigma.map f₁ f₂ ⟨i, y⟩
⊢ ⟨i, x⟩ = ⟨i, y⟩

tactic: obtain rfl : x = y := h₂ i (sigma_mk_injective h)
state_before: α : Type u_1
α₁ : Type u_2
α₂ : Type u_3
β : α → Type u_4
β₁ : α₁ → Type u_5
β₂ : α₂ → Type u_6
f₁ : α₁ → α₂
f₂ : (a : α₁) → β₁ a → β₂ (f₁ a)
h₁ : Injective f₁
h₂ : ∀ (a : α₁), Injective (f₂ a)
i : α₁
x y : β₁ i
h : Sigma.map f₁ f₂ ⟨i, x⟩ = Sigma.map f₁ f₂ ⟨i, y⟩
⊢ ⟨i, x⟩ = ⟨i, y⟩
state_after: α : Type u_1
α₁ : Type u_2
α₂ : Type u_3
β : α → Type u_4
β₁ : α₁ → Type u_5
β₂ : α₂ → Type u_6
f₁ : α₁ → α₂
f₂ : (a : α₁) → β₁ a → β₂ (f₁ a)
h₁ : Injective f₁
h₂ : ∀ (a : α₁), Injective (f₂ a)
i : α₁
x : β₁ i
h : Sigma.map f₁ f₂ ⟨i, x⟩ = Sigma.map f₁ f₂ ⟨i, x⟩
⊢ ⟨i, x⟩ = ⟨i, x⟩

tactic: rfl
state_before: α : Type u_1
α₁ : Type u_2
α₂ : Type u_3
β : α → Type u_4
β₁ : α₁ → Type u_5
β₂ : α₂ → Type u_6
f₁ : α₁ → α₂
f₂ : (a : α₁) → β₁ a → β₂ (f₁ a)
h₁ : Injective f₁
h₂ : ∀ (a : α₁), Injective (f₂ a)
i : α₁
x : β₁ i
h : Sigma.map f₁ f₂ ⟨i, x⟩ = Sigma.map f₁ f₂ ⟨i, x⟩
⊢ ⟨i, x⟩ = ⟨i, x⟩
state_after: no goals
Theorem: Filter.prod_comm
File: Mathlib/Order/Filter/Prod.lean

tactic: rw [prod_comm', ← map_swap_eq_comap_swap]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
s : Set α
t : Set β
f : Filter α
g : Filter β
⊢ f ×ˢ g = map (fun p => (p.2, p.1)) (g ×ˢ f)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
s : Set α
t : Set β
f : Filter α
g : Filter β
⊢ Prod.swap <$> (g ×ˢ f) = map (fun p => (p.2, p.1)) (g ×ˢ f)

tactic: rfl
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
s : Set α
t : Set β
f : Filter α
g : Filter β
⊢ Prod.swap <$> (g ×ˢ f) = map (fun p => (p.2, p.1)) (g ×ˢ f)
state_after: no goals
Theorem: CategoryTheory.Limits.pullbackDiagonalMapIdIso_hom_fst
File: Mathlib/CategoryTheory/Limits/Shapes/Diagonal.lean

tactic: delta pullbackDiagonalMapIdIso
state_before: C : Type u_1
inst✝⁵ : Category.{u_2, u_1} C
X Y Z : C
inst✝⁴ : HasPullbacks C
S T : C
f : X ⟶ T
g : Y ⟶ T
i : T ⟶ S
inst✝³ : HasPullback i i
inst✝² : HasPullback f g
inst✝¹ : HasPullback (f ≫ i) (g ≫ i)
inst✝ : HasPullback (diagonal i) (map (f ≫ i) (g ≫ i) i i f g (𝟙 S) ⋯ ⋯)
⊢ (pullbackDiagonalMapIdIso f g i).hom ≫ fst = snd ≫ fst
state_after: C : Type u_1
inst✝⁵ : Category.{u_2, u_1} C
X Y Z : C
inst✝⁴ : HasPullbacks C
S T : C
f : X ⟶ T
g : Y ⟶ T
i : T ⟶ S
inst✝³ : HasPullback i i
inst✝² : HasPullback f g
inst✝¹ : HasPullback (f ≫ i) (g ≫ i)
inst✝ : HasPullback (diagonal i) (map (f ≫ i) (g ≫ i) i i f g (𝟙 S) ⋯ ⋯)
⊢ (asIso
            (map (diagonal i) (map (f ≫ i) (g ≫ i) i i f g (𝟙 S) ⋯ ⋯) (diagonal i)
              (map ((f ≫ inv fst) ≫ snd) ((g ≫ inv fst) ≫ snd) i i ((f ≫ inv fst) ≫ fst) ((g ≫ inv fst) ≫ fst) (𝟙 S) ⋯
                ⋯)
              (𝟙 T) (congrHom ⋯ ⋯).hom (𝟙 (diagonalObj i)) ⋯ ⋯) ≪≫
          pullbackDiagonalMapIso i (𝟙 S) (f ≫ inv fst) (g ≫ inv fst) ≪≫
            asIso (map (f ≫ inv fst) (g ≫ inv fst) f g (𝟙 X) (𝟙 Y) fst ⋯ ⋯)).hom ≫
      fst =
    snd ≫ fst

tactic: simp
state_before: C : Type u_1
inst✝⁵ : Category.{u_2, u_1} C
X Y Z : C
inst✝⁴ : HasPullbacks C
S T : C
f : X ⟶ T
g : Y ⟶ T
i : T ⟶ S
inst✝³ : HasPullback i i
inst✝² : HasPullback f g
inst✝¹ : HasPullback (f ≫ i) (g ≫ i)
inst✝ : HasPullback (diagonal i) (map (f ≫ i) (g ≫ i) i i f g (𝟙 S) ⋯ ⋯)
⊢ (asIso
            (map (diagonal i) (map (f ≫ i) (g ≫ i) i i f g (𝟙 S) ⋯ ⋯) (diagonal i)
              (map ((f ≫ inv fst) ≫ snd) ((g ≫ inv fst) ≫ snd) i i ((f ≫ inv fst) ≫ fst) ((g ≫ inv fst) ≫ fst) (𝟙 S) ⋯
                ⋯)
              (𝟙 T) (congrHom ⋯ ⋯).hom (𝟙 (diagonalObj i)) ⋯ ⋯) ≪≫
          pullbackDiagonalMapIso i (𝟙 S) (f ≫ inv fst) (g ≫ inv fst) ≪≫
            asIso (map (f ≫ inv fst) (g ≫ inv fst) f g (𝟙 X) (𝟙 Y) fst ⋯ ⋯)).hom ≫
      fst =
    snd ≫ fst
state_after: no goals
Theorem: rank_lt_rank_dual
File: Mathlib/LinearAlgebra/Dimension/DivisionRing.lean

tactic: convert lift_rank_lt_rank_dual h
state_before: K✝ R : Type u
V✝ V₁ V₂ V₃ : Type v
V' V'₁ : Type v'
V'' : Type v''
ι : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type u_1
inst✝³ : DivisionRing K✝
K V : Type u
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
h : ℵ₀ ≤ Module.rank K V
⊢ Module.rank K V < Module.rank K (V →ₗ[K] K)
state_after: case h.e'_3
K✝ R : Type u
V✝ V₁ V₂ V₃ : Type v
V' V'₁ : Type v'
V'' : Type v''
ι : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type u_1
inst✝³ : DivisionRing K✝
K V : Type u
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
h : ℵ₀ ≤ Module.rank K V
⊢ Module.rank K V = lift.{u, u} (Module.rank K V)

tactic: rw [lift_id]
state_before: case h.e'_3
K✝ R : Type u
V✝ V₁ V₂ V₃ : Type v
V' V'₁ : Type v'
V'' : Type v''
ι : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type u_1
inst✝³ : DivisionRing K✝
K V : Type u
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
h : ℵ₀ ≤ Module.rank K V
⊢ Module.rank K V = lift.{u, u} (Module.rank K V)
state_after: no goals
Theorem: exterior_subset_exterior
File: Mathlib/Topology/AlexandrovDiscrete.lean

tactic: refine ⟨?_, fun h ↦ ker_mono h⟩
state_before: ι : Sort u_1
κ : ι → Sort u_2
α : Type u_3
β : Type u_4
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
s t : Set α
a x y : α
inst✝¹ : AlexandrovDiscrete α
inst✝ : AlexandrovDiscrete β
⊢ exterior s ⊆ exterior t ↔ 𝓝ˢ s ≤ 𝓝ˢ t
state_after: ι : Sort u_1
κ : ι → Sort u_2
α : Type u_3
β : Type u_4
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
s t : Set α
a x y : α
inst✝¹ : AlexandrovDiscrete α
inst✝ : AlexandrovDiscrete β
⊢ exterior s ⊆ exterior t → 𝓝ˢ s ≤ 𝓝ˢ t

tactic: simp_rw [le_def, ← exterior_subset_iff_mem_nhdsSet]
state_before: ι : Sort u_1
κ : ι → Sort u_2
α : Type u_3
β : Type u_4
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
s t : Set α
a x y : α
inst✝¹ : AlexandrovDiscrete α
inst✝ : AlexandrovDiscrete β
⊢ exterior s ⊆ exterior t → 𝓝ˢ s ≤ 𝓝ˢ t
state_after: ι : Sort u_1
κ : ι → Sort u_2
α : Type u_3
β : Type u_4
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
s t : Set α
a x y : α
inst✝¹ : AlexandrovDiscrete α
inst✝ : AlexandrovDiscrete β
⊢ exterior s ⊆ exterior t → ∀ (x : Set α), exterior t ⊆ x → exterior s ⊆ x

tactic: exact fun h u ↦ h.trans
state_before: ι : Sort u_1
κ : ι → Sort u_2
α : Type u_3
β : Type u_4
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
s t : Set α
a x y : α
inst✝¹ : AlexandrovDiscrete α
inst✝ : AlexandrovDiscrete β
⊢ exterior s ⊆ exterior t → ∀ (x : Set α), exterior t ⊆ x → exterior s ⊆ x
state_after: no goals
Theorem: CategoryTheory.ShortComplex.LeftHomologyData.leftHomologyIso_inv_naturality
File: Mathlib/Algebra/Homology/ShortComplex/Homology.lean

tactic: dsimp [homologyIso, ShortComplex.leftHomologyIso, homologyMap, homologyMap', leftHomologyIso]
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
S S₁ S₂ S₃ S₄ : ShortComplex C
φ✝ : S₁ ⟶ S₂
h₁✝ : S₁.HomologyData
h₂✝ : S₂.HomologyData
inst✝¹ : S₁.HasHomology
inst✝ : S₂.HasHomology
φ : S₁ ⟶ S₂
h₁ : S₁.LeftHomologyData
h₂ : S₂.LeftHomologyData
⊢ h₁.homologyIso.inv ≫ homologyMap φ = leftHomologyMap' φ h₁ h₂ ≫ h₂.homologyIso.inv
state_after: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
S S₁ S₂ S₃ S₄ : ShortComplex C
φ✝ : S₁ ⟶ S₂
h₁✝ : S₁.HomologyData
h₂✝ : S₂.HomologyData
inst✝¹ : S₁.HasHomology
inst✝ : S₂.HasHomology
φ : S₁ ⟶ S₂
h₁ : S₁.LeftHomologyData
h₂ : S₂.LeftHomologyData
⊢ (leftHomologyMap' (𝟙 S₁) h₁ S₁.leftHomologyData ≫ leftHomologyMap' (𝟙 S₁) S₁.leftHomologyData S₁.homologyData.left) ≫
      leftHomologyMap' φ S₁.homologyData.left S₂.homologyData.left =
    leftHomologyMap' φ h₁ h₂ ≫
      leftHomologyMap' (𝟙 S₂) h₂ S₂.leftHomologyData ≫ leftHomologyMap' (𝟙 S₂) S₂.leftHomologyData S₂.homologyData.left

tactic: simp only [← leftHomologyMap'_comp, id_comp, comp_id]
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
S S₁ S₂ S₃ S₄ : ShortComplex C
φ✝ : S₁ ⟶ S₂
h₁✝ : S₁.HomologyData
h₂✝ : S₂.HomologyData
inst✝¹ : S₁.HasHomology
inst✝ : S₂.HasHomology
φ : S₁ ⟶ S₂
h₁ : S₁.LeftHomologyData
h₂ : S₂.LeftHomologyData
⊢ (leftHomologyMap' (𝟙 S₁) h₁ S₁.leftHomologyData ≫ leftHomologyMap' (𝟙 S₁) S₁.leftHomologyData S₁.homologyData.left) ≫
      leftHomologyMap' φ S₁.homologyData.left S₂.homologyData.left =
    leftHomologyMap' φ h₁ h₂ ≫
      leftHomologyMap' (𝟙 S₂) h₂ S₂.leftHomologyData ≫ leftHomologyMap' (𝟙 S₂) S₂.leftHomologyData S₂.homologyData.left
state_after: no goals
Theorem: Submonoid.mem_closure_pair
File: Mathlib/Algebra/Group/Submonoid/Membership.lean

tactic: rw [← Set.singleton_union, Submonoid.closure_union, mem_sup]
state_before: M : Type u_1
A✝ : Type u_2
B : Type u_3
A : Type u_4
inst✝ : CommMonoid A
a b c : A
⊢ c ∈ closure {a, b} ↔ ∃ m n, a ^ m * b ^ n = c
state_after: M : Type u_1
A✝ : Type u_2
B : Type u_3
A : Type u_4
inst✝ : CommMonoid A
a b c : A
⊢ (∃ y ∈ closure {a}, ∃ z ∈ closure {b}, y * z = c) ↔ ∃ m n, a ^ m * b ^ n = c

tactic: simp_rw [mem_closure_singleton, exists_exists_eq_and]
state_before: M : Type u_1
A✝ : Type u_2
B : Type u_3
A : Type u_4
inst✝ : CommMonoid A
a b c : A
⊢ (∃ y ∈ closure {a}, ∃ z ∈ closure {b}, y * z = c) ↔ ∃ m n, a ^ m * b ^ n = c
state_after: no goals
Theorem: Basis.toDual_toDual
File: Mathlib/LinearAlgebra/Dual.lean

tactic: refine b.ext fun i => b.dualBasis.ext fun j => ?_
state_before: R : Type uR
M : Type uM
K : Type uK
V : Type uV
ι : Type uι
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : DecidableEq ι
b : Basis ι R M
inst✝ : _root_.Finite ι
⊢ b.dualBasis.toDual ∘ₗ b.toDual = Dual.eval R M
state_after: R : Type uR
M : Type uM
K : Type uK
V : Type uV
ι : Type uι
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : DecidableEq ι
b : Basis ι R M
inst✝ : _root_.Finite ι
i j : ι
⊢ ((b.dualBasis.toDual ∘ₗ b.toDual) (b i)) (b.dualBasis j) = ((Dual.eval R M) (b i)) (b.dualBasis j)

tactic: rw [LinearMap.comp_apply, toDual_apply_left, coe_toDual_self, ← coe_dualBasis,
  Dual.eval_apply, Basis.repr_self, Finsupp.single_apply, dualBasis_apply_self]
state_before: R : Type uR
M : Type uM
K : Type uK
V : Type uV
ι : Type uι
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : DecidableEq ι
b : Basis ι R M
inst✝ : _root_.Finite ι
i j : ι
⊢ ((b.dualBasis.toDual ∘ₗ b.toDual) (b i)) (b.dualBasis j) = ((Dual.eval R M) (b i)) (b.dualBasis j)
state_after: no goals
Theorem: Matroid.comapOn_dual_eq_of_bijOn
File: Mathlib/Data/Matroid/Map.lean

tactic: refine eq_of_base_iff_base_forall (by simp) (fun B hB ↦ ?_)
state_before: α : Type u_1
β : Type u_2
f : α → β
E✝ I✝ s : Set α
M : Matroid α
N : Matroid β
E B I : Set α
h : BijOn f E N.E
⊢ (N.comapOn E f)✶ = N✶.comapOn E f
state_after: α : Type u_1
β : Type u_2
f : α → β
E✝ I✝ s : Set α
M : Matroid α
N : Matroid β
E B✝ I : Set α
h : BijOn f E N.E
B : Set α
hB : B ⊆ (N.comapOn E f)✶.E
⊢ (N.comapOn E f)✶.Base B ↔ (N✶.comapOn E f).Base B

tactic: rw [comapOn_base_iff_of_bijOn (by simpa), dual_base_iff, comapOn_base_iff_of_bijOn h,
  dual_base_iff _, comapOn_ground_eq, and_iff_left diff_subset, and_iff_left (by simpa),
  h.injOn.image_diff_subset (by simpa), h.image_eq]
state_before: α : Type u_1
β : Type u_2
f : α → β
E✝ I✝ s : Set α
M : Matroid α
N : Matroid β
E B✝ I : Set α
h : BijOn f E N.E
B : Set α
hB : B ⊆ (N.comapOn E f)✶.E
⊢ (N.comapOn E f)✶.Base B ↔ (N✶.comapOn E f).Base B
state_after: α : Type u_1
β : Type u_2
f : α → β
E✝ I✝ s : Set α
M : Matroid α
N : Matroid β
E B✝ I : Set α
h : BijOn f E N.E
B : Set α
hB : B ⊆ (N.comapOn E f)✶.E
⊢ f '' B ⊆ N.E

tactic: exact (h.mapsTo.mono_left (show B ⊆ E by simpa)).image_subset
state_before: α : Type u_1
β : Type u_2
f : α → β
E✝ I✝ s : Set α
M : Matroid α
N : Matroid β
E B✝ I : Set α
h : BijOn f E N.E
B : Set α
hB : B ⊆ (N.comapOn E f)✶.E
⊢ f '' B ⊆ N.E
state_after: no goals

tactic: simp
state_before: α : Type u_1
β : Type u_2
f : α → β
E✝ I✝ s : Set α
M : Matroid α
N : Matroid β
E B I : Set α
h : BijOn f E N.E
⊢ (N.comapOn E f)✶.E = (N✶.comapOn E f).E
state_after: no goals

tactic: simpa
state_before: α : Type u_1
β : Type u_2
f : α → β
E✝ I✝ s : Set α
M : Matroid α
N : Matroid β
E B✝ I : Set α
h : BijOn f E N.E
B : Set α
hB : B ⊆ (N.comapOn E f)✶.E
⊢ BijOn f E N✶.E
state_after: no goals

tactic: simpa
state_before: α : Type u_1
β : Type u_2
f : α → β
E✝ I✝ s : Set α
M : Matroid α
N : Matroid β
E B✝ I : Set α
h : BijOn f E N.E
B : Set α
hB : B ⊆ (N.comapOn E f)✶.E
⊢ B ⊆ E
state_after: no goals