1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Ideal.toIdeal_homogeneousHull_eq_iSup
File: Mathlib/RingTheory/GradedAlgebra/HomogeneousIdeal.lean

tactic: rw [← Ideal.span_iUnion]
state_before: ι : Type u_1
σ : Type u_2
R : Type u_3
A : Type u_4
inst✝⁵ : Semiring A
inst✝⁴ : DecidableEq ι
inst✝³ : AddMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
I : Ideal A
⊢ (homogeneousHull 𝒜 I).toIdeal = ⨆ i, span (⇑(GradedRing.proj 𝒜 i) '' ↑I)
state_after: ι : Type u_1
σ : Type u_2
R : Type u_3
A : Type u_4
inst✝⁵ : Semiring A
inst✝⁴ : DecidableEq ι
inst✝³ : AddMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
I : Ideal A
⊢ (homogeneousHull 𝒜 I).toIdeal = span (⋃ i, ⇑(GradedRing.proj 𝒜 i) '' ↑I)

tactic: apply congr_arg Ideal.span _
state_before: ι : Type u_1
σ : Type u_2
R : Type u_3
A : Type u_4
inst✝⁵ : Semiring A
inst✝⁴ : DecidableEq ι
inst✝³ : AddMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
I : Ideal A
⊢ (homogeneousHull 𝒜 I).toIdeal = span (⋃ i, ⇑(GradedRing.proj 𝒜 i) '' ↑I)
state_after: ι : Type u_1
σ : Type u_2
R : Type u_3
A : Type u_4
inst✝⁵ : Semiring A
inst✝⁴ : DecidableEq ι
inst✝³ : AddMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
I : Ideal A
⊢ {r | ∃ i x, ↑(((decompose 𝒜) ↑x) i) = r} = ⋃ i, ⇑(GradedRing.proj 𝒜 i) '' ↑I

tactic: ext1
state_before: ι : Type u_1
σ : Type u_2
R : Type u_3
A : Type u_4
inst✝⁵ : Semiring A
inst✝⁴ : DecidableEq ι
inst✝³ : AddMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
I : Ideal A
⊢ {r | ∃ i x, ↑(((decompose 𝒜) ↑x) i) = r} = ⋃ i, ⇑(GradedRing.proj 𝒜 i) '' ↑I
state_after: case h
ι : Type u_1
σ : Type u_2
R : Type u_3
A : Type u_4
inst✝⁵ : Semiring A
inst✝⁴ : DecidableEq ι
inst✝³ : AddMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
I : Ideal A
x✝ : A
⊢ x✝ ∈ {r | ∃ i x, ↑(((decompose 𝒜) ↑x) i) = r} ↔ x✝ ∈ ⋃ i, ⇑(GradedRing.proj 𝒜 i) '' ↑I

tactic: simp only [Set.mem_iUnion, Set.mem_image, mem_setOf_eq, GradedRing.proj_apply, SetLike.exists,
  exists_prop, Subtype.coe_mk, SetLike.mem_coe]
state_before: case h
ι : Type u_1
σ : Type u_2
R : Type u_3
A : Type u_4
inst✝⁵ : Semiring A
inst✝⁴ : DecidableEq ι
inst✝³ : AddMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
I : Ideal A
x✝ : A
⊢ x✝ ∈ {r | ∃ i x, ↑(((decompose 𝒜) ↑x) i) = r} ↔ x✝ ∈ ⋃ i, ⇑(GradedRing.proj 𝒜 i) '' ↑I
state_after: no goals
Theorem: Real.rpow_mul_intCast
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

tactic: rw [rpow_mul hx, rpow_intCast]
state_before: x y✝ z : ℝ
n✝ : ℕ
hx : 0 ≤ x
y : ℝ
n : ℤ
⊢ x ^ (y * ↑n) = (x ^ y) ^ n
state_after: no goals
Theorem: ENNReal.one_le_rpow
File: Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean

tactic: cases x
state_before: x : ℝ≥0∞
z : ℝ
hx : 1 ≤ x
hz : 0 < z
⊢ 1 ≤ x ^ z
state_after: case top
z : ℝ
hz : 0 < z
hx : 1 ≤ ⊤
⊢ 1 ≤ ⊤ ^ z

case coe
z : ℝ
hz : 0 < z
x✝ : ℝ≥0
hx : 1 ≤ ↑x✝
⊢ 1 ≤ ↑x✝ ^ z

