1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: ManyOneDegree.le_refl
File: Mathlib/Computability/Reduce.lean

tactic: induction d using ManyOneDegree.ind_on
state_before: α : Type u
inst✝⁵ : Primcodable α
inst✝⁴ : Inhabited α
β : Type v
inst✝³ : Primcodable β
inst✝² : Inhabited β
γ : Type w
inst✝¹ : Primcodable γ
inst✝ : Inhabited γ
d : ManyOneDegree
⊢ d ≤ d
state_after: case h
α : Type u
inst✝⁵ : Primcodable α
inst✝⁴ : Inhabited α
β : Type v
inst✝³ : Primcodable β
inst✝² : Inhabited β
γ : Type w
inst✝¹ : Primcodable γ
inst✝ : Inhabited γ
p✝ : Set ℕ
⊢ of p✝ ≤ of p✝

tactic: simp
state_before: case h
α : Type u
inst✝⁵ : Primcodable α
inst✝⁴ : Inhabited α
β : Type v
inst✝³ : Primcodable β
inst✝² : Inhabited β
γ : Type w
inst✝¹ : Primcodable γ
inst✝ : Inhabited γ
p✝ : Set ℕ
⊢ of p✝ ≤ of p✝
state_after: case h
α : Type u
inst✝⁵ : Primcodable α
inst✝⁴ : Inhabited α
β : Type v
inst✝³ : Primcodable β
inst✝² : Inhabited β
γ : Type w
inst✝¹ : Primcodable γ
inst✝ : Inhabited γ
p✝ : Set ℕ
⊢ p✝ ≤₀ p✝

tactic: rfl
state_before: case h
α : Type u
inst✝⁵ : Primcodable α
inst✝⁴ : Inhabited α
β : Type v
inst✝³ : Primcodable β
inst✝² : Inhabited β
γ : Type w
inst✝¹ : Primcodable γ
inst✝ : Inhabited γ
p✝ : Set ℕ
⊢ p✝ ≤₀ p✝
state_after: no goals
Theorem: Subring.exists_list_of_mem_closure
File: Mathlib/Algebra/Ring/Subring/Basic.lean

tactic: simp [h]
state_before: R : Type u
S : Type v
T : Type w
inst✝² : Ring R
inst✝¹ : Ring S
inst✝ : Ring T
s : Set R
x✝ : R
h✝ : x✝ ∈ closure s
x : R
hx : x ∈ ↑(Submonoid.closure s)
l : List R
hl : ∀ y ∈ l, y ∈ s
h : l.prod = x
⊢ (∀ t ∈ [l], ∀ y ∈ t, y ∈ s ∨ y = -1) ∧ (List.map List.prod [l]).sum = x
state_after: R : Type u
S : Type v
T : Type w
inst✝² : Ring R
inst✝¹ : Ring S
inst✝ : Ring T
s : Set R
x✝ : R
h✝ : x✝ ∈ closure s
x : R
hx : x ∈ ↑(Submonoid.closure s)
l : List R
hl : ∀ y ∈ l, y ∈ s
h : l.prod = x
⊢ ∀ y ∈ l, y ∈ s ∨ y = -1

tactic: tauto
state_before: R : Type u
S : Type v
T : Type w
inst✝² : Ring R
inst✝¹ : Ring S
inst✝ : Ring T
s : Set R
x✝ : R
h✝ : x✝ ∈ closure s
x : R
hx : x ∈ ↑(Submonoid.closure s)
l : List R
hl : ∀ y ∈ l, y ∈ s
h : l.prod = x
⊢ ∀ y ∈ l, y ∈ s ∨ y = -1
state_after: no goals

tactic: simp
state_before: R : Type u
S : Type v
T : Type w
inst✝² : Ring R
inst✝¹ : Ring S
inst✝ : Ring T
s : Set R
x : R
h : x ∈ closure s
⊢ (∀ t ∈ [], ∀ y ∈ t, y ∈ s ∨ y = -1) ∧ (List.map List.prod []).sum = 0
state_after: no goals

