1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: CategoryTheory.Pretriangulated.Triangle.coyoneda_exact₂
File: Mathlib/CategoryTheory/Triangulated/Pretriangulated.lean

tactic: obtain ⟨a, ⟨ha₁, _⟩⟩ := complete_distinguished_triangle_morphism₁ _ T
  (contractible_distinguished X) hT f 0 (by aesop_cat)
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroObject C
inst✝² : HasShift C ℤ
inst✝¹ : Preadditive C
inst✝ : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive
hC : Pretriangulated C
T : Triangle C
hT : T ∈ distinguishedTriangles
X : C
f : X ⟶ T.obj₂
hf : f ≫ T.mor₂ = 0
⊢ ∃ g, f = g ≫ T.mor₁
state_after: case intro.intro
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroObject C
inst✝² : HasShift C ℤ
inst✝¹ : Preadditive C
inst✝ : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive
hC : Pretriangulated C
T : Triangle C
hT : T ∈ distinguishedTriangles
X : C
f : X ⟶ T.obj₂
hf : f ≫ T.mor₂ = 0
a : (contractibleTriangle X).obj₁ ⟶ T.obj₁
ha₁ : (contractibleTriangle X).mor₁ ≫ f = a ≫ T.mor₁
right✝ : (contractibleTriangle X).mor₃ ≫ (CategoryTheory.shiftFunctor C 1).map a = 0 ≫ T.mor₃
⊢ ∃ g, f = g ≫ T.mor₁

tactic: exact ⟨a, by simpa using ha₁⟩
state_before: case intro.intro
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroObject C
inst✝² : HasShift C ℤ
inst✝¹ : Preadditive C
inst✝ : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive
hC : Pretriangulated C
T : Triangle C
hT : T ∈ distinguishedTriangles
X : C
f : X ⟶ T.obj₂
hf : f ≫ T.mor₂ = 0
a : (contractibleTriangle X).obj₁ ⟶ T.obj₁
ha₁ : (contractibleTriangle X).mor₁ ≫ f = a ≫ T.mor₁
right✝ : (contractibleTriangle X).mor₃ ≫ (CategoryTheory.shiftFunctor C 1).map a = 0 ≫ T.mor₃
⊢ ∃ g, f = g ≫ T.mor₁
state_after: no goals

tactic: aesop_cat
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroObject C
inst✝² : HasShift C ℤ
inst✝¹ : Preadditive C
inst✝ : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive
hC : Pretriangulated C
T : Triangle C
hT : T ∈ distinguishedTriangles
X : C
f : X ⟶ T.obj₂
hf : f ≫ T.mor₂ = 0
⊢ (contractibleTriangle X).mor₂ ≫ 0 = f ≫ T.mor₂
state_after: no goals

tactic: simpa using ha₁
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroObject C
inst✝² : HasShift C ℤ
inst✝¹ : Preadditive C
inst✝ : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive
hC : Pretriangulated C
T : Triangle C
hT : T ∈ distinguishedTriangles
X : C
f : X ⟶ T.obj₂
hf : f ≫ T.mor₂ = 0
a : (contractibleTriangle X).obj₁ ⟶ T.obj₁
ha₁ : (contractibleTriangle X).mor₁ ≫ f = a ≫ T.mor₁
right✝ : (contractibleTriangle X).mor₃ ≫ (CategoryTheory.shiftFunctor C 1).map a = 0 ≫ T.mor₃
⊢ f = a ≫ T.mor₁
state_after: no goals
Theorem: isRightRegular_of_non_zero_divisor
File: Mathlib/Algebra/Ring/Regular.lean

