1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: PowerBasis.degree_minpolyGen
File: Mathlib/RingTheory/PowerBasis.lean

tactic: unfold minpolyGen
state_before: R : Type u_1
S : Type u_2
T : Type u_3
inst✝⁹ : CommRing R
inst✝⁸ : Ring S
inst✝⁷ : Algebra R S
A : Type u_4
B : Type u_5
inst✝⁶ : CommRing A
inst✝⁵ : CommRing B
inst✝⁴ : IsDomain B
inst✝³ : Algebra A B
K : Type u_6
inst✝² : Field K
inst✝¹ : Algebra A S
inst✝ : Nontrivial A
pb : PowerBasis A S
⊢ pb.minpolyGen.degree = ↑pb.dim
state_after: R : Type u_1
S : Type u_2
T : Type u_3
inst✝⁹ : CommRing R
inst✝⁸ : Ring S
inst✝⁷ : Algebra R S
A : Type u_4
B : Type u_5
inst✝⁶ : CommRing A
inst✝⁵ : CommRing B
inst✝⁴ : IsDomain B
inst✝³ : Algebra A B
K : Type u_6
inst✝² : Field K
inst✝¹ : Algebra A S
inst✝ : Nontrivial A
pb : PowerBasis A S
⊢ (X ^ pb.dim - ∑ i : Fin pb.dim, C ((pb.basis.repr (pb.gen ^ pb.dim)) i) * X ^ ↑i).degree = ↑pb.dim

tactic: rw [degree_sub_eq_left_of_degree_lt] <;> rw [degree_X_pow]
state_before: R : Type u_1
S : Type u_2
T : Type u_3
inst✝⁹ : CommRing R
inst✝⁸ : Ring S
inst✝⁷ : Algebra R S
A : Type u_4
B : Type u_5
inst✝⁶ : CommRing A
inst✝⁵ : CommRing B
inst✝⁴ : IsDomain B
inst✝³ : Algebra A B
K : Type u_6
inst✝² : Field K
inst✝¹ : Algebra A S
inst✝ : Nontrivial A
pb : PowerBasis A S
⊢ (X ^ pb.dim - ∑ i : Fin pb.dim, C ((pb.basis.repr (pb.gen ^ pb.dim)) i) * X ^ ↑i).degree = ↑pb.dim
state_after: R : Type u_1
S : Type u_2
T : Type u_3
inst✝⁹ : CommRing R
inst✝⁸ : Ring S
inst✝⁷ : Algebra R S
A : Type u_4
B : Type u_5
inst✝⁶ : CommRing A
inst✝⁵ : CommRing B
inst✝⁴ : IsDomain B
inst✝³ : Algebra A B
K : Type u_6
inst✝² : Field K
inst✝¹ : Algebra A S
inst✝ : Nontrivial A
pb : PowerBasis A S
⊢ (∑ i : Fin pb.dim, C ((pb.basis.repr (pb.gen ^ pb.dim)) i) * X ^ ↑i).degree < ↑pb.dim

tactic: apply degree_sum_fin_lt
state_before: R : Type u_1
S : Type u_2
T : Type u_3
inst✝⁹ : CommRing R
inst✝⁸ : Ring S
inst✝⁷ : Algebra R S
A : Type u_4
B : Type u_5
inst✝⁶ : CommRing A
inst✝⁵ : CommRing B
inst✝⁴ : IsDomain B
inst✝³ : Algebra A B
K : Type u_6
inst✝² : Field K
inst✝¹ : Algebra A S
inst✝ : Nontrivial A
pb : PowerBasis A S
⊢ (∑ i : Fin pb.dim, C ((pb.basis.repr (pb.gen ^ pb.dim)) i) * X ^ ↑i).degree < ↑pb.dim
state_after: no goals
Theorem: Equiv.embeddingCongr_apply_trans
File: Mathlib/Logic/Embedding/Basic.lean