tactic: simp [hl2, hm2]
state_before: R : Type u
S : Type v
T : Type w
inst✝² : Ring R
inst✝¹ : Ring S
inst✝ : Ring T
s : Set R
x✝² : R
h : x✝² ∈ closure s
x y : R
x✝¹ : (fun x => ∃ L, (∀ t ∈ L, ∀ y ∈ t, y ∈ s ∨ y = -1) ∧ (List.map List.prod L).sum = x) x
x✝ : (fun x => ∃ L, (∀ t ∈ L, ∀ y ∈ t, y ∈ s ∨ y = -1) ∧ (List.map List.prod L).sum = x) y
l : List (List R)
hl1 : ∀ t ∈ l, ∀ y ∈ t, y ∈ s ∨ y = -1
hl2 : (List.map List.prod l).sum = x
m : List (List R)
hm1 : ∀ t ∈ m, ∀ y ∈ t, y ∈ s ∨ y = -1
hm2 : (List.map List.prod m).sum = y
⊢ (List.map List.prod (l ++ m)).sum = x + y
state_after: no goals

tactic: simp
state_before: R : Type u
S : Type v
T : Type w
inst✝² : Ring R
inst✝¹ : Ring S
inst✝ : Ring T
s : Set R
x✝¹ : R
h : x✝¹ ∈ closure s
x : R
x✝ : (fun x => ∃ L, (∀ t ∈ L, ∀ y ∈ t, y ∈ s ∨ y = -1) ∧ (List.map List.prod L).sum = x) x
L : List (List R)
hL : (∀ t ∈ L, ∀ y ∈ t, y ∈ s ∨ y = -1) ∧ (List.map List.prod L).sum = x
⊢ (List.map List.prod (List.map (List.cons (-1)) [])).sum = -(List.map List.prod []).sum
state_after: no goals

tactic: simp (config := { contextual := true }) [List.map_cons, add_comm]
state_before: R : Type u
S : Type v
T : Type w
inst✝² : Ring R
inst✝¹ : Ring S
inst✝ : Ring T
s : Set R
x✝¹ : R
h : x✝¹ ∈ closure s
x : R
x✝ : (fun x => ∃ L, (∀ t ∈ L, ∀ y ∈ t, y ∈ s ∨ y = -1) ∧ (List.map List.prod L).sum = x) x
L : List (List R)
hL : (∀ t ∈ L, ∀ y ∈ t, y ∈ s ∨ y = -1) ∧ (List.map List.prod L).sum = x
⊢ ∀ (head : List R) (tail : List (List R)),
    (List.map List.prod (List.map (List.cons (-1)) tail)).sum = -(List.map List.prod tail).sum →
      (List.map List.prod (List.map (List.cons (-1)) (head :: tail))).sum = -(List.map List.prod (head :: tail)).sum
state_after: no goals
Theorem: Nat.prime_of_fac_equiv_neg_one
File: Mathlib/NumberTheory/Wilson.lean

tactic: rcases eq_or_ne n 0 with (rfl | h0)
state_before: n : ℕ
h : ↑(n - 1)! = -1
h1 : n ≠ 1
⊢ Prime n
state_after: case inl
h : ↑(0 - 1)! = -1
h1 : 0 ≠ 1
⊢ Prime 0

case inr
n : ℕ
h : ↑(n - 1)! = -1
h1 : n ≠ 1
h0 : n ≠ 0
⊢ Prime n

tactic: replace h1 : 1 < n := n.two_le_iff.mpr ⟨h0, h1⟩
state_before: case inr
n : ℕ
h : ↑(n - 1)! = -1
h1 : n ≠ 1
h0 : n ≠ 0
⊢ Prime n
state_after: case inr
n : ℕ
h : ↑(n - 1)! = -1
h0 : n ≠ 0
h1 : 1 < n
⊢ Prime n

tactic: by_contra h2
state_before: case inr
n : ℕ
h : ↑(n - 1)! = -1
h0 : n ≠ 0
h1 : 1 < n
⊢ Prime n
state_after: case inr
n : ℕ
h : ↑(n - 1)! = -1
h0 : n ≠ 0
h1 : 1 < n
h2 : ¬Prime n
⊢ False