tactic: refine fun x y (h' : x * k = y * k) => sub_eq_zero.mp (h _ ?_)
state_before: α : Type u_1
inst✝ : NonUnitalNonAssocRing α
k : α
h : ∀ (x : α), x * k = 0 → x = 0
⊢ IsRightRegular k
state_after: α : Type u_1
inst✝ : NonUnitalNonAssocRing α
k : α
h : ∀ (x : α), x * k = 0 → x = 0
x y : α
h' : x * k = y * k
⊢ (x - y) * k = 0

tactic: rw [sub_mul, sub_eq_zero, h']
state_before: α : Type u_1
inst✝ : NonUnitalNonAssocRing α
k : α
h : ∀ (x : α), x * k = 0 → x = 0
x y : α
h' : x * k = y * k
⊢ (x - y) * k = 0
state_after: no goals
Theorem: LieSubalgebra.lieSpan_mono
File: Mathlib/Algebra/Lie/Subalgebra.lean

tactic: rw [lieSpan_le]
state_before: R : Type u
L : Type v
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
L₂ : Type w
inst✝¹ : LieRing L₂
inst✝ : LieAlgebra R L₂
f : L →ₗ⁅R⁆ L₂
K K' : LieSubalgebra R L
K₂ : LieSubalgebra R L₂
s t : Set L
h : s ⊆ t
⊢ lieSpan R L s ≤ lieSpan R L t
state_after: R : Type u
L : Type v
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
L₂ : Type w
inst✝¹ : LieRing L₂
inst✝ : LieAlgebra R L₂
f : L →ₗ⁅R⁆ L₂
K K' : LieSubalgebra R L
K₂ : LieSubalgebra R L₂
s t : Set L
h : s ⊆ t
⊢ s ⊆ ↑(lieSpan R L t)

tactic: exact Set.Subset.trans h subset_lieSpan
state_before: R : Type u
L : Type v
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
L₂ : Type w
inst✝¹ : LieRing L₂
inst✝ : LieAlgebra R L₂
f : L →ₗ⁅R⁆ L₂
K K' : LieSubalgebra R L
K₂ : LieSubalgebra R L₂
s t : Set L
h : s ⊆ t
⊢ s ⊆ ↑(lieSpan R L t)
state_after: no goals
Theorem: pow_mul_pow_sub
File: Mathlib/Algebra/Group/Basic.lean

tactic: rw [← pow_add, Nat.add_comm, Nat.sub_add_cancel h]
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : Monoid M
a✝ b c : M
m n : ℕ
a : M
h : m ≤ n
⊢ a ^ m * a ^ (n - m) = a ^ n
state_after: no goals
Theorem: Set.ncard_eq_succ
File: Mathlib/Data/Set/Card.lean

tactic: refine ⟨eq_insert_of_ncard_eq_succ, ?_⟩
state_before: α : Type u_1
β : Type u_2
s t : Set α
f : α → β
n : ℕ
hs : autoParam s.Finite _auto✝
⊢ s.ncard = n + 1 ↔ ∃ a t, a ∉ t ∧ insert a t = s ∧ t.ncard = n
state_after: α : Type u_1
β : Type u_2
s t : Set α
f : α → β
n : ℕ
hs : autoParam s.Finite _auto✝
⊢ (∃ a t, a ∉ t ∧ insert a t = s ∧ t.ncard = n) → s.ncard = n + 1

tactic: rintro ⟨a, t, hat, h, rfl⟩
state_before: α : Type u_1
β : Type u_2
s t : Set α
f : α → β
n : ℕ
hs : autoParam s.Finite _auto✝
⊢ (∃ a t, a ∉ t ∧ insert a t = s ∧ t.ncard = n) → s.ncard = n + 1
state_after: case intro.intro.intro.intro
α : Type u_1
β : Type u_2
s t✝ : Set α
f : α → β
hs : autoParam s.Finite _auto✝
a : α
t : Set α
hat : a ∉ t
h : insert a t = s
⊢ s.ncard = t.ncard + 1

tactic: rw [← h, ncard_insert_of_not_mem hat (hs.subset ((subset_insert a t).trans_eq h))]
state_before: case intro.intro.intro.intro
α : Type u_1
β : Type u_2
s t✝ : Set α
f : α → β
hs : autoParam s.Finite _auto✝
a : α
t : Set α
hat : a ∉ t
h : insert a t = s
⊢ s.ncard = t.ncard + 1
state_after: no goals
Theorem: Set.Definable.map_expansion
File: Mathlib/ModelTheory/Definability.lean

tactic: obtain ⟨ψ, rfl⟩ := h
state_before: M : Type w
A : Set M
L : Language
inst✝² : L.Structure M
α : Type u₁
β : Type u_1
B : Set M
s : Set (α → M)
L' : Language
inst✝¹ : L'.Structure M
h : A.Definable L s
φ : L →ᴸ L'
inst✝ : φ.IsExpansionOn M
⊢ A.Definable L' s
state_after: case intro
M : Type w
A : Set M
L : Language
inst✝² : L.Structure M
α : Type u₁
β : Type u_1
B : Set M
L' : Language
inst✝¹ : L'.Structure M
φ : L →ᴸ L'
inst✝ : φ.IsExpansionOn M
ψ : L[[↑A]].Formula α
⊢ A.Definable L' (setOf ψ.Realize)

tactic: refine ⟨(φ.addConstants A).onFormula ψ, ?_⟩
state_before: case intro
M : Type w
A : Set M
L : Language
inst✝² : L.Structure M
α : Type u₁
β : Type u_1
B : Set M
L' : Language
inst✝¹ : L'.Structure M
φ : L →ᴸ L'
inst✝ : φ.IsExpansionOn M
ψ : L[[↑A]].Formula α
⊢ A.Definable L' (setOf ψ.Realize)
state_after: case intro
M : Type w
A : Set M
L : Language
inst✝² : L.Structure M
α : Type u₁
β : Type u_1
B : Set M
L' : Language
inst✝¹ : L'.Structure M
φ : L →ᴸ L'
inst✝ : φ.IsExpansionOn M
ψ : L[[↑A]].Formula α
⊢ setOf ψ.Realize = setOf ((LHom.addConstants (↑A) φ).onFormula ψ).Realize

tactic: ext x
state_before: case intro
M : Type w
A : Set M
L : Language
inst✝² : L.Structure M
α : Type u₁
β : Type u_1
B : Set M
L' : Language
inst✝¹ : L'.Structure M
φ : L →ᴸ L'
inst✝ : φ.IsExpansionOn M
ψ : L[[↑A]].Formula α
⊢ setOf ψ.Realize = setOf ((LHom.addConstants (↑A) φ).onFormula ψ).Realize
state_after: case intro.h
M : Type w
A : Set M
L : Language
inst✝² : L.Structure M
α : Type u₁
β : Type u_1
B : Set M
L' : Language
inst✝¹ : L'.Structure M
φ : L →ᴸ L'
inst✝ : φ.IsExpansionOn M
ψ : L[[↑A]].Formula α
x : α → M
⊢ x ∈ setOf ψ.Realize ↔ x ∈ setOf ((LHom.addConstants (↑A) φ).onFormula ψ).Realize

tactic: simp only [mem_setOf_eq, LHom.realize_onFormula]
state_before: case intro.h
M : Type w
A : Set M
L : Language
inst✝² : L.Structure M
α : Type u₁
β : Type u_1
B : Set M
L' : Language
inst✝¹ : L'.Structure M
φ : L →ᴸ L'
inst✝ : φ.IsExpansionOn M
ψ : L[[↑A]].Formula α
x : α → M
⊢ x ∈ setOf ψ.Realize ↔ x ∈ setOf ((LHom.addConstants (↑A) φ).onFormula ψ).Realize
state_after: no goals
Theorem: hallMatchingsOn.nonempty
File: Mathlib/Combinatorics/Hall/Basic.lean

tactic: refine ⟨Classical.indefiniteDescription _ ?_⟩
state_before: ι : Type u
α : Type v
inst✝ : DecidableEq α
t : ι → Finset α
h : ∀ (s : Finset ι), s.card ≤ (s.biUnion t).card
ι' : Finset ι
⊢ Nonempty ↑(hallMatchingsOn t ι')
state_after: ι : Type u
α : Type v
inst✝ : DecidableEq α
t : ι → Finset α
h : ∀ (s : Finset ι), s.card ≤ (s.biUnion t).card
ι' : Finset ι
⊢ ∃ x, x ∈ hallMatchingsOn t ι'

tactic: apply (all_card_le_biUnion_card_iff_existsInjective' fun i : ι' => t i).mp
state_before: ι : Type u
α : Type v
inst✝ : DecidableEq α
t : ι → Finset α
h : ∀ (s : Finset ι), s.card ≤ (s.biUnion t).card
ι' : Finset ι
⊢ ∃ x, x ∈ hallMatchingsOn t ι'
state_after: ι : Type u
α : Type v
inst✝ : DecidableEq α
t : ι → Finset α
h : ∀ (s : Finset ι), s.card ≤ (s.biUnion t).card
ι' : Finset ι
⊢ ∀ (s : Finset { x // x ∈ ι' }), s.card ≤ (s.biUnion fun i => t ↑i).card

tactic: intro s'
state_before: ι : Type u
α : Type v
inst✝ : DecidableEq α
t : ι → Finset α
h : ∀ (s : Finset ι), s.card ≤ (s.biUnion t).card
ι' : Finset ι
⊢ ∀ (s : Finset { x // x ∈ ι' }), s.card ≤ (s.biUnion fun i => t ↑i).card
state_after: ι : Type u
α : Type v
inst✝ : DecidableEq α
t : ι → Finset α
h : ∀ (s : Finset ι), s.card ≤ (s.biUnion t).card
ι' : Finset ι
s' : Finset { x // x ∈ ι' }
⊢ s'.card ≤ (s'.biUnion fun i => t ↑i).card

tactic: convert h (s'.image (↑)) using 1
state_before: ι : Type u
α : Type v
inst✝ : DecidableEq α
t : ι → Finset α
h : ∀ (s : Finset ι), s.card ≤ (s.biUnion t).card
ι' : Finset ι
s' : Finset { x // x ∈ ι' }
⊢ s'.card ≤ (s'.biUnion fun i => t ↑i).card
state_after: case h.e'_3
ι : Type u
α : Type v
inst✝ : DecidableEq α
t : ι → Finset α
h : ∀ (s : Finset ι), s.card ≤ (s.biUnion t).card
ι' : Finset ι
s' : Finset { x // x ∈ ι' }
⊢ s'.card = (image Subtype.val s').card

case h.e'_4
ι : Type u
α : Type v
inst✝ : DecidableEq α
t : ι → Finset α
h : ∀ (s : Finset ι), s.card ≤ (s.biUnion t).card
ι' : Finset ι
s' : Finset { x // x ∈ ι' }
⊢ (s'.biUnion fun i => t ↑i).card = ((image Subtype.val s').biUnion t).card