tactic: ext
state_before: α₁ : Sort u_1
β₁ : Sort u_2
γ₁ : Sort u_3
α₂ : Sort u_4
β₂ : Sort u_5
γ₂ : Sort u_6
ea : α₁ ≃ α₂
eb : β₁ ≃ β₂
ec : γ₁ ≃ γ₂
f : α₁ ↪ β₁
g : β₁ ↪ γ₁
⊢ (ea.embeddingCongr ec) (f.trans g) = ((ea.embeddingCongr eb) f).trans ((eb.embeddingCongr ec) g)
state_after: case h
α₁ : Sort u_1
β₁ : Sort u_2
γ₁ : Sort u_3
α₂ : Sort u_4
β₂ : Sort u_5
γ₂ : Sort u_6
ea : α₁ ≃ α₂
eb : β₁ ≃ β₂
ec : γ₁ ≃ γ₂
f : α₁ ↪ β₁
g : β₁ ↪ γ₁
x✝ : α₂
⊢ ((ea.embeddingCongr ec) (f.trans g)) x✝ = (((ea.embeddingCongr eb) f).trans ((eb.embeddingCongr ec) g)) x✝

tactic: simp
state_before: case h
α₁ : Sort u_1
β₁ : Sort u_2
γ₁ : Sort u_3
α₂ : Sort u_4
β₂ : Sort u_5
γ₂ : Sort u_6
ea : α₁ ≃ α₂
eb : β₁ ≃ β₂
ec : γ₁ ≃ γ₂
f : α₁ ↪ β₁
g : β₁ ↪ γ₁
x✝ : α₂
⊢ ((ea.embeddingCongr ec) (f.trans g)) x✝ = (((ea.embeddingCongr eb) f).trans ((eb.embeddingCongr ec) g)) x✝
state_after: no goals
Theorem: Finset.min'_eq_sorted_zero
File: Mathlib/Data/Finset/Sort.lean

tactic: rw [length_sort]
state_before: α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
s : Finset α
h : s.Nonempty
⊢ 0 < (sort (fun x x_1 => x ≤ x_1) s).length
state_after: α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
s : Finset α
h : s.Nonempty
⊢ 0 < s.card

tactic: exact card_pos.2 h
state_before: α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
s : Finset α
h : s.Nonempty
⊢ 0 < s.card
state_after: no goals
Theorem: AlgebraicGeometry.RingedSpace.mem_basicOpen
File: Mathlib/Geometry/RingedSpace/Basic.lean

tactic: constructor
state_before: X : RingedSpace
U : Opens ↑↑X.toPresheafedSpace
f : ↑(X.presheaf.obj { unop := U })
x : ↥U
⊢ ↑x ∈ X.basicOpen f ↔ IsUnit ((X.presheaf.germ x) f)
state_after: case mp
X : RingedSpace
U : Opens ↑↑X.toPresheafedSpace
f : ↑(X.presheaf.obj { unop := U })
x : ↥U
⊢ ↑x ∈ X.basicOpen f → IsUnit ((X.presheaf.germ x) f)

case mpr
X : RingedSpace
U : Opens ↑↑X.toPresheafedSpace
f : ↑(X.presheaf.obj { unop := U })
x : ↥U
⊢ IsUnit ((X.presheaf.germ x) f) → ↑x ∈ X.basicOpen f

tactic: rintro ⟨x, hx, a⟩
state_before: case mp
X : RingedSpace
U : Opens ↑↑X.toPresheafedSpace
f : ↑(X.presheaf.obj { unop := U })
x : ↥U
⊢ ↑x ∈ X.basicOpen f → IsUnit ((X.presheaf.germ x) f)
state_after: case mp.intro.intro
X : RingedSpace
U : Opens ↑↑X.toPresheafedSpace
f : ↑(X.presheaf.obj { unop := U })
x✝ x : ↥U
hx : x ∈ {x | IsUnit ((X.presheaf.germ x) f)}
a : ↑x = ↑x✝
⊢ IsUnit ((X.presheaf.germ x✝) f)

tactic: cases Subtype.eq a
state_before: case mp.intro.intro
X : RingedSpace
U : Opens ↑↑X.toPresheafedSpace
f : ↑(X.presheaf.obj { unop := U })
x✝ x : ↥U
hx : x ∈ {x | IsUnit ((X.presheaf.germ x) f)}
a : ↑x = ↑x✝
⊢ IsUnit ((X.presheaf.germ x✝) f)
state_after: case mp.intro.intro.refl
X : RingedSpace
U : Opens ↑↑X.toPresheafedSpace
f : ↑(X.presheaf.obj { unop := U })
x : ↥U
hx : x ∈ {x | IsUnit ((X.presheaf.germ x) f)}
a : ↑x = ↑x
⊢ IsUnit ((X.presheaf.germ x) f)