tactic: simp [top_rpow_of_pos hz]
state_before: case top
z : ℝ
hz : 0 < z
hx : 1 ≤ ⊤
⊢ 1 ≤ ⊤ ^ z
state_after: no goals

tactic: simp only [one_le_coe_iff, some_eq_coe] at hx
state_before: case coe
z : ℝ
hz : 0 < z
x✝ : ℝ≥0
hx : 1 ≤ ↑x✝
⊢ 1 ≤ ↑x✝ ^ z
state_after: case coe
z : ℝ
hz : 0 < z
x✝ : ℝ≥0
hx : 1 ≤ x✝
⊢ 1 ≤ ↑x✝ ^ z

tactic: simp [coe_rpow_of_nonneg _ (le_of_lt hz), NNReal.one_le_rpow hx (le_of_lt hz)]
state_before: case coe
z : ℝ
hz : 0 < z
x✝ : ℝ≥0
hx : 1 ≤ x✝
⊢ 1 ≤ ↑x✝ ^ z
state_after: no goals
Theorem: Ideal.mem_leadingCoeffNth_zero
File: Mathlib/RingTheory/Polynomial/Basic.lean

tactic: rwa [← hpx, Polynomial.leadingCoeff,
  Nat.eq_zero_of_le_zero (natDegree_le_of_degree_le hpdeg), ← eq_C_of_degree_le_zero hpdeg]
state_before: R : Type u
S : Type u_1
inst✝¹ : CommSemiring R
inst✝ : Semiring S
I : Ideal R[X]
x : R
x✝ : ∃ p ∈ I, p.degree ≤ ↑0 ∧ p.leadingCoeff = x
p : R[X]
hpI : p ∈ I
hpdeg : p.degree ≤ ↑0
hpx : p.leadingCoeff = x
⊢ C x ∈ I
state_after: no goals
Theorem: TopologicalSpace.Closeds.iInf_def
File: Mathlib/Topology/Sets/Closeds.lean