tactic: simp only [card_image_of_injective s' Subtype.coe_injective]
state_before: case h.e'_3
ι : Type u
α : Type v
inst✝ : DecidableEq α
t : ι → Finset α
h : ∀ (s : Finset ι), s.card ≤ (s.biUnion t).card
ι' : Finset ι
s' : Finset { x // x ∈ ι' }
⊢ s'.card = (image Subtype.val s').card
state_after: no goals

tactic: rw [image_biUnion]
state_before: case h.e'_4
ι : Type u
α : Type v
inst✝ : DecidableEq α
t : ι → Finset α
h : ∀ (s : Finset ι), s.card ≤ (s.biUnion t).card
ι' : Finset ι
s' : Finset { x // x ∈ ι' }
⊢ (s'.biUnion fun i => t ↑i).card = ((image Subtype.val s').biUnion t).card
state_after: no goals
Theorem: DFinsupp.erase_same
File: Mathlib/Data/DFinsupp/Basic.lean

tactic: simp
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝¹ : DecidableEq ι
inst✝ : (i : ι) → Zero (β i)
s : Finset ι
x : (i : ↑↑s) → β ↑i
i✝ i : ι
f : Π₀ (i : ι), β i
⊢ (erase i f) i = 0
state_after: no goals
Theorem: Int.isCoprime_iff_gcd_eq_one
File: Mathlib/RingTheory/Coprime/Lemmas.lean