tactic: exact hx
state_before: case mp.intro.intro.refl
X : RingedSpace
U : Opens ↑↑X.toPresheafedSpace
f : ↑(X.presheaf.obj { unop := U })
x : ↥U
hx : x ∈ {x | IsUnit ((X.presheaf.germ x) f)}
a : ↑x = ↑x
⊢ IsUnit ((X.presheaf.germ x) f)
state_after: no goals

tactic: intro h
state_before: case mpr
X : RingedSpace
U : Opens ↑↑X.toPresheafedSpace
f : ↑(X.presheaf.obj { unop := U })
x : ↥U
⊢ IsUnit ((X.presheaf.germ x) f) → ↑x ∈ X.basicOpen f
state_after: case mpr
X : RingedSpace
U : Opens ↑↑X.toPresheafedSpace
f : ↑(X.presheaf.obj { unop := U })
x : ↥U
h : IsUnit ((X.presheaf.germ x) f)
⊢ ↑x ∈ X.basicOpen f

tactic: exact ⟨x, h, rfl⟩
state_before: case mpr
X : RingedSpace
U : Opens ↑↑X.toPresheafedSpace
f : ↑(X.presheaf.obj { unop := U })
x : ↥U
h : IsUnit ((X.presheaf.germ x) f)
⊢ ↑x ∈ X.basicOpen f
state_after: no goals
Theorem: Set.BijOn.exists_extend
File: Mathlib/Data/Set/Function.lean

tactic: simpa using h.exists_extend_of_subset (subset_univ s) htt' (by simpa [SurjOn])
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
s s₁ s₂ : Set α
t : Set β
f : α → β
t' : Set β
h : BijOn f s t
htt' : t ⊆ t'
ht' : t' ⊆ range f
⊢ ∃ s', s ⊆ s' ∧ BijOn f s' t'
state_after: no goals

tactic: simpa [SurjOn]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
s s₁ s₂ : Set α
t : Set β
f : α → β
t' : Set β
h : BijOn f s t
htt' : t ⊆ t'
ht' : t' ⊆ range f
⊢ SurjOn f univ t'
state_after: no goals
Theorem: Stream'.WSeq.dropn_cons
File: Mathlib/Data/Seq/WSeq.lean

tactic: induction n with
| zero => simp [drop]
| succ n n_ih =>
  simp [drop, ← n_ih]
state_before: α : Type u
β : Type v
γ : Type w
a : α
s : WSeq α
n : ℕ
⊢ (cons a s).drop (n + 1) = s.drop n
state_after: no goals

tactic: simp [drop]
state_before: case zero
α : Type u
β : Type v
γ : Type w
a : α
s : WSeq α
⊢ (cons a s).drop (0 + 1) = s.drop 0
state_after: no goals

tactic: simp [drop, ← n_ih]
state_before: case succ
α : Type u
β : Type v
γ : Type w
a : α
s : WSeq α
n : ℕ
n_ih : (cons a s).drop (n + 1) = s.drop n
⊢ (cons a s).drop (n + 1 + 1) = s.drop (n + 1)
state_after: no goals
Theorem: FractionalIdeal.coe_one
File: Mathlib/RingTheory/FractionalIdeal/Basic.lean

tactic: rw [coe_one_eq_coeSubmodule_top, coeSubmodule_top]
state_before: R : Type u_1
inst✝² : CommRing R
S : Submonoid R
P : Type u_2
inst✝¹ : CommRing P
inst✝ : Algebra R P
loc : IsLocalization S P
⊢ ↑1 = 1
state_after: no goals
Theorem: HomologicalComplex.epi_of_epi_f
File: Mathlib/Algebra/Homology/HomologicalComplex.lean

tactic: ext i
state_before: ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : HasZeroMorphisms V
c : ComplexShape ι
C K L : HomologicalComplex V c
φ : K ⟶ L
hφ : ∀ (i : ι), Epi (φ.f i)
Z✝ : HomologicalComplex V c
g h : L ⟶ Z✝
eq : φ ≫ g = φ ≫ h
⊢ g = h
state_after: case h
ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : HasZeroMorphisms V
c : ComplexShape ι
C K L : HomologicalComplex V c
φ : K ⟶ L
hφ : ∀ (i : ι), Epi (φ.f i)
Z✝ : HomologicalComplex V c
g h : L ⟶ Z✝
eq : φ ≫ g = φ ≫ h
i : ι
⊢ g.f i = h.f i