tactic: obtain ⟨m, hm1, hm2 : 1 < m, hm3⟩ := exists_dvd_of_not_prime2 h1 h2
state_before: case inr
n : ℕ
h : ↑(n - 1)! = -1
h0 : n ≠ 0
h1 : 1 < n
h2 : ¬Prime n
⊢ False
state_after: case inr.intro.intro.intro
n : ℕ
h : ↑(n - 1)! = -1
h0 : n ≠ 0
h1 : 1 < n
h2 : ¬Prime n
m : ℕ
hm1 : m ∣ n
hm2 : 1 < m
hm3 : m < n
⊢ False

tactic: have hm : m ∣ (n - 1)! := Nat.dvd_factorial (pos_of_gt hm2) (le_pred_of_lt hm3)
state_before: case inr.intro.intro.intro
n : ℕ
h : ↑(n - 1)! = -1
h0 : n ≠ 0
h1 : 1 < n
h2 : ¬Prime n
m : ℕ
hm1 : m ∣ n
hm2 : 1 < m
hm3 : m < n
⊢ False
state_after: case inr.intro.intro.intro
n : ℕ
h : ↑(n - 1)! = -1
h0 : n ≠ 0
h1 : 1 < n
h2 : ¬Prime n
m : ℕ
hm1 : m ∣ n
hm2 : 1 < m
hm3 : m < n
hm : m ∣ (n - 1)!
⊢ False

tactic: refine hm2.ne' (Nat.dvd_one.mp ((Nat.dvd_add_right hm).mp (hm1.trans ?_)))
state_before: case inr.intro.intro.intro
n : ℕ
h : ↑(n - 1)! = -1
h0 : n ≠ 0
h1 : 1 < n
h2 : ¬Prime n
m : ℕ
hm1 : m ∣ n
hm2 : 1 < m
hm3 : m < n
hm : m ∣ (n - 1)!
⊢ False
state_after: case inr.intro.intro.intro
n : ℕ
h : ↑(n - 1)! = -1
h0 : n ≠ 0
h1 : 1 < n
h2 : ¬Prime n
m : ℕ
hm1 : m ∣ n
hm2 : 1 < m
hm3 : m < n
hm : m ∣ (n - 1)!
⊢ n ∣ (n - 1)! + 1

tactic: rw [← ZMod.natCast_zmod_eq_zero_iff_dvd, cast_add, cast_one, h, add_left_neg]
state_before: case inr.intro.intro.intro
n : ℕ
h : ↑(n - 1)! = -1
h0 : n ≠ 0
h1 : 1 < n
h2 : ¬Prime n
m : ℕ
hm1 : m ∣ n
hm2 : 1 < m
hm3 : m < n
hm : m ∣ (n - 1)!
⊢ n ∣ (n - 1)! + 1
state_after: no goals

tactic: norm_num at h
state_before: case inl
h : ↑(0 - 1)! = -1
h1 : 0 ≠ 1
⊢ Prime 0
state_after: no goals
Theorem: CategoryTheory.coyonedaEquiv_comp
File: Mathlib/CategoryTheory/Yoneda.lean

tactic: rfl
state_before: C : Type u₁
inst✝ : Category.{v₁, u₁} C
X : C
F G : C ⥤ Type v₁
α : coyoneda.obj { unop := X } ⟶ F
β : F ⟶ G
⊢ coyonedaEquiv (α ≫ β) = β.app X (coyonedaEquiv α)
state_after: no goals
Theorem: CategoryTheory.shiftZero'
File: Mathlib/CategoryTheory/Shift/Basic.lean

tactic: symm
state_before: C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
X Y : C
f : X ⟶ Y
⊢ (shiftFunctor C 0).map f = (shiftZero A X).hom ≫ f ≫ (shiftZero A Y).inv
state_after: C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
X Y : C
f : X ⟶ Y
⊢ (shiftZero A X).hom ≫ f ≫ (shiftZero A Y).inv = (shiftFunctor C 0).map f

tactic: rw [NatIso.app_inv, NatIso.app_hom]
state_before: C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
X Y : C
f : X ⟶ Y
⊢ (shiftZero A X).hom ≫ f ≫ (shiftZero A Y).inv = (shiftFunctor C 0).map f
state_after: C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
X Y : C
f : X ⟶ Y
⊢ (shiftFunctorZero C A).hom.app X ≫ f ≫ (shiftFunctorZero C A).inv.app Y = (shiftFunctor C 0).map f