tactic: constructor
state_before: R : Type u
I : Type v
inst✝ : CommSemiring R
x y z : R
s : I → R
t : Finset I
m n : ℤ
⊢ IsCoprime m n ↔ m.gcd n = 1
state_after: case mp
R : Type u
I : Type v
inst✝ : CommSemiring R
x y z : R
s : I → R
t : Finset I
m n : ℤ
⊢ IsCoprime m n → m.gcd n = 1

case mpr
R : Type u
I : Type v
inst✝ : CommSemiring R
x y z : R
s : I → R
t : Finset I
m n : ℤ
⊢ m.gcd n = 1 → IsCoprime m n

tactic: rintro ⟨a, b, h⟩
state_before: case mp
R : Type u
I : Type v
inst✝ : CommSemiring R
x y z : R
s : I → R
t : Finset I
m n : ℤ
⊢ IsCoprime m n → m.gcd n = 1
state_after: case mp.intro.intro
R : Type u
I : Type v
inst✝ : CommSemiring R
x y z : R
s : I → R
t : Finset I
m n a b : ℤ
h : a * m + b * n = 1
⊢ m.gcd n = 1

tactic: have : 1 = m * a + n * b := by rwa [mul_comm m, mul_comm n, eq_comm]
state_before: case mp.intro.intro
R : Type u
I : Type v
inst✝ : CommSemiring R
x y z : R
s : I → R
t : Finset I
m n a b : ℤ
h : a * m + b * n = 1
⊢ m.gcd n = 1
state_after: case mp.intro.intro
R : Type u
I : Type v
inst✝ : CommSemiring R
x y z : R
s : I → R
t : Finset I
m n a b : ℤ
h : a * m + b * n = 1
this : 1 = m * a + n * b
⊢ m.gcd n = 1

tactic: exact Nat.dvd_one.mp (Int.gcd_dvd_iff.mpr ⟨a, b, this⟩)
state_before: case mp.intro.intro
R : Type u
I : Type v
inst✝ : CommSemiring R
x y z : R
s : I → R
t : Finset I
m n a b : ℤ
h : a * m + b * n = 1
this : 1 = m * a + n * b
⊢ m.gcd n = 1
state_after: no goals