tactic: rw [← cancel_epi (φ.f i)]
state_before: case h
ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : HasZeroMorphisms V
c : ComplexShape ι
C K L : HomologicalComplex V c
φ : K ⟶ L
hφ : ∀ (i : ι), Epi (φ.f i)
Z✝ : HomologicalComplex V c
g h : L ⟶ Z✝
eq : φ ≫ g = φ ≫ h
i : ι
⊢ g.f i = h.f i
state_after: case h
ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : HasZeroMorphisms V
c : ComplexShape ι
C K L : HomologicalComplex V c
φ : K ⟶ L
hφ : ∀ (i : ι), Epi (φ.f i)
Z✝ : HomologicalComplex V c
g h : L ⟶ Z✝
eq : φ ≫ g = φ ≫ h
i : ι
⊢ φ.f i ≫ g.f i = φ.f i ≫ h.f i

tactic: exact congr_hom eq i
state_before: case h
ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : HasZeroMorphisms V
c : ComplexShape ι
C K L : HomologicalComplex V c
φ : K ⟶ L
hφ : ∀ (i : ι), Epi (φ.f i)
Z✝ : HomologicalComplex V c
g h : L ⟶ Z✝
eq : φ ≫ g = φ ≫ h
i : ι
⊢ φ.f i ≫ g.f i = φ.f i ≫ h.f i
state_after: no goals
Theorem: NNReal.summable_iff_not_tendsto_nat_atTop
File: Mathlib/Topology/Instances/ENNReal.lean

tactic: rw [← not_iff_not, Classical.not_not, not_summable_iff_tendsto_nat_atTop]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
f : ℕ → ℝ≥0
⊢ Summable f ↔ ¬Tendsto (fun n => ∑ i ∈ Finset.range n, f i) atTop atTop
state_after: no goals
Theorem: Int.clog_of_right_le_one
File: Mathlib/Data/Int/Log.lean

tactic: obtain rfl | hr := hr.eq_or_lt
state_before: R : Type u_1
inst✝¹ : LinearOrderedSemifield R
inst✝ : FloorSemiring R
b : ℕ
r : R
hr : r ≤ 1
⊢ clog b r = -↑(Nat.log b ⌊r⁻¹⌋₊)
state_after: case inl
R : Type u_1
inst✝¹ : LinearOrderedSemifield R
inst✝ : FloorSemiring R
b : ℕ
hr : 1 ≤ 1
⊢ clog b 1 = -↑(Nat.log b ⌊1⁻¹⌋₊)

case inr
R : Type u_1
inst✝¹ : LinearOrderedSemifield R
inst✝ : FloorSemiring R
b : ℕ
r : R
hr✝ : r ≤ 1
hr : r < 1
⊢ clog b r = -↑(Nat.log b ⌊r⁻¹⌋₊)

tactic: rw [clog, if_pos hr, inv_one, Nat.ceil_one, Nat.floor_one, Nat.log_one_right,
  Nat.clog_one_right, Int.ofNat_zero, neg_zero]
state_before: case inl
R : Type u_1
inst✝¹ : LinearOrderedSemifield R
inst✝ : FloorSemiring R
b : ℕ
hr : 1 ≤ 1
⊢ clog b 1 = -↑(Nat.log b ⌊1⁻¹⌋₊)
state_after: no goals

tactic: exact if_neg hr.not_le
state_before: case inr
R : Type u_1
inst✝¹ : LinearOrderedSemifield R
inst✝ : FloorSemiring R
b : ℕ
r : R
hr✝ : r ≤ 1
hr : r < 1
⊢ clog b r = -↑(Nat.log b ⌊r⁻¹⌋₊)
state_after: no goals
Theorem: String.data_take
File: .lake/packages/batteries/Batteries/Data/String/Lemmas.lean

tactic: rw [take_eq]
state_before: s : String
n : Nat
⊢ (s.take n).data = List.take n s.data
state_after: no goals
Theorem: smul_one_smul
File: Mathlib/Algebra/Group/Action/Defs.lean

tactic: rw [smul_assoc, one_smul]
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✝⁴ : Monoid N
inst✝³ : SMul M N
inst✝² : MulAction N α
inst✝¹ : SMul M α
inst✝ : IsScalarTower M N α
x : M
y : α
⊢ (x • 1) • y = x • y
state_after: no goals
Theorem: one_le_star_iff
File: Mathlib/Algebra/Star/Order.lean