tactic: ext1
state_before: ι✝ : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
ι : Sort u_4
s : ι → Closeds α
⊢ ⨅ i, s i = { carrier := ⋂ i, ↑(s i), closed' := ⋯ }
state_after: case h
ι✝ : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
ι : Sort u_4
s : ι → Closeds α
⊢ ↑(⨅ i, s i) = ↑{ carrier := ⋂ i, ↑(s i), closed' := ⋯ }

tactic: simp
state_before: case h
ι✝ : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
ι : Sort u_4
s : ι → Closeds α
⊢ ↑(⨅ i, s i) = ↑{ carrier := ⋂ i, ↑(s i), closed' := ⋯ }
state_after: no goals
Theorem: ascPochhammer_ne_zero_eval_zero
File: Mathlib/RingTheory/Polynomial/Pochhammer.lean

tactic: simp [ascPochhammer_eval_zero, h]
state_before: S : Type u
inst✝ : Semiring S
n : ℕ
h : n ≠ 0
⊢ eval 0 (ascPochhammer S n) = 0
state_after: no goals
Theorem: IsPreconnected.iUnion_of_reflTransGen
File: Mathlib/Topology/Connected/Basic.lean

tactic: rw [← biUnion_univ]
state_before: α : Type u
β : Type v
ι✝ : Type u_1
π : ι✝ → Type u_2
inst✝ : TopologicalSpace α
s✝ t u v : Set α
ι : Type u_3
s : ι → Set α
H : ∀ (i : ι), IsPreconnected (s i)
K : ∀ (i j : ι), ReflTransGen (fun i j => (s i ∩ s j).Nonempty) i j
⊢ IsPreconnected (⋃ n, s n)
state_after: α : Type u
β : Type v
ι✝ : Type u_1
π : ι✝ → Type u_2
inst✝ : TopologicalSpace α
s✝ t u v : Set α
ι : Type u_3
s : ι → Set α
H : ∀ (i : ι), IsPreconnected (s i)
K : ∀ (i j : ι), ReflTransGen (fun i j => (s i ∩ s j).Nonempty) i j
⊢ IsPreconnected (⋃ x ∈ univ, s x)

tactic: exact IsPreconnected.biUnion_of_reflTransGen (fun i _ => H i) fun i _ j _ => by
  simpa [mem_univ] using K i j
state_before: α : Type u
β : Type v
ι✝ : Type u_1
π : ι✝ → Type u_2
inst✝ : TopologicalSpace α
s✝ t u v : Set α
ι : Type u_3
s : ι → Set α
H : ∀ (i : ι), IsPreconnected (s i)
K : ∀ (i j : ι), ReflTransGen (fun i j => (s i ∩ s j).Nonempty) i j
⊢ IsPreconnected (⋃ x ∈ univ, s x)
state_after: no goals

tactic: simpa [mem_univ] using K i j
state_before: α : Type u
β : Type v
ι✝ : Type u_1
π : ι✝ → Type u_2
inst✝ : TopologicalSpace α
s✝ t u v : Set α
ι : Type u_3
s : ι → Set α
H : ∀ (i : ι), IsPreconnected (s i)
K : ∀ (i j : ι), ReflTransGen (fun i j => (s i ∩ s j).Nonempty) i j
i : ι
x✝¹ : i ∈ univ
j : ι
x✝ : j ∈ univ
⊢ ReflTransGen (fun i j => (s i ∩ s j).Nonempty ∧ i ∈ univ) i j
state_after: no goals
Theorem: dist_le_of_le_geometric_of_tendsto
File: Mathlib/Analysis/SpecificLimits/Basic.lean

tactic: have := aux_hasSum_of_le_geometric hr hu
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : PseudoMetricSpace α
r C : ℝ
hr : r < 1
f : ℕ → α
hu : ∀ (n : ℕ), dist (f n) (f (n + 1)) ≤ C * r ^ n
a : α
ha : Tendsto f atTop (𝓝 a)
n : ℕ
⊢ dist (f n) a ≤ C * r ^ n / (1 - r)
state_after: α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : PseudoMetricSpace α
r C : ℝ
hr : r < 1
f : ℕ → α
hu : ∀ (n : ℕ), dist (f n) (f (n + 1)) ≤ C * r ^ n
a : α
ha : Tendsto f atTop (𝓝 a)
n : ℕ
this : HasSum (fun n => C * r ^ n) (C / (1 - r))
⊢ dist (f n) a ≤ C * r ^ n / (1 - r)

tactic: convert dist_le_tsum_of_dist_le_of_tendsto _ hu ⟨_, this⟩ ha n
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : PseudoMetricSpace α
r C : ℝ
hr : r < 1
f : ℕ → α
hu : ∀ (n : ℕ), dist (f n) (f (n + 1)) ≤ C * r ^ n
a : α
ha : Tendsto f atTop (𝓝 a)
n : ℕ
this : HasSum (fun n => C * r ^ n) (C / (1 - r))
⊢ dist (f n) a ≤ C * r ^ n / (1 - r)
state_after: case h.e'_4
α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : PseudoMetricSpace α
r C : ℝ
hr : r < 1
f : ℕ → α
hu : ∀ (n : ℕ), dist (f n) (f (n + 1)) ≤ C * r ^ n
a : α
ha : Tendsto f atTop (𝓝 a)
n : ℕ
this : HasSum (fun n => C * r ^ n) (C / (1 - r))
⊢ C * r ^ n / (1 - r) = ∑' (m : ℕ), C * r ^ (n + m)

tactic: simp only [pow_add, mul_left_comm C, mul_div_right_comm]
state_before: case h.e'_4
α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : PseudoMetricSpace α
r C : ℝ
hr : r < 1
f : ℕ → α
hu : ∀ (n : ℕ), dist (f n) (f (n + 1)) ≤ C * r ^ n
a : α
ha : Tendsto f atTop (𝓝 a)
n : ℕ
this : HasSum (fun n => C * r ^ n) (C / (1 - r))
⊢ C * r ^ n / (1 - r) = ∑' (m : ℕ), C * r ^ (n + m)
state_after: case h.e'_4
α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : PseudoMetricSpace α
r C : ℝ
hr : r < 1
f : ℕ → α
hu : ∀ (n : ℕ), dist (f n) (f (n + 1)) ≤ C * r ^ n
a : α
ha : Tendsto f atTop (𝓝 a)
n : ℕ
this : HasSum (fun n => C * r ^ n) (C / (1 - r))
⊢ C / (1 - r) * r ^ n = ∑' (m : ℕ), r ^ n * (C * r ^ m)

tactic: rw [mul_comm]
state_before: case h.e'_4
α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : PseudoMetricSpace α
r C : ℝ
hr : r < 1
f : ℕ → α
hu : ∀ (n : ℕ), dist (f n) (f (n + 1)) ≤ C * r ^ n
a : α
ha : Tendsto f atTop (𝓝 a)
n : ℕ
this : HasSum (fun n => C * r ^ n) (C / (1 - r))
⊢ C / (1 - r) * r ^ n = ∑' (m : ℕ), r ^ n * (C * r ^ m)
state_after: case h.e'_4
α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : PseudoMetricSpace α
r C : ℝ
hr : r < 1
f : ℕ → α
hu : ∀ (n : ℕ), dist (f n) (f (n + 1)) ≤ C * r ^ n
a : α
ha : Tendsto f atTop (𝓝 a)
n : ℕ
this : HasSum (fun n => C * r ^ n) (C / (1 - r))
⊢ r ^ n * (C / (1 - r)) = ∑' (m : ℕ), r ^ n * (C * r ^ m)

tactic: exact (this.mul_left _).tsum_eq.symm
state_before: case h.e'_4
α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : PseudoMetricSpace α
r C : ℝ
hr : r < 1
f : ℕ → α
hu : ∀ (n : ℕ), dist (f n) (f (n + 1)) ≤ C * r ^ n
a : α
ha : Tendsto f atTop (𝓝 a)
n : ℕ
this : HasSum (fun n => C * r ^ n) (C / (1 - r))
⊢ r ^ n * (C / (1 - r)) = ∑' (m : ℕ), r ^ n * (C * r ^ m)
state_after: no goals
Theorem: Equiv.pointReflection_symm
File: Mathlib/Algebra/AddTorsor.lean

tactic: simp [pointReflection]
state_before: G : Type u_1
P : Type u_2
inst✝¹ : AddGroup G
inst✝ : AddTorsor G P
x : P
⊢ ∀ (x_1 : P), (Equiv.symm (pointReflection x)) x_1 = (pointReflection x) x_1
state_after: no goals
Theorem: toIcoMod_le_toIocMod
File: Mathlib/Algebra/Order/ToIntervalMod.lean

tactic: rw [toIcoMod, toIocMod, sub_le_sub_iff_left]
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c : α
n : ℤ
a b : α
⊢ toIcoMod hp a b ≤ toIocMod hp a b
state_after: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c : α
n : ℤ
a b : α
⊢ toIocDiv hp a b • p ≤ toIcoDiv hp a b • p

tactic: exact zsmul_mono_left hp.le (toIocDiv_wcovBy_toIcoDiv _ _ _).le
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c : α
n : ℤ
a b : α
⊢ toIocDiv hp a b • p ≤ toIcoDiv hp a b • p
state_after: no goals
Theorem: CategoryTheory.StructuredArrow.map_comp
File: Mathlib/CategoryTheory/Comma/StructuredArrow.lean

tactic: rw [eq_mk h]
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
S S' S'' : D
Y Y' Y'' : C
T T' : C ⥤ D
f : S ⟶ S'
f' : S' ⟶ S''
h : StructuredArrow S'' T
⊢ (map (f ≫ f')).obj h = (map f).obj ((map f').obj h)
state_after: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
S S' S'' : D
Y Y' Y'' : C
T T' : C ⥤ D
f : S ⟶ S'
f' : S' ⟶ S''
h : StructuredArrow S'' T
⊢ (map (f ≫ f')).obj (mk h.hom) = (map f).obj ((map f').obj (mk h.hom))

tactic: simp
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
S S' S'' : D
Y Y' Y'' : C
T T' : C ⥤ D
f : S ⟶ S'
f' : S' ⟶ S''
h : StructuredArrow S'' T
⊢ (map (f ≫ f')).obj (mk h.hom) = (map f).obj ((map f').obj (mk h.hom))
state_after: no goals
Theorem: SemilatticeInf.ext_inf
File: Mathlib/Order/Lattice.lean

tactic: simp only [le_inf_iff]
state_before: α✝ : Type u
β : Type v
inst✝ : SemilatticeInf α✝
a b c✝ d : α✝
α : Type u_1
A B : SemilatticeInf α
H : ∀ (x y : α), x ≤ y ↔ x ≤ y
x y c : α
⊢ c ≤ x ⊓ y ↔ c ≤ x ⊓ y
state_after: α✝ : Type u
β : Type v
inst✝ : SemilatticeInf α✝
a b c✝ d : α✝
α : Type u_1
A B : SemilatticeInf α
H : ∀ (x y : α), x ≤ y ↔ x ≤ y
x y c : α
⊢ c ≤ x ⊓ y ↔ c ≤ x ∧ c ≤ y

tactic: rw [← H, @le_inf_iff α A, H, H]
state_before: α✝ : Type u
β : Type v
inst✝ : SemilatticeInf α✝
a b c✝ d : α✝
α : Type u_1
A B : SemilatticeInf α
H : ∀ (x y : α), x ≤ y ↔ x ≤ y
x y c : α
⊢ c ≤ x ⊓ y ↔ c ≤ x ∧ c ≤ y
state_after: no goals
Theorem: inf_sup_symmDiff
File: Mathlib/Order/SymmDiff.lean

tactic: rw [sup_comm, symmDiff_sup_inf]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝ : GeneralizedCoheytingAlgebra α
a b c d : α
⊢ a ⊓ b ⊔ a ∆ b = a ⊔ b
state_after: no goals
Theorem: UniformSpace.to_nhds_mono
File: Mathlib/Topology/UniformSpace/Basic.lean

tactic: rw [@nhds_eq_uniformity α u₁ a, @nhds_eq_uniformity α u₂ a]
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
u₁ u₂ : UniformSpace α
h : u₁ ≤ u₂
a : α
⊢ 𝓝 a ≤ 𝓝 a
state_after: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
u₁ u₂ : UniformSpace α
h : u₁ ≤ u₂
a : α
⊢ (𝓤 α).lift' (ball a) ≤ (𝓤 α).lift' (ball a)

tactic: exact lift'_mono h le_rfl
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
u₁ u₂ : UniformSpace α
h : u₁ ≤ u₂
a : α
⊢ (𝓤 α).lift' (ball a) ≤ (𝓤 α).lift' (ball a)
state_after: no goals
Theorem: Sum.Lex.Icc_inl_inl
File: Mathlib/Data/Sum/Interval.lean

tactic: rw [← Finset.map_map]
state_before: α : Type u_1
β : Type u_2
inst✝⁵ : Preorder α
inst✝⁴ : Preorder β
inst✝³ : OrderTop α
inst✝² : OrderBot β
inst✝¹ : LocallyFiniteOrder α
inst✝ : LocallyFiniteOrder β
a a₁ a₂ : α
b b₁ b₂ : β
⊢ Icc (inlₗ a₁) (inlₗ a₂) = map (Embedding.inl.trans toLex.toEmbedding) (Icc a₁ a₂)
state_after: α : Type u_1
β : Type u_2
inst✝⁵ : Preorder α
inst✝⁴ : Preorder β
inst✝³ : OrderTop α
inst✝² : OrderBot β
inst✝¹ : LocallyFiniteOrder α
inst✝ : LocallyFiniteOrder β
a a₁ a₂ : α
b b₁ b₂ : β
⊢ Icc (inlₗ a₁) (inlₗ a₂) = map toLex.toEmbedding (map Embedding.inl (Icc a₁ a₂))

tactic: rfl
state_before: α : Type u_1
β : Type u_2
inst✝⁵ : Preorder α
inst✝⁴ : Preorder β
inst✝³ : OrderTop α
inst✝² : OrderBot β
inst✝¹ : LocallyFiniteOrder α
inst✝ : LocallyFiniteOrder β
a a₁ a₂ : α
b b₁ b₂ : β
⊢ Icc (inlₗ a₁) (inlₗ a₂) = map toLex.toEmbedding (map Embedding.inl (Icc a₁ a₂))
state_after: no goals
Theorem: AlgebraicGeometry.Scheme.appLE_comp_appLE
File: Mathlib/AlgebraicGeometry/Scheme.lean

tactic: dsimp [Hom.appLE]
state_before: X Y Z : Scheme
f : X ⟶ Y
g : Y ⟶ Z
U : Opens ↑↑Z.toPresheafedSpace
V : Opens ↑↑Y.toPresheafedSpace
W : Opens ↑↑X.toPresheafedSpace
e₁ : V ≤ g ⁻¹ᵁ U
e₂ : W ≤ f ⁻¹ᵁ V
⊢ Hom.appLE g U V e₁ ≫ Hom.appLE f V W e₂ = Hom.appLE (f ≫ g) U W ⋯
state_after: X Y Z : Scheme
f : X ⟶ Y
g : Y ⟶ Z
U : Opens ↑↑Z.toPresheafedSpace
V : Opens ↑↑Y.toPresheafedSpace
W : Opens ↑↑X.toPresheafedSpace
e₁ : V ≤ g ⁻¹ᵁ U
e₂ : W ≤ f ⁻¹ᵁ V
⊢ (Hom.app g U ≫ Y.presheaf.map (homOfLE e₁).op) ≫ Hom.app f V ≫ X.presheaf.map (homOfLE e₂).op =
    (Hom.app g U ≫ Hom.app f (g ⁻¹ᵁ U)) ≫ X.presheaf.map (homOfLE ⋯).op

tactic: rw [Category.assoc, f.naturality_assoc, ← Functor.map_comp]
state_before: X Y Z : Scheme
f : X ⟶ Y
g : Y ⟶ Z
U : Opens ↑↑Z.toPresheafedSpace
V : Opens ↑↑Y.toPresheafedSpace
W : Opens ↑↑X.toPresheafedSpace
e₁ : V ≤ g ⁻¹ᵁ U
e₂ : W ≤ f ⁻¹ᵁ V
⊢ (Hom.app g U ≫ Y.presheaf.map (homOfLE e₁).op) ≫ Hom.app f V ≫ X.presheaf.map (homOfLE e₂).op =
    (Hom.app g U ≫ Hom.app f (g ⁻¹ᵁ U)) ≫ X.presheaf.map (homOfLE ⋯).op
state_after: X Y Z : Scheme
f : X ⟶ Y
g : Y ⟶ Z
U : Opens ↑↑Z.toPresheafedSpace
V : Opens ↑↑Y.toPresheafedSpace
W : Opens ↑↑X.toPresheafedSpace
e₁ : V ≤ g ⁻¹ᵁ U
e₂ : W ≤ f ⁻¹ᵁ V
⊢ Hom.app g U ≫
      Hom.app f (g ⁻¹ᵁ U) ≫ X.presheaf.map (((Opens.map f.val.base).map (homOfLE e₁).op.unop).op ≫ (homOfLE e₂).op) =
    (Hom.app g U ≫ Hom.app f (g ⁻¹ᵁ U)) ≫ X.presheaf.map (homOfLE ⋯).op

tactic: rfl
state_before: X Y Z : Scheme
f : X ⟶ Y
g : Y ⟶ Z
U : Opens ↑↑Z.toPresheafedSpace
V : Opens ↑↑Y.toPresheafedSpace
W : Opens ↑↑X.toPresheafedSpace
e₁ : V ≤ g ⁻¹ᵁ U
e₂ : W ≤ f ⁻¹ᵁ V
⊢ Hom.app g U ≫
      Hom.app f (g ⁻¹ᵁ U) ≫ X.presheaf.map (((Opens.map f.val.base).map (homOfLE e₁).op.unop).op ≫ (homOfLE e₂).op) =
    (Hom.app g U ≫ Hom.app f (g ⁻¹ᵁ U)) ≫ X.presheaf.map (homOfLE ⋯).op
state_after: no goals
Theorem: CategoryTheory.MonoidalPreadditive.tensor_zero
File: Mathlib/CategoryTheory/Monoidal/Preadditive.lean

tactic: simp [tensorHom_def]
state_before: C : Type u_1
inst✝³ : Category.{u_2, u_1} C
inst✝² : Preadditive C
inst✝¹ : MonoidalCategory C
inst✝ : MonoidalPreadditive C
W X Y Z : C
f : W ⟶ X
⊢ f ⊗ 0 = 0
state_after: no goals
Theorem: MeasureTheory.Measure.mapₗ_apply_of_measurable
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: simp only [← mapₗ_mk_apply_of_aemeasurable hf.aemeasurable]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Type u_5
R : Type u_6
R' : Type u_7
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ✝ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
f : α → β
hf : Measurable f
μ : Measure α
⊢ (mapₗ f) μ = map f μ
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Type u_5
R : Type u_6
R' : Type u_7
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ✝ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
f : α → β
hf : Measurable f
μ : Measure α
⊢ (mapₗ f) μ = (mapₗ (AEMeasurable.mk f ⋯)) μ

tactic: exact mapₗ_congr hf hf.aemeasurable.measurable_mk hf.aemeasurable.ae_eq_mk
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Type u_5
R : Type u_6
R' : Type u_7
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ✝ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
f : α → β
hf : Measurable f
μ : Measure α
⊢ (mapₗ f) μ = (mapₗ (AEMeasurable.mk f ⋯)) μ
state_after: no goals
Theorem: Matrix.conjTranspose_natCast
File: Mathlib/Data/Matrix/Basic.lean

tactic: simp [conjTranspose, Matrix.map_natCast, diagonal_natCast]
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝² : DecidableEq n
inst✝¹ : Semiring α
inst✝ : StarRing α
d : ℕ
⊢ (↑d)ᴴ = ↑d
state_after: no goals
Theorem: ForInStep.done_bindList
File: .lake/packages/batteries/Batteries/Control/ForInStep/Lemmas.lean

tactic: cases l <;> simp
state_before: m : Type u_1 → Type u_2
α : Type u_3
β : Type u_1
inst✝ : Monad m
f : α → β → m (ForInStep β)
a : β
l : List α
⊢ bindList f l (done a) = pure (done a)
state_after: no goals
Theorem: WittVector.truncate_mk'
File: Mathlib/RingTheory/WittVector/Truncated.lean

tactic: ext i
state_before: p : ℕ
hp : Fact (Nat.Prime p)
n : ℕ
R : Type u_1
inst✝ : CommRing R
f : ℕ → R
⊢ (truncate n) { coeff := f } = TruncatedWittVector.mk p fun k => f ↑k
state_after: case h
p : ℕ
hp : Fact (Nat.Prime p)
n : ℕ
R : Type u_1
inst✝ : CommRing R
f : ℕ → R
i : Fin n
⊢ TruncatedWittVector.coeff i ((truncate n) { coeff := f }) =
    TruncatedWittVector.coeff i (TruncatedWittVector.mk p fun k => f ↑k)

tactic: simp only [coeff_truncate, TruncatedWittVector.coeff_mk]
state_before: case h
p : ℕ
hp : Fact (Nat.Prime p)
n : ℕ
R : Type u_1
inst✝ : CommRing R
f : ℕ → R
i : Fin n
⊢ TruncatedWittVector.coeff i ((truncate n) { coeff := f }) =
    TruncatedWittVector.coeff i (TruncatedWittVector.mk p fun k => f ↑k)
state_after: no goals
Theorem: MeasureTheory.ae_of_ae_restrict_of_ae_restrict_compl
File: Mathlib/MeasureTheory/Measure/Restrict.lean

tactic: rw [ae_iff.1 ht, ae_iff.1 htc, zero_add]
state_before: R : Type u_1
α : Type u_2
β : Type u_3
δ : Type u_4
γ : Type u_5
ι : Type u_6
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t✝ t : Set α
p : α → Prop
ht : ∀ᵐ (x : α) ∂μ.restrict t, p x
htc : ∀ᵐ (x : α) ∂μ.restrict tᶜ, p x
⊢ (μ.restrict t) {x | ¬p x} + (μ.restrict tᶜ) {x | ¬p x} = 0
state_after: no goals
Theorem: CategoryTheory.Localization.Preadditive.zero_add'
File: Mathlib/CategoryTheory/Localization/CalculusOfFractions/Preadditive.lean

tactic: rw [add'_comm, add'_zero]
state_before: C : Type u_1
D : Type u_2
inst✝⁴ : Category.{u_4, u_1} C
inst✝³ : Category.{u_3, u_2} D
inst✝² : Preadditive C
L : C ⥤ D
W : MorphismProperty C
inst✝¹ : L.IsLocalization W
inst✝ : W.HasLeftCalculusOfFractions
X Y Z : C
f : L.obj X ⟶ L.obj Y
⊢ add' W (L.map 0) f = f
state_after: no goals
Theorem: Finsupp.support_nonempty_iff
File: Mathlib/Data/Finsupp/Defs.lean

tactic: simp only [Finsupp.support_eq_empty, Finset.nonempty_iff_ne_empty, Ne]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝ : Zero M
f : α →₀ M
⊢ f.support.Nonempty ↔ f ≠ 0
state_after: no goals
Theorem: Multiset.erase_lt
File: Mathlib/Data/Multiset/Basic.lean

tactic: simpa [h] using lt_cons_self (s.erase a) a
state_before: α : Type u_1
β : Type v
γ : Type u_2
inst✝ : DecidableEq α
s✝ t : Multiset α
a✝ b a : α
s : Multiset α
h : a ∈ s
⊢ s.erase a < s
state_after: no goals
Theorem: Polynomial.derivative_X
File: Mathlib/Algebra/Polynomial/Derivative.lean

tactic: simp
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
A : Type z
a b : R
n : ℕ
inst✝ : Semiring R
⊢ (monomial (1 - 1)) (1 * ↑1) = 1
state_after: no goals
Theorem: mem_minimals_iff_forall_lt_not_mem'
File: Mathlib/Order/Minimal.lean

tactic: simp [minimals, right_iff_left_not_left_of r rlt, not_imp_not, imp.swap (a := _ ∈ _)]
state_before: α : Type u_1
β : Type u_2
r r₁ r₂ : α → α → Prop
s t : Set α
a b x : α
inst✝¹ : IsAntisymm α r
rlt : α → α → Prop
inst✝ : IsNonstrictStrictOrder α r rlt
⊢ x ∈ minimals r s ↔ x ∈ s ∧ ∀ ⦃y : α⦄, rlt y x → y ∉ s
state_after: no goals
Theorem: MeasureTheory.OuterMeasure.toMeasure_top
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: rw [OuterMeasure.top_caratheodory]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Type u_5
R : Type u_6
R' : Type u_7
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
⊢ m0 ≤ ⊤.caratheodory
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Type u_5
R : Type u_6
R' : Type u_7
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
⊢ m0 ≤ ⊤

tactic: exact le_top
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Type u_5
R : Type u_6
R' : Type u_7
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
⊢ m0 ≤ ⊤
state_after: no goals
Theorem: quarters_mem_preCantorSet
File: Mathlib/Topology/Instances/CantorSet.lean

tactic: simp only [preCantorSet_zero, inv_nonneg]
state_before: case zero

⊢ 1 / 4 ∈ preCantorSet 0 ∧ 3 / 4 ∈ preCantorSet 0
state_after: case zero

⊢ 1 / 4 ∈ Set.Icc 0 1 ∧ 3 / 4 ∈ Set.Icc 0 1

tactic: refine ⟨⟨ ?_, ?_⟩, ?_, ?_⟩ <;> norm_num
state_before: case zero

⊢ 1 / 4 ∈ Set.Icc 0 1 ∧ 3 / 4 ∈ Set.Icc 0 1
state_after: no goals

tactic: apply And.intro
state_before: case succ
n : ℕ
ih : 1 / 4 ∈ preCantorSet n ∧ 3 / 4 ∈ preCantorSet n
⊢ 1 / 4 ∈ preCantorSet (n + 1) ∧ 3 / 4 ∈ preCantorSet (n + 1)
state_after: case succ.left
n : ℕ
ih : 1 / 4 ∈ preCantorSet n ∧ 3 / 4 ∈ preCantorSet n
⊢ 1 / 4 ∈ preCantorSet (n + 1)

case succ.right
n : ℕ
ih : 1 / 4 ∈ preCantorSet n ∧ 3 / 4 ∈ preCantorSet n
⊢ 3 / 4 ∈ preCantorSet (n + 1)

tactic: exact Or.inl ⟨3 / 4, ih.2, by norm_num⟩
state_before: case succ.left
n : ℕ
ih : 1 / 4 ∈ preCantorSet n ∧ 3 / 4 ∈ preCantorSet n
⊢ 1 / 4 ∈ preCantorSet (n + 1)
state_after: no goals

tactic: norm_num
state_before: n : ℕ
ih : 1 / 4 ∈ preCantorSet n ∧ 3 / 4 ∈ preCantorSet n
⊢ (fun x => x / 3) (3 / 4) = 1 / 4
state_after: no goals

tactic: exact Or.inr ⟨1 / 4, ih.1, by norm_num⟩
state_before: case succ.right
n : ℕ
ih : 1 / 4 ∈ preCantorSet n ∧ 3 / 4 ∈ preCantorSet n
⊢ 3 / 4 ∈ preCantorSet (n + 1)
state_after: no goals

tactic: norm_num
state_before: n : ℕ
ih : 1 / 4 ∈ preCantorSet n ∧ 3 / 4 ∈ preCantorSet n
⊢ (fun x => (2 + x) / 3) (1 / 4) = 3 / 4
state_after: no goals