tactic: apply NatIso.naturality_2
state_before: C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
X Y : C
f : X ⟶ Y
⊢ (shiftFunctorZero C A).hom.app X ≫ f ≫ (shiftFunctorZero C A).inv.app Y = (shiftFunctor C 0).map f
state_after: no goals
Theorem: Fin.predAbove_castSucc_of_le
File: Mathlib/Data/Fin/Basic.lean

tactic: rw [predAbove_of_le_castSucc _ _ (castSucc_le_castSucc_iff.mpr h), castPred_castSucc]
state_before: n m : ℕ
p i : Fin n
h : i ≤ p
⊢ p.predAbove i.castSucc = i
state_after: no goals
Theorem: Nat.descFactorial_eq_div
File: Mathlib/Data/Nat/Factorial/Basic.lean

tactic: apply Nat.mul_left_cancel (n - k).factorial_pos
state_before: n k : ℕ
h : k ≤ n
⊢ n.descFactorial k = n ! / (n - k)!
state_after: n k : ℕ
h : k ≤ n
⊢ (n - k)! * n.descFactorial k = (n - k)! * (n ! / (n - k)!)

tactic: rw [factorial_mul_descFactorial h]
state_before: n k : ℕ
h : k ≤ n
⊢ (n - k)! * n.descFactorial k = (n - k)! * (n ! / (n - k)!)
state_after: n k : ℕ
h : k ≤ n
⊢ n ! = (n - k)! * (n ! / (n - k)!)