tactic: simpa using star_le_star_iff (x := 1) (y := x)
state_before: R : Type u
inst✝³ : Semiring R
inst✝² : PartialOrder R
inst✝¹ : StarRing R
inst✝ : StarOrderedRing R
x : R
⊢ 1 ≤ star x ↔ 1 ≤ x
state_after: no goals
Theorem: SimpleGraph.Walk.subset_support_append_left
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: simp only [Walk.support_append, List.subset_append_left]
state_before: V✝ : Type u
V' : Type v
V'' : Type w
G✝ : SimpleGraph V✝
G' : SimpleGraph V'
G'' : SimpleGraph V''
V : Type u
G : SimpleGraph V
u v w : V
p : G.Walk u v
q : G.Walk v w
⊢ p.support ⊆ (p.append q).support
state_after: no goals
Theorem: Polynomial.abs_tendsto_atTop
File: Mathlib/Analysis/SpecialFunctions/Polynomials.lean

tactic: rcases le_total 0 P.leadingCoeff with hP | hP
state_before: 𝕜 : Type u_1
inst✝¹ : NormedLinearOrderedField 𝕜
P Q : 𝕜[X]
inst✝ : OrderTopology 𝕜
hdeg : 0 < P.degree
⊢ Tendsto (fun x => |eval x P|) atTop atTop
state_after: case inl
𝕜 : Type u_1
inst✝¹ : NormedLinearOrderedField 𝕜
P Q : 𝕜[X]
inst✝ : OrderTopology 𝕜
hdeg : 0 < P.degree
hP : 0 ≤ P.leadingCoeff
⊢ Tendsto (fun x => |eval x P|) atTop atTop

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

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

tactic: exact tendsto_abs_atBot_atTop.comp (P.tendsto_atBot_of_leadingCoeff_nonpos hdeg hP)
state_before: case inr
𝕜 : Type u_1
inst✝¹ : NormedLinearOrderedField 𝕜
P Q : 𝕜[X]
inst✝ : OrderTopology 𝕜
hdeg : 0 < P.degree
hP : P.leadingCoeff ≤ 0
⊢ Tendsto (fun x => |eval x P|) atTop atTop
state_after: no goals
Theorem: Real.Angle.sign_neg
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

tactic: simp_rw [sign, sin_neg, Left.sign_neg]
state_before: θ : Angle
⊢ (-θ).sign = -θ.sign
state_after: no goals
Theorem: Rat.zero_ne_one
File: Mathlib/Data/Rat/Defs.lean

tactic: rw [ne_comm, ← divInt_one_one, divInt_ne_zero] <;> omega
state_before: q a b c : ℚ
⊢ 0 ≠ 1
state_after: no goals
Theorem: Matrix.conjTranspose_mul_self_mul_eq_zero
File: Mathlib/LinearAlgebra/Matrix/DotProduct.lean

tactic: refine ⟨fun h => ?_, fun h => by simp only [Matrix.mul_assoc, h, Matrix.mul_zero]⟩
state_before: m : Type u_1
n : Type u_2
p : Type u_3
R : Type u_4
inst✝⁷ : Fintype m
inst✝⁶ : Fintype n
inst✝⁵ : Fintype p
inst✝⁴ : PartialOrder R
inst✝³ : NonUnitalRing R
inst✝² : StarRing R
inst✝¹ : StarOrderedRing R
inst✝ : NoZeroDivisors R
A : Matrix m n R
B : Matrix n p R
⊢ Aᴴ * A * B = 0 ↔ A * B = 0
state_after: m : Type u_1
n : Type u_2
p : Type u_3
R : Type u_4
inst✝⁷ : Fintype m
inst✝⁶ : Fintype n
inst✝⁵ : Fintype p
inst✝⁴ : PartialOrder R
inst✝³ : NonUnitalRing R
inst✝² : StarRing R
inst✝¹ : StarOrderedRing R
inst✝ : NoZeroDivisors R
A : Matrix m n R
B : Matrix n p R
h : Aᴴ * A * B = 0
⊢ A * B = 0

tactic: rwa [Matrix.mul_zero, Matrix.mul_assoc, ← Matrix.mul_assoc, ← conjTranspose_mul,
  conjTranspose_mul_self_eq_zero] at h
state_before: m : Type u_1
n : Type u_2
p : Type u_3
R : Type u_4
inst✝⁷ : Fintype m
inst✝⁶ : Fintype n
inst✝⁵ : Fintype p
inst✝⁴ : PartialOrder R
inst✝³ : NonUnitalRing R
inst✝² : StarRing R
inst✝¹ : StarOrderedRing R
inst✝ : NoZeroDivisors R
A : Matrix m n R
B : Matrix n p R
h : Bᴴ * (Aᴴ * A * B) = Bᴴ * 0
⊢ A * B = 0
state_after: no goals