tactic: rwa [mul_comm m, mul_comm n, eq_comm]
state_before: R : Type u
I : Type v
inst✝ : CommSemiring R
x y z : R
s : I → R
t : Finset I
m n a b : ℤ
h : a * m + b * n = 1
⊢ 1 = m * a + n * b
state_after: no goals

tactic: rw [← Int.ofNat_inj, IsCoprime, Int.gcd_eq_gcd_ab, mul_comm m, mul_comm n, Nat.cast_one]
state_before: case mpr
R : Type u
I : Type v
inst✝ : CommSemiring R
x y z : R
s : I → R
t : Finset I
m n : ℤ
⊢ m.gcd n = 1 → IsCoprime m n
state_after: case mpr
R : Type u
I : Type v
inst✝ : CommSemiring R
x y z : R
s : I → R
t : Finset I
m n : ℤ
⊢ m.gcdA n * m + m.gcdB n * n = 1 → ∃ a b, a * m + b * n = 1

tactic: intro h
state_before: case mpr
R : Type u
I : Type v
inst✝ : CommSemiring R
x y z : R
s : I → R
t : Finset I
m n : ℤ
⊢ m.gcdA n * m + m.gcdB n * n = 1 → ∃ a b, a * m + b * n = 1
state_after: case mpr
R : Type u
I : Type v
inst✝ : CommSemiring R
x y z : R
s : I → R
t : Finset I
m n : ℤ
h : m.gcdA n * m + m.gcdB n * n = 1
⊢ ∃ a b, a * m + b * n = 1

tactic: exact ⟨_, _, h⟩
state_before: case mpr
R : Type u
I : Type v
inst✝ : CommSemiring R
x y z : R
s : I → R
t : Finset I
m n : ℤ
h : m.gcdA n * m + m.gcdB n * n = 1
⊢ ∃ a b, a * m + b * n = 1
state_after: no goals
Theorem: Pi.card_Ioo
File: Mathlib/Data/Pi/Interval.lean

tactic: rw [card_Ioo_eq_card_Icc_sub_two, card_Icc]
state_before: ι : Type u_1
α : ι → Type u_2
inst✝⁴ : Fintype ι
inst✝³ : DecidableEq ι
inst✝² : (i : ι) → DecidableEq (α i)
inst✝¹ : (i : ι) → PartialOrder (α i)
inst✝ : (i : ι) → LocallyFiniteOrder (α i)
a b : (i : ι) → α i
⊢ (Ioo a b).card = ∏ i : ι, (Icc (a i) (b i)).card - 2
state_after: no goals
Theorem: intervalIntegral.integral_sub_integral_sub_linear_isLittleO_of_tendsto_ae_right
File: Mathlib/MeasureTheory/Integral/FundThmCalculus.lean

tactic: simpa only [integral_const, smul_eq_mul, mul_one] using
  measure_integral_sub_integral_sub_linear_isLittleO_of_tendsto_ae_right hab hmeas hf hu hv