tactic: exact (Nat.mul_div_cancel' <| factorial_dvd_factorial <| Nat.sub_le n k).symm
state_before: n k : ℕ
h : k ≤ n
⊢ n ! = (n - k)! * (n ! / (n - k)!)
state_after: no goals
Theorem: FractionalIdeal.coeToSubmodule_eq_bot
File: Mathlib/RingTheory/FractionalIdeal/Basic.lean

tactic: simp [h]
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
I : FractionalIdeal S P
h : ↑I = ⊥
⊢ (fun I => ↑I) I = (fun I => ↑I) 0
state_after: no goals

tactic: simp [h]
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
I : FractionalIdeal S P
h : I = 0
⊢ ↑I = ⊥
state_after: no goals
Theorem: Submodule.le_span_singleton_iff
File: Mathlib/LinearAlgebra/Span.lean

tactic: simp_rw [SetLike.le_def, mem_span_singleton]
state_before: R : Type u_1
R₂ : Type u_2
K : Type u_3
M : Type u_4
M₂ : Type u_5
V : Type u_6
S : Type u_7
inst✝⁷ : Semiring R
inst✝⁶ : AddCommMonoid M
inst✝⁵ : Module R M
x : M
p p' : Submodule R M
inst✝⁴ : Semiring R₂
σ₁₂ : R →+* R₂
inst✝³ : AddCommMonoid M₂
inst✝² : Module R₂ M₂
F : Type u_8
inst✝¹ : FunLike F M M₂
inst✝ : SemilinearMapClass F σ₁₂ M M₂
s✝ t : Set M
s : Submodule R M
v₀ : M
⊢ s ≤ span R {v₀} ↔ ∀ v ∈ s, ∃ r, r • v₀ = v
state_after: no goals
Theorem: ContDiffAt.iteratedFDeriv_right
File: Mathlib/Analysis/Calculus/ContDiff/Basic.lean

tactic: rw [← iteratedFDerivWithin_univ, ← contDiffWithinAt_univ] at *
state_before: 𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
b : E × F → G
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
i : ℕ
hf : ContDiffAt 𝕜 n f x₀
hmn : m + ↑i ≤ n
⊢ ContDiffAt 𝕜 m (iteratedFDeriv 𝕜 i f) x₀
state_after: 𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
b : E × F → G
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
i : ℕ
hf : ContDiffWithinAt 𝕜 n f univ x₀
hmn : m + ↑i ≤ n
⊢ ContDiffWithinAt 𝕜 m (iteratedFDerivWithin 𝕜 i f univ) univ x₀

tactic: exact hf.iteratedFderivWithin_right uniqueDiffOn_univ hmn trivial
state_before: 𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
b : E × F → G
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
i : ℕ
hf : ContDiffWithinAt 𝕜 n f univ x₀
hmn : m + ↑i ≤ n
⊢ ContDiffWithinAt 𝕜 m (iteratedFDerivWithin 𝕜 i f univ) univ x₀
state_after: no goals
Theorem: HolorIndex.drop_drop
File: Mathlib/Data/Holor.lean

tactic: simp [add_comm, assocRight, drop, cast_type, List.drop_drop]
state_before: ds₁ ds₂ ds₃ is : List ℕ
h : Forall₂ (fun x x_1 => x < x_1) is (ds₁ ++ ds₂ ++ ds₃)
⊢ ↑(assocRight ⟨is, h⟩).drop.drop = ↑(drop ⟨is, h⟩)
state_after: no goals
Theorem: PowerSeries.coeff_sin_bit0
File: Mathlib/RingTheory/PowerSeries/WellKnown.lean

tactic: rw [sin, coeff_mk, if_pos (even_bit0 n)]
state_before: A : Type u_1
A' : Type u_2
inst✝⁷ : Ring A
inst✝⁶ : Ring A'
inst✝⁵ : Algebra ℚ A
inst✝⁴ : Algebra ℚ A'
inst✝³ : Ring A
inst✝² : Ring A'
inst✝¹ : Algebra ℚ A
inst✝ : Algebra ℚ A'
n : ℕ
f : A →+* A'
⊢ (coeff A (bit0 n)) (sin A) = 0
state_after: no goals
Theorem: CategoryTheory.ShortComplex.LeftHomologyData.π_comp_homologyIso_inv
File: Mathlib/Algebra/Homology/ShortComplex/Homology.lean

tactic: dsimp only [homologyπ, homologyIso]
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
A : C
inst✝¹ : S.HasHomology
h : S.LeftHomologyData
inst✝ : S.HasHomology
⊢ h.π ≫ h.homologyIso.inv = h.cyclesIso.inv ≫ S.homologyπ
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
A : C
inst✝¹ : S.HasHomology
h : S.LeftHomologyData
inst✝ : S.HasHomology
⊢ h.π ≫ (S.leftHomologyIso.symm ≪≫ h.leftHomologyIso).inv = h.cyclesIso.inv ≫ S.leftHomologyπ ≫ S.leftHomologyIso.hom

tactic: simp only [Iso.trans_inv, Iso.symm_inv, π_comp_leftHomologyIso_inv_assoc]
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
A : C
inst✝¹ : S.HasHomology
h : S.LeftHomologyData
inst✝ : S.HasHomology
⊢ h.π ≫ (S.leftHomologyIso.symm ≪≫ h.leftHomologyIso).inv = h.cyclesIso.inv ≫ S.leftHomologyπ ≫ S.leftHomologyIso.hom
state_after: no goals
Theorem: CategoryTheory.Presieve.isSeparatedFor_top
File: Mathlib/CategoryTheory/Sites/IsSheafFor.lean

tactic: have q₁ := h₁ (𝟙 X) (by tauto)
state_before: C : Type u₁
inst✝ : Category.{v₁, u₁} C
P✝ Q U : Cᵒᵖ ⥤ Type w
X Y : C
S : Sieve X
R : Presieve X
P : Cᵒᵖ ⥤ Type w
x : FamilyOfElements P ⊤
t₁ t₂ : P.obj { unop := X }
h₁ : x.IsAmalgamation t₁
h₂ : x.IsAmalgamation t₂
⊢ t₁ = t₂
state_after: C : Type u₁
inst✝ : Category.{v₁, u₁} C
P✝ Q U : Cᵒᵖ ⥤ Type w
X Y : C
S : Sieve X
R : Presieve X
P : Cᵒᵖ ⥤ Type w
x : FamilyOfElements P ⊤
t₁ t₂ : P.obj { unop := X }
h₁ : x.IsAmalgamation t₁
h₂ : x.IsAmalgamation t₂
q₁ : P.map (𝟙 X).op t₁ = x (𝟙 X) trivial
⊢ t₁ = t₂

tactic: have q₂ := h₂ (𝟙 X) (by tauto)
state_before: C : Type u₁
inst✝ : Category.{v₁, u₁} C
P✝ Q U : Cᵒᵖ ⥤ Type w
X Y : C
S : Sieve X
R : Presieve X
P : Cᵒᵖ ⥤ Type w
x : FamilyOfElements P ⊤
t₁ t₂ : P.obj { unop := X }
h₁ : x.IsAmalgamation t₁
h₂ : x.IsAmalgamation t₂
q₁ : P.map (𝟙 X).op t₁ = x (𝟙 X) trivial
⊢ t₁ = t₂
state_after: C : Type u₁
inst✝ : Category.{v₁, u₁} C
P✝ Q U : Cᵒᵖ ⥤ Type w
X Y : C
S : Sieve X
R : Presieve X
P : Cᵒᵖ ⥤ Type w
x : FamilyOfElements P ⊤
t₁ t₂ : P.obj { unop := X }
h₁ : x.IsAmalgamation t₁
h₂ : x.IsAmalgamation t₂
q₁ : P.map (𝟙 X).op t₁ = x (𝟙 X) trivial
q₂ : P.map (𝟙 X).op t₂ = x (𝟙 X) trivial
⊢ t₁ = t₂

tactic: simp only [op_id, FunctorToTypes.map_id_apply] at q₁ q₂
state_before: C : Type u₁
inst✝ : Category.{v₁, u₁} C
P✝ Q U : Cᵒᵖ ⥤ Type w
X Y : C
S : Sieve X
R : Presieve X
P : Cᵒᵖ ⥤ Type w
x : FamilyOfElements P ⊤
t₁ t₂ : P.obj { unop := X }
h₁ : x.IsAmalgamation t₁
h₂ : x.IsAmalgamation t₂
q₁ : P.map (𝟙 X).op t₁ = x (𝟙 X) trivial
q₂ : P.map (𝟙 X).op t₂ = x (𝟙 X) trivial
⊢ t₁ = t₂
state_after: C : Type u₁
inst✝ : Category.{v₁, u₁} C
P✝ Q U : Cᵒᵖ ⥤ Type w
X Y : C
S : Sieve X
R : Presieve X
P : Cᵒᵖ ⥤ Type w
x : FamilyOfElements P ⊤
t₁ t₂ : P.obj { unop := X }
h₁ : x.IsAmalgamation t₁
h₂ : x.IsAmalgamation t₂
q₁ : t₁ = x (𝟙 X) trivial
q₂ : t₂ = x (𝟙 X) trivial
⊢ t₁ = t₂

tactic: rw [q₁, q₂]
state_before: C : Type u₁
inst✝ : Category.{v₁, u₁} C
P✝ Q U : Cᵒᵖ ⥤ Type w
X Y : C
S : Sieve X
R : Presieve X
P : Cᵒᵖ ⥤ Type w
x : FamilyOfElements P ⊤
t₁ t₂ : P.obj { unop := X }
h₁ : x.IsAmalgamation t₁
h₂ : x.IsAmalgamation t₂
q₁ : t₁ = x (𝟙 X) trivial
q₂ : t₂ = x (𝟙 X) trivial
⊢ t₁ = t₂
state_after: no goals

tactic: tauto
state_before: C : Type u₁
inst✝ : Category.{v₁, u₁} C
P✝ Q U : Cᵒᵖ ⥤ Type w
X Y : C
S : Sieve X
R : Presieve X
P : Cᵒᵖ ⥤ Type w
x : FamilyOfElements P ⊤
t₁ t₂ : P.obj { unop := X }
h₁ : x.IsAmalgamation t₁
h₂ : x.IsAmalgamation t₂
⊢ ⊤ (𝟙 X)
state_after: no goals

tactic: tauto
state_before: C : Type u₁
inst✝ : Category.{v₁, u₁} C
P✝ Q U : Cᵒᵖ ⥤ Type w
X Y : C
S : Sieve X
R : Presieve X
P : Cᵒᵖ ⥤ Type w
x : FamilyOfElements P ⊤
t₁ t₂ : P.obj { unop := X }
h₁ : x.IsAmalgamation t₁
h₂ : x.IsAmalgamation t₂
q₁ : P.map (𝟙 X).op t₁ = x (𝟙 X) trivial
⊢ ⊤ (𝟙 X)
state_after: no goals
Theorem: Finset.biUnion_insert
File: Mathlib/Data/Finset/Union.lean

tactic: simp only [mem_biUnion, exists_prop, mem_union, mem_insert, or_and_right, exists_or,
  exists_eq_left]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
s s₁ s₂ : Finset α
t t₁ t₂ : α → Finset β
inst✝¹ : DecidableEq β
inst✝ : DecidableEq α
a : α
x : β
⊢ x ∈ (insert a s).biUnion t ↔ x ∈ t a ∪ s.biUnion t
state_after: no goals
Theorem: Set.insert_diff_of_not_mem
File: Mathlib/Data/Set/Basic.lean

tactic: ext x
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s✝ s₁ s₂ t t₁ t₂ u s : Set α
h : a ∉ t
⊢ insert a s \ t = insert a (s \ t)
state_after: case h
α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s✝ s₁ s₂ t t₁ t₂ u s : Set α
h : a ∉ t
x : α
⊢ x ∈ insert a s \ t ↔ x ∈ insert a (s \ t)

tactic: by_cases h' : x ∈ t
state_before: case h
α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s✝ s₁ s₂ t t₁ t₂ u s : Set α
h : a ∉ t
x : α
⊢ x ∈ insert a s \ t ↔ x ∈ insert a (s \ t)
state_after: case pos
α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s✝ s₁ s₂ t t₁ t₂ u s : Set α
h : a ∉ t
x : α
h' : x ∈ t
⊢ x ∈ insert a s \ t ↔ x ∈ insert a (s \ t)

case neg
α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s✝ s₁ s₂ t t₁ t₂ u s : Set α
h : a ∉ t
x : α
h' : x ∉ t
⊢ x ∈ insert a s \ t ↔ x ∈ insert a (s \ t)

tactic: have : x ≠ a := by
  intro H
  rw [H] at h'
  exact h h'
state_before: case pos
α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s✝ s₁ s₂ t t₁ t₂ u s : Set α
h : a ∉ t
x : α
h' : x ∈ t
⊢ x ∈ insert a s \ t ↔ x ∈ insert a (s \ t)
state_after: case pos
α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s✝ s₁ s₂ t t₁ t₂ u s : Set α
h : a ∉ t
x : α
h' : x ∈ t
this : x ≠ a
⊢ x ∈ insert a s \ t ↔ x ∈ insert a (s \ t)

tactic: simp [h, h', this]
state_before: case pos
α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s✝ s₁ s₂ t t₁ t₂ u s : Set α
h : a ∉ t
x : α
h' : x ∈ t
this : x ≠ a
⊢ x ∈ insert a s \ t ↔ x ∈ insert a (s \ t)
state_after: no goals

tactic: intro H
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s✝ s₁ s₂ t t₁ t₂ u s : Set α
h : a ∉ t
x : α
h' : x ∈ t
⊢ x ≠ a
state_after: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s✝ s₁ s₂ t t₁ t₂ u s : Set α
h : a ∉ t
x : α
h' : x ∈ t
H : x = a
⊢ False

tactic: rw [H] at h'
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s✝ s₁ s₂ t t₁ t₂ u s : Set α
h : a ∉ t
x : α
h' : x ∈ t
H : x = a
⊢ False
state_after: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s✝ s₁ s₂ t t₁ t₂ u s : Set α
h : a ∉ t
x : α
h' : a ∈ t
H : x = a
⊢ False

tactic: exact h h'
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s✝ s₁ s₂ t t₁ t₂ u s : Set α
h : a ∉ t
x : α
h' : a ∈ t
H : x = a
⊢ False
state_after: no goals

tactic: simp [h, h']
state_before: case neg
α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s✝ s₁ s₂ t t₁ t₂ u s : Set α
h : a ∉ t
x : α
h' : x ∉ t
⊢ x ∈ insert a s \ t ↔ x ∈ insert a (s \ t)
state_after: no goals
Theorem: Polynomial.dickson_two_zero
File: Mathlib/RingTheory/Polynomial/Dickson.lean

tactic: simp only [dickson_zero, pow_zero]
state_before: R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
k : ℕ
a : R
⊢ dickson 2 0 0 = X ^ 0
state_after: R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
k : ℕ
a : R
⊢ 3 - ↑2 = 1

tactic: norm_num
state_before: R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
k : ℕ
a : R
⊢ 3 - ↑2 = 1
state_after: no goals

tactic: simp only [dickson_one, pow_one]
state_before: R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
k : ℕ
a : R
⊢ dickson 2 0 1 = X ^ 1
state_after: no goals

tactic: simp only [dickson_add_two, C_0, zero_mul, sub_zero]
state_before: R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
k : ℕ
a : R
n : ℕ
⊢ dickson 2 0 (n + 2) = X ^ (n + 2)
state_after: R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
k : ℕ
a : R
n : ℕ
⊢ X * dickson 2 0 (n + 1) = X ^ (n + 2)

tactic: rw [dickson_two_zero (n + 1), pow_add X (n + 1) 1, mul_comm, pow_one]
state_before: R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
k : ℕ
a : R
n : ℕ
⊢ X * dickson 2 0 (n + 1) = X ^ (n + 2)
state_after: no goals
Theorem: MeasureTheory.AEEqFun.inf_le_right
File: Mathlib/MeasureTheory/Function/AEEqFun.lean

tactic: rw [← coeFn_le]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁵ : MeasurableSpace α
μ ν : Measure α
inst✝⁴ : TopologicalSpace β
inst✝³ : TopologicalSpace γ
inst✝² : TopologicalSpace δ
inst✝¹ : SemilatticeInf β
inst✝ : ContinuousInf β
f g : α →ₘ[μ] β
⊢ f ⊓ g ≤ g
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁵ : MeasurableSpace α
μ ν : Measure α
inst✝⁴ : TopologicalSpace β
inst✝³ : TopologicalSpace γ
inst✝² : TopologicalSpace δ
inst✝¹ : SemilatticeInf β
inst✝ : ContinuousInf β
f g : α →ₘ[μ] β
⊢ ↑(f ⊓ g) ≤ᶠ[ae μ] ↑g

tactic: filter_upwards [coeFn_inf f g] with _ ha
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁵ : MeasurableSpace α
μ ν : Measure α
inst✝⁴ : TopologicalSpace β
inst✝³ : TopologicalSpace γ
inst✝² : TopologicalSpace δ
inst✝¹ : SemilatticeInf β
inst✝ : ContinuousInf β
f g : α →ₘ[μ] β
⊢ ↑(f ⊓ g) ≤ᶠ[ae μ] ↑g
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁵ : MeasurableSpace α
μ ν : Measure α
inst✝⁴ : TopologicalSpace β
inst✝³ : TopologicalSpace γ
inst✝² : TopologicalSpace δ
inst✝¹ : SemilatticeInf β
inst✝ : ContinuousInf β
f g : α →ₘ[μ] β
a✝ : α
ha : ↑(f ⊓ g) a✝ = ↑f a✝ ⊓ ↑g a✝
⊢ ↑(f ⊓ g) a✝ ≤ ↑g a✝

tactic: rw [ha]
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁵ : MeasurableSpace α
μ ν : Measure α
inst✝⁴ : TopologicalSpace β
inst✝³ : TopologicalSpace γ
inst✝² : TopologicalSpace δ
inst✝¹ : SemilatticeInf β
inst✝ : ContinuousInf β
f g : α →ₘ[μ] β
a✝ : α
ha : ↑(f ⊓ g) a✝ = ↑f a✝ ⊓ ↑g a✝
⊢ ↑(f ⊓ g) a✝ ≤ ↑g a✝
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁵ : MeasurableSpace α
μ ν : Measure α
inst✝⁴ : TopologicalSpace β
inst✝³ : TopologicalSpace γ
inst✝² : TopologicalSpace δ
inst✝¹ : SemilatticeInf β
inst✝ : ContinuousInf β
f g : α →ₘ[μ] β
a✝ : α
ha : ↑(f ⊓ g) a✝ = ↑f a✝ ⊓ ↑g a✝
⊢ ↑f a✝ ⊓ ↑g a✝ ≤ ↑g a✝

tactic: exact inf_le_right
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁵ : MeasurableSpace α
μ ν : Measure α
inst✝⁴ : TopologicalSpace β
inst✝³ : TopologicalSpace γ
inst✝² : TopologicalSpace δ
inst✝¹ : SemilatticeInf β
inst✝ : ContinuousInf β
f g : α →ₘ[μ] β
a✝ : α
ha : ↑(f ⊓ g) a✝ = ↑f a✝ ⊓ ↑g a✝
⊢ ↑f a✝ ⊓ ↑g a✝ ≤ ↑g a✝
state_after: no goals