tactic: simp only [Matrix.mul_assoc, h, Matrix.mul_zero]
state_before: m : Type u_1
n : Type u_2
p : Type u_3
R : Type u_4
inst✝⁷ : Fintype m
inst✝⁶ : Fintype n
inst✝⁵ : Fintype p
inst✝⁴ : PartialOrder R
inst✝³ : NonUnitalRing R
inst✝² : StarRing R
inst✝¹ : StarOrderedRing R
inst✝ : NoZeroDivisors R
A : Matrix m n R
B : Matrix n p R
h : A * B = 0
⊢ Aᴴ * A * B = 0
state_after: no goals
Theorem: ENNReal.zero_rpow_of_pos
File: Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean

tactic: rw [← ENNReal.coe_zero, ← ENNReal.some_eq_coe]
state_before: y : ℝ
h : 0 < y
⊢ 0 ^ y = 0
state_after: y : ℝ
h : 0 < y
⊢ some 0 ^ y = some 0

tactic: simp [h, asymm h, ne_of_gt h]
state_before: y : ℝ
h : 0 < y
⊢ (if 0 = 0 ∧ y < 0 then ⊤ else ↑(NNReal.rpow 0 y)) = some 0
state_after: no goals
Theorem: CategoryTheory.unitCompPartialBijective_symm_apply
File: Mathlib/CategoryTheory/Adjunction/Reflective.lean

tactic: simp [unitCompPartialBijective, unitCompPartialBijectiveAux_symm_apply]
state_before: C : Type u₁
D : Type u₂
E : Type u₃
inst✝³ : Category.{v₁, u₁} C
inst✝² : Category.{v₂, u₂} D
inst✝¹ : Category.{v₃, u₃} E
i : D ⥤ C
inst✝ : Reflective i
A B : C
hB : B ∈ i.essImage
f : i.obj ((reflector i).obj A) ⟶ B
⊢ (unitCompPartialBijective A hB).symm f = (reflectorAdjunction i).unit.app A ≫ f
state_after: no goals
Theorem: Stream'.Seq.cons_injective2
File: Mathlib/Data/Seq/Seq.lean

tactic: rw [← Option.some_inj, ← get?_cons_zero, h, get?_cons_zero]
state_before: α : Type u
β : Type v
γ : Type w
x y : α
s t : Seq α
h : cons x s = cons y t
⊢ x = y
state_after: no goals

tactic: simp_rw [← get?_cons_succ x s n, h, get?_cons_succ]
state_before: α : Type u
β : Type v
γ : Type w
x y : α
s t : Seq α
h : cons x s = cons y t
n : ℕ
⊢ s.get? n = t.get? n
state_after: no goals
Theorem: CategoryTheory.Limits.Types.colimitEquivQuot_apply
File: Mathlib/CategoryTheory/Limits/Types.lean

tactic: apply (colimitEquivQuot F).symm.injective
state_before: J : Type v
inst✝¹ : Category.{w, v} J
F : J ⥤ Type u
inst✝ : HasColimit F
j : J
x : F.obj j
⊢ (colimitEquivQuot F) (colimit.ι F j x) = Quot.mk (Quot.Rel F) ⟨j, x⟩
state_after: case a
J : Type v
inst✝¹ : Category.{w, v} J
F : J ⥤ Type u
inst✝ : HasColimit F
j : J
x : F.obj j
⊢ (colimitEquivQuot F).symm ((colimitEquivQuot F) (colimit.ι F j x)) =
    (colimitEquivQuot F).symm (Quot.mk (Quot.Rel F) ⟨j, x⟩)

tactic: simp
state_before: case a
J : Type v
inst✝¹ : Category.{w, v} J
F : J ⥤ Type u
inst✝ : HasColimit F
j : J
x : F.obj j
⊢ (colimitEquivQuot F).symm ((colimitEquivQuot F) (colimit.ι F j x)) =
    (colimitEquivQuot F).symm (Quot.mk (Quot.Rel F) ⟨j, x⟩)
state_after: no goals
Theorem: Matrix.cramer_subsingleton_apply
File: Mathlib/LinearAlgebra/Matrix/Adjugate.lean