state_before: ι : Type u_1
𝕜 : Type u_2
E : Type u_3
F : Type u_4
A : Type u_5
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : CompleteSpace E
f : ℝ → E
c ca cb : E
l l' la la' lb lb' : Filter ℝ
lt : Filter ι
a b z : ℝ
u v ua ub va vb : ι → ℝ
inst✝¹ : FTCFilter a la la'
inst✝ : FTCFilter b lb lb'
hab : IntervalIntegrable f volume a b
hmeas : StronglyMeasurableAtFilter f lb' volume
hf : Tendsto f (lb' ⊓ ae volume) (𝓝 c)
hu : Tendsto u lt lb
hv : Tendsto v lt lb
⊢ (fun t => ((∫ (x : ℝ) in a..v t, f x) - ∫ (x : ℝ) in a..u t, f x) - (v t - u t) • c) =o[lt] (v - u)
state_after: no goals
Theorem: UniformInducing.inducing
File: Mathlib/Topology/UniformSpace/UniformEmbedding.lean

tactic: obtain rfl := h.comap_uniformSpace
state_before: α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
f : α → β
h : UniformInducing f
⊢ Inducing f
state_after: α : Type u
β : Type v
γ : Type w
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
f : α → β
h : UniformInducing f
⊢ Inducing f

tactic: exact inducing_induced f
state_before: α : Type u
β : Type v
γ : Type w
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
f : α → β
h : UniformInducing f
⊢ Inducing f
state_after: no goals
Theorem: TopologicalSpace.Opens.adjunction_counit_app_self
File: Mathlib/Topology/Category/TopCat/Opens.lean

tactic: simp
state_before: X : TopCat
U : Opens ↑X
⊢ (map U.inclusion ⋙ ⋯.functor).obj U = (𝟭 (Opens ↑X)).obj U
state_after: no goals
Theorem: List.rtakeWhile_suffix
File: Mathlib/Data/List/DropRight.lean

tactic: rw [← reverse_prefix, rtakeWhile, reverse_reverse]
state_before: α : Type u_1
p : α → Bool
l : List α
n : ℕ
⊢ rtakeWhile p l <:+ l
state_after: α : Type u_1
p : α → Bool
l : List α
n : ℕ
⊢ takeWhile p l.reverse <+: l.reverse

tactic: exact takeWhile_prefix _
state_before: α : Type u_1
p : α → Bool
l : List α
n : ℕ
⊢ takeWhile p l.reverse <+: l.reverse
state_after: no goals
Theorem: Real.isLittleO_one_exp_comp
File: Mathlib/Analysis/SpecialFunctions/Exp.lean

tactic: simp only [← exp_zero, isLittleO_exp_comp_exp_comp, sub_zero]
state_before: α : Type u_1
x y z : ℝ
l : Filter α
f : α → ℝ
⊢ ((fun x => 1) =o[l] fun x => rexp (f x)) ↔ Tendsto f l atTop
state_after: no goals
Theorem: Function.mulSupport_curry
File: Mathlib/Algebra/Group/Support.lean

tactic: simp [mulSupport, funext_iff, image]
state_before: α : Type u_1
β : Type u_2
A : Type u_3
B : Type u_4
M : Type u_5
N : Type u_6
P : Type u_7
G : Type u_8
inst✝² : One M
inst✝¹ : One N
inst✝ : One P
f : α × β → M
⊢ mulSupport (curry f) = Prod.fst '' mulSupport f
state_after: no goals
Theorem: CategoryTheory.rightDistributor_inv_comp_biproduct_π
File: Mathlib/CategoryTheory/Monoidal/Preadditive.lean

tactic: simp [rightDistributor_inv, Preadditive.sum_comp, ← MonoidalCategory.comp_whiskerRight,
  biproduct.ι_π, dite_whiskerRight, comp_dite]
state_before: C : Type u_1
inst✝⁵ : Category.{u_2, u_1} C
inst✝⁴ : Preadditive C
inst✝³ : MonoidalCategory C
inst✝² : MonoidalPreadditive C
inst✝¹ : HasFiniteBiproducts C
J : Type
inst✝ : Fintype J
f : J → C
X : C
j : J
⊢ (rightDistributor f X).inv ≫ biproduct.π f j ▷ X = biproduct.π (fun j => f j ⊗ X) j
state_after: no goals
Theorem: Real.exp_bound
File: Mathlib/Data/Complex/Exponential.lean

tactic: have hxc : Complex.abs x ≤ 1 := mod_cast hx
state_before: x : ℝ
hx : |x| ≤ 1
n : ℕ
hn : 0 < n
⊢ |rexp x - ∑ m ∈ range n, x ^ m / ↑m.factorial| ≤ |x| ^ n * (↑n.succ / (↑n.factorial * ↑n))
state_after: x : ℝ
hx : |x| ≤ 1
n : ℕ
hn : 0 < n
hxc : Complex.abs ↑x ≤ 1
⊢ |rexp x - ∑ m ∈ range n, x ^ m / ↑m.factorial| ≤ |x| ^ n * (↑n.succ / (↑n.factorial * ↑n))

tactic: convert exp_bound hxc hn using 2 <;>
simp only [← abs_ofReal, ← ofReal_sub, ← ofReal_exp, ← ofReal_sum, ← ofReal_pow,
  ← ofReal_div, ← ofReal_natCast]
state_before: x : ℝ
hx : |x| ≤ 1
n : ℕ
hn : 0 < n
hxc : Complex.abs ↑x ≤ 1
⊢ |rexp x - ∑ m ∈ range n, x ^ m / ↑m.factorial| ≤ |x| ^ n * (↑n.succ / (↑n.factorial * ↑n))
state_after: no goals
Theorem: WittVector.verschiebung_frobenius
File: Mathlib/RingTheory/WittVector/Identities.lean

tactic: ext ⟨i⟩
state_before: p : ℕ
R : Type u_1
hp : Fact (Nat.Prime p)
inst✝¹ : CommRing R
inst✝ : CharP R p
x : 𝕎 R
⊢ verschiebung (frobenius x) = x * ↑p
state_after: case h.zero
p : ℕ
R : Type u_1
hp : Fact (Nat.Prime p)
inst✝¹ : CommRing R
inst✝ : CharP R p
x : 𝕎 R
⊢ (verschiebung (frobenius x)).coeff 0 = (x * ↑p).coeff 0

case h.succ
p : ℕ
R : Type u_1
hp : Fact (Nat.Prime p)
inst✝¹ : CommRing R
inst✝ : CharP R p
x : 𝕎 R
n✝ : ℕ
⊢ (verschiebung (frobenius x)).coeff (n✝ + 1) = (x * ↑p).coeff (n✝ + 1)

tactic: rw [mul_charP_coeff_zero, verschiebung_coeff_zero]
state_before: case h.zero
p : ℕ
R : Type u_1
hp : Fact (Nat.Prime p)
inst✝¹ : CommRing R
inst✝ : CharP R p
x : 𝕎 R
⊢ (verschiebung (frobenius x)).coeff 0 = (x * ↑p).coeff 0
state_after: no goals

tactic: rw [mul_charP_coeff_succ, verschiebung_coeff_succ, coeff_frobenius_charP]
state_before: case h.succ
p : ℕ
R : Type u_1
hp : Fact (Nat.Prime p)
inst✝¹ : CommRing R
inst✝ : CharP R p
x : 𝕎 R
n✝ : ℕ
⊢ (verschiebung (frobenius x)).coeff (n✝ + 1) = (x * ↑p).coeff (n✝ + 1)
state_after: no goals
Theorem: Batteries.UnionFind.rank'_lt
File: .lake/packages/batteries/Batteries/Data/UnionFind/Basic.lean

tactic: simpa only [← parentD_eq] using self.rankD_lt
state_before: self : UnionFind
i : Fin self.size
⊢ (self.arr.get i).parent ≠ ↑i → self.rank ↑i < self.rank (self.arr.get i).parent
state_after: no goals
Theorem: ENNReal.div_eq_div_iff
File: Mathlib/Data/ENNReal/Inv.lean

tactic: rw [eq_div_iff ha ha']
state_before: a b c d : ℝ≥0∞
r p q : ℝ≥0
ha : a ≠ 0
ha' : a ≠ ⊤
hb : b ≠ 0
hb' : b ≠ ⊤
⊢ c / b = d / a ↔ a * c = b * d
state_after: a b c d : ℝ≥0∞
r p q : ℝ≥0
ha : a ≠ 0
ha' : a ≠ ⊤
hb : b ≠ 0
hb' : b ≠ ⊤
⊢ a * (c / b) = d ↔ a * c = b * d

tactic: conv_rhs => rw [eq_comm]
state_before: a b c d : ℝ≥0∞
r p q : ℝ≥0
ha : a ≠ 0
ha' : a ≠ ⊤
hb : b ≠ 0
hb' : b ≠ ⊤
⊢ a * (c / b) = d ↔ a * c = b * d
state_after: a b c d : ℝ≥0∞
r p q : ℝ≥0
ha : a ≠ 0
ha' : a ≠ ⊤
hb : b ≠ 0
hb' : b ≠ ⊤
⊢ a * (c / b) = d ↔ b * d = a * c

tactic: rw [← eq_div_iff hb hb', mul_div_assoc, eq_comm]
state_before: a b c d : ℝ≥0∞
r p q : ℝ≥0
ha : a ≠ 0
ha' : a ≠ ⊤
hb : b ≠ 0
hb' : b ≠ ⊤
⊢ a * (c / b) = d ↔ b * d = a * c
state_after: no goals
Theorem: linearIndependent_empty
File: Mathlib/LinearAlgebra/LinearIndependent.lean

tactic: simp [linearIndependent_subtype_disjoint]
state_before: ι : Type u'
ι' : Type u_1
R : Type u_2
K : Type u_3
M : Type u_4
M' : Type u_5
M'' : Type u_6
V : Type u
V' : Type u_7
v : ι → M
inst✝⁶ : Semiring R
inst✝⁵ : AddCommMonoid M
inst✝⁴ : AddCommMonoid M'
inst✝³ : AddCommMonoid M''
inst✝² : Module R M
inst✝¹ : Module R M'
inst✝ : Module R M''
a b : R
x y : M
⊢ LinearIndependent R fun (x : ↑∅) => ↑x
state_after: no goals
Theorem: trop_sInf_image
File: Mathlib/Algebra/Tropical/BigOperators.lean

tactic: rcases s.eq_empty_or_nonempty with (rfl | h)
state_before: R : Type u_1
S : Type u_2
inst✝ : ConditionallyCompleteLinearOrder R
s : Finset S
f : S → WithTop R
⊢ trop (sInf (f '' ↑s)) = ∑ i ∈ s, trop (f i)
state_after: case inl
R : Type u_1
S : Type u_2
inst✝ : ConditionallyCompleteLinearOrder R
f : S → WithTop R
⊢ trop (sInf (f '' ↑∅)) = ∑ i ∈ ∅, trop (f i)

case inr
R : Type u_1
S : Type u_2
inst✝ : ConditionallyCompleteLinearOrder R
s : Finset S
f : S → WithTop R
h : s.Nonempty
⊢ trop (sInf (f '' ↑s)) = ∑ i ∈ s, trop (f i)

tactic: rw [← inf'_eq_csInf_image _ h, inf'_eq_inf, s.trop_inf]
state_before: case inr
R : Type u_1
S : Type u_2
inst✝ : ConditionallyCompleteLinearOrder R
s : Finset S
f : S → WithTop R
h : s.Nonempty
⊢ trop (sInf (f '' ↑s)) = ∑ i ∈ s, trop (f i)
state_after: no goals

tactic: simp only [Set.image_empty, coe_empty, sum_empty, WithTop.sInf_empty, trop_top]
state_before: case inl
R : Type u_1
S : Type u_2
inst✝ : ConditionallyCompleteLinearOrder R
f : S → WithTop R
⊢ trop (sInf (f '' ↑∅)) = ∑ i ∈ ∅, trop (f i)
state_after: no goals
Theorem: Set.compl_sUnion
File: Mathlib/Data/Set/Lattice.lean

tactic: simp
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
ι₂ : Sort u_6
κ : ι → Sort u_7
κ₁ : ι → Sort u_8
κ₂ : ι → Sort u_9
κ' : ι' → Sort u_10
S : Set (Set α)
x : α
⊢ x ∈ (⋃₀ S)ᶜ ↔ x ∈ ⋂₀ (compl '' S)
state_after: no goals
Theorem: Batteries.RBNode.Ordered.find?_some
File: .lake/packages/batteries/Batteries/Data/RBMap/Lemmas.lean

tactic: refine ⟨fun h => ⟨find?_some_mem h, find?_some_eq_eq h⟩, fun ⟨hx, e⟩ => ?_⟩
state_before: α : Type u_1
cmp : α → α → Ordering
cut : α → Ordering
t : RBNode α
x : α
inst✝¹ : TransCmp cmp
inst✝ : IsStrictCut cmp cut
ht : Ordered cmp t
⊢ find? cut t = some x ↔ x ∈ t ∧ cut x = Ordering.eq
state_after: α : Type u_1
cmp : α → α → Ordering
cut : α → Ordering
t : RBNode α
x : α
inst✝¹ : TransCmp cmp
inst✝ : IsStrictCut cmp cut
ht : Ordered cmp t
x✝ : x ∈ t ∧ cut x = Ordering.eq
hx : x ∈ t
e : cut x = Ordering.eq
⊢ find? cut t = some x

tactic: have ⟨y, hy⟩ := ht.memP_iff_find?.1 (memP_def.2 ⟨_, hx, e⟩)
state_before: α : Type u_1
cmp : α → α → Ordering
cut : α → Ordering
t : RBNode α
x : α
inst✝¹ : TransCmp cmp
inst✝ : IsStrictCut cmp cut
ht : Ordered cmp t
x✝ : x ∈ t ∧ cut x = Ordering.eq
hx : x ∈ t
e : cut x = Ordering.eq
⊢ find? cut t = some x
state_after: α : Type u_1
cmp : α → α → Ordering
cut : α → Ordering
t : RBNode α
x : α
inst✝¹ : TransCmp cmp
inst✝ : IsStrictCut cmp cut
ht : Ordered cmp t
x✝ : x ∈ t ∧ cut x = Ordering.eq
hx : x ∈ t
e : cut x = Ordering.eq
y : α
hy : find? cut t = some y
⊢ find? cut t = some x

tactic: exact ht.unique hx (find?_some_mem hy) ((IsStrictCut.exact e).trans (find?_some_eq_eq hy)) ▸ hy
state_before: α : Type u_1
cmp : α → α → Ordering
cut : α → Ordering
t : RBNode α
x : α
inst✝¹ : TransCmp cmp
inst✝ : IsStrictCut cmp cut
ht : Ordered cmp t
x✝ : x ∈ t ∧ cut x = Ordering.eq
hx : x ∈ t
e : cut x = Ordering.eq
y : α
hy : find? cut t = some y
⊢ find? cut t = some x
state_after: no goals