tactic: rw [cramer_apply, det_eq_elem_of_subsingleton _ i, updateColumn_self]
state_before: m : Type u
n : Type v
α : Type w
inst✝⁵ : DecidableEq n
inst✝⁴ : Fintype n
inst✝³ : DecidableEq m
inst✝² : Fintype m
inst✝¹ : CommRing α
A✝ : Matrix n n α
b✝ : n → α
inst✝ : Subsingleton n
A : Matrix n n α
b : n → α
i : n
⊢ A.cramer b i = b i
state_after: no goals
Theorem: not_IntegrableOn_Ioi_inv
File: Mathlib/Analysis/SpecialFunctions/NonIntegrable.lean

tactic: simpa only [IntegrableOn, restrict_Ioi_eq_restrict_Ici] using not_IntegrableOn_Ici_inv
state_before: E : Type u_1
F : Type u_2
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : NormedAddCommGroup F
a : ℝ
⊢ ¬IntegrableOn (fun x => x⁻¹) (Ioi a) volume
state_after: no goals
Theorem: CategoryTheory.GrothendieckTopology.isIso_toSheafify
File: Mathlib/CategoryTheory/Sites/ConcreteSheafification.lean

tactic: dsimp [toSheafify]
state_before: C : Type u
inst✝³ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝² : Category.{max v u, w} D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : J.Cover X), HasMultiequalizer (S.index P)
inst✝ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
P : Cᵒᵖ ⥤ D
hP : Presheaf.IsSheaf J P
⊢ IsIso (J.toSheafify P)
state_after: C : Type u
inst✝³ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝² : Category.{max v u, w} D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : J.Cover X), HasMultiequalizer (S.index P)
inst✝ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
P : Cᵒᵖ ⥤ D
hP : Presheaf.IsSheaf J P
⊢ IsIso (J.toPlus P ≫ J.plusMap (J.toPlus P))

tactic: haveI := isIso_toPlus_of_isSheaf J P hP
state_before: C : Type u
inst✝³ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝² : Category.{max v u, w} D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : J.Cover X), HasMultiequalizer (S.index P)
inst✝ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
P : Cᵒᵖ ⥤ D
hP : Presheaf.IsSheaf J P
⊢ IsIso (J.toPlus P ≫ J.plusMap (J.toPlus P))
state_after: C : Type u
inst✝³ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝² : Category.{max v u, w} D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : J.Cover X), HasMultiequalizer (S.index P)
inst✝ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
P : Cᵒᵖ ⥤ D
hP : Presheaf.IsSheaf J P
this : IsIso (J.toPlus P)
⊢ IsIso (J.toPlus P ≫ J.plusMap (J.toPlus P))

tactic: change (IsIso (toPlus J P ≫ (J.plusFunctor D).map (toPlus J P)))
state_before: C : Type u
inst✝³ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝² : Category.{max v u, w} D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : J.Cover X), HasMultiequalizer (S.index P)
inst✝ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
P : Cᵒᵖ ⥤ D
hP : Presheaf.IsSheaf J P
this : IsIso (J.toPlus P)
⊢ IsIso (J.toPlus P ≫ J.plusMap (J.toPlus P))
state_after: C : Type u
inst✝³ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝² : Category.{max v u, w} D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : J.Cover X), HasMultiequalizer (S.index P)
inst✝ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
P : Cᵒᵖ ⥤ D
hP : Presheaf.IsSheaf J P
this : IsIso (J.toPlus P)
⊢ IsIso (J.toPlus P ≫ (J.plusFunctor D).map (J.toPlus P))

tactic: infer_instance
state_before: C : Type u
inst✝³ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝² : Category.{max v u, w} D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : J.Cover X), HasMultiequalizer (S.index P)
inst✝ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
P : Cᵒᵖ ⥤ D
hP : Presheaf.IsSheaf J P
this : IsIso (J.toPlus P)
⊢ IsIso (J.toPlus P ≫ (J.plusFunctor D).map (J.toPlus P))
state_after: no goals
Theorem: CategoryTheory.Limits.PreservesKernel.iso_hom
File: Mathlib/CategoryTheory/Limits/Preserves/Shapes/Kernels.lean

tactic: rw [← cancel_mono (kernel.ι _)]
state_before: C : Type u₁
inst✝⁷ : Category.{v₁, u₁} C
inst✝⁶ : HasZeroMorphisms C
D : Type u₂
inst✝⁵ : Category.{v₂, u₂} D
inst✝⁴ : HasZeroMorphisms D
G : C ⥤ D
inst✝³ : G.PreservesZeroMorphisms
X Y Z : C
f : X ⟶ Y
h : Z ⟶ X
w : h ≫ f = 0
inst✝² : HasKernel f
inst✝¹ : HasKernel (G.map f)
inst✝ : PreservesLimit (parallelPair f 0) G
⊢ (iso G f).hom = kernelComparison f G
state_after: C : Type u₁
inst✝⁷ : Category.{v₁, u₁} C
inst✝⁶ : HasZeroMorphisms C
D : Type u₂
inst✝⁵ : Category.{v₂, u₂} D
inst✝⁴ : HasZeroMorphisms D
G : C ⥤ D
inst✝³ : G.PreservesZeroMorphisms
X Y Z : C
f : X ⟶ Y
h : Z ⟶ X
w : h ≫ f = 0
inst✝² : HasKernel f
inst✝¹ : HasKernel (G.map f)
inst✝ : PreservesLimit (parallelPair f 0) G
⊢ (iso G f).hom ≫ kernel.ι (G.map f) = kernelComparison f G ≫ kernel.ι (G.map f)

tactic: simp [PreservesKernel.iso]
state_before: C : Type u₁
inst✝⁷ : Category.{v₁, u₁} C
inst✝⁶ : HasZeroMorphisms C
D : Type u₂
inst✝⁵ : Category.{v₂, u₂} D
inst✝⁴ : HasZeroMorphisms D
G : C ⥤ D
inst✝³ : G.PreservesZeroMorphisms
X Y Z : C
f : X ⟶ Y
h : Z ⟶ X
w : h ≫ f = 0
inst✝² : HasKernel f
inst✝¹ : HasKernel (G.map f)
inst✝ : PreservesLimit (parallelPair f 0) G
⊢ (iso G f).hom ≫ kernel.ι (G.map f) = kernelComparison f G ≫ kernel.ι (G.map f)
state_after: no goals
Theorem: measurable_iUnionLift
File: Mathlib/MeasureTheory/MeasurableSpace/Basic.lean

tactic: rw [preimage_iUnionLift]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort uι
s✝ t✝ u : Set α
m : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
inst✝ : Countable ι
t : ι → Set α
f : (i : ι) → ↑(t i) → β
htf : ∀ (i j : ι) (x : α) (hxi : x ∈ t i) (hxj : x ∈ t j), f i ⟨x, hxi⟩ = f j ⟨x, hxj⟩
T : Set α
hT : T ⊆ ⋃ i, t i
htm : ∀ (i : ι), MeasurableSet (t i)
hfm : ∀ (i : ι), Measurable (f i)
s : Set β
hs : MeasurableSet s
⊢ MeasurableSet (iUnionLift t f htf T hT ⁻¹' s)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort uι
s✝ t✝ u : Set α
m : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
inst✝ : Countable ι
t : ι → Set α
f : (i : ι) → ↑(t i) → β
htf : ∀ (i j : ι) (x : α) (hxi : x ∈ t i) (hxj : x ∈ t j), f i ⟨x, hxi⟩ = f j ⟨x, hxj⟩
T : Set α
hT : T ⊆ ⋃ i, t i
htm : ∀ (i : ι), MeasurableSet (t i)
hfm : ∀ (i : ι), Measurable (f i)
s : Set β
hs : MeasurableSet s
⊢ MeasurableSet (inclusion hT ⁻¹' ⋃ i, inclusion ⋯ '' (f i ⁻¹' s))

tactic: exact .preimage (.iUnion fun i => .image_inclusion _ (htm _) (hfm i hs)) (measurable_inclusion _)
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort uι
s✝ t✝ u : Set α
m : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
inst✝ : Countable ι
t : ι → Set α
f : (i : ι) → ↑(t i) → β
htf : ∀ (i j : ι) (x : α) (hxi : x ∈ t i) (hxj : x ∈ t j), f i ⟨x, hxi⟩ = f j ⟨x, hxj⟩
T : Set α
hT : T ⊆ ⋃ i, t i
htm : ∀ (i : ι), MeasurableSet (t i)
hfm : ∀ (i : ι), Measurable (f i)
s : Set β
hs : MeasurableSet s
⊢ MeasurableSet (inclusion hT ⁻¹' ⋃ i, inclusion ⋯ '' (f i ⁻¹' s))
state_after: no goals