1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: StrictConcaveOn.slope_anti_adjacent
File: Mathlib/Analysis/Convex/Slope.lean

tactic: have := neg_lt_neg (StrictConvexOn.slope_strict_mono_adjacent hf.neg hx hz hxy hyz)
state_before: 𝕜 : Type u_1
inst✝ : LinearOrderedField 𝕜
s : Set 𝕜
f : 𝕜 → 𝕜
hf : StrictConcaveOn 𝕜 s f
x y z : 𝕜
hx : x ∈ s
hz : z ∈ s
hxy : x < y
hyz : y < z
⊢ (f z - f y) / (z - y) < (f y - f x) / (y - x)
state_after: 𝕜 : Type u_1
inst✝ : LinearOrderedField 𝕜
s : Set 𝕜
f : 𝕜 → 𝕜
hf : StrictConcaveOn 𝕜 s f
x y z : 𝕜
hx : x ∈ s
hz : z ∈ s
hxy : x < y
hyz : y < z
this : -(((-f) z - (-f) y) / (z - y)) < -(((-f) y - (-f) x) / (y - x))
⊢ (f z - f y) / (z - y) < (f y - f x) / (y - x)

tactic: simp only [Pi.neg_apply, ← neg_div, neg_sub', neg_neg] at this
state_before: 𝕜 : Type u_1
inst✝ : LinearOrderedField 𝕜
s : Set 𝕜
f : 𝕜 → 𝕜
hf : StrictConcaveOn 𝕜 s f
x y z : 𝕜
hx : x ∈ s
hz : z ∈ s
hxy : x < y
hyz : y < z
this : -(((-f) z - (-f) y) / (z - y)) < -(((-f) y - (-f) x) / (y - x))
⊢ (f z - f y) / (z - y) < (f y - f x) / (y - x)
state_after: 𝕜 : Type u_1
inst✝ : LinearOrderedField 𝕜
s : Set 𝕜
f : 𝕜 → 𝕜
hf : StrictConcaveOn 𝕜 s f
x y z : 𝕜
hx : x ∈ s
hz : z ∈ s
hxy : x < y
hyz : y < z
this : (f z - f y) / (z - y) < (f y - f x) / (y - x)
⊢ (f z - f y) / (z - y) < (f y - f x) / (y - x)

tactic: exact this
state_before: 𝕜 : Type u_1
inst✝ : LinearOrderedField 𝕜
s : Set 𝕜
f : 𝕜 → 𝕜
hf : StrictConcaveOn 𝕜 s f
x y z : 𝕜
hx : x ∈ s
hz : z ∈ s
hxy : x < y
hyz : y < z
this : (f z - f y) / (z - y) < (f y - f x) / (y - x)
⊢ (f z - f y) / (z - y) < (f y - f x) / (y - x)
state_after: no goals
Theorem: ball_add_ball
File: Mathlib/Analysis/NormedSpace/Pointwise.lean

tactic: rw [ball_add, thickening_ball hε hδ b, Metric.vadd_ball, vadd_eq_add]
state_before: 𝕜 : Type u_1
E : Type u_2
inst✝³ : NormedField 𝕜
inst✝² : SeminormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : NormedSpace ℝ E
x y z : E
δ ε : ℝ
hε : 0 < ε
hδ : 0 < δ
a b : E
⊢ Metric.ball a ε + Metric.ball b δ = Metric.ball (a + b) (ε + δ)
state_after: no goals
Theorem: Ideal.isPrime_of_isPrime_prod_top'
File: Mathlib/RingTheory/Ideal/Prod.lean

tactic: apply isPrime_of_isPrime_prod_top (S := R)
state_before: R : Type u
S : Type v
inst✝¹ : Semiring R
inst✝ : Semiring S
I✝ I' : Ideal R
J J' I : Ideal S
h : (⊤.prod I).IsPrime
⊢ I.IsPrime
state_after: R : Type u
S : Type v
inst✝¹ : Semiring R
inst✝ : Semiring S
I✝ I' : Ideal R
J J' I : Ideal S
h : (⊤.prod I).IsPrime
⊢ (I.prod ⊤).IsPrime

tactic: rw [← map_prodComm_prod]
state_before: R : Type u
S : Type v
inst✝¹ : Semiring R
inst✝ : Semiring S
I✝ I' : Ideal R
J J' I : Ideal S
h : (⊤.prod I).IsPrime
⊢ (I.prod ⊤).IsPrime
state_after: R : Type u
S : Type v
inst✝¹ : Semiring R
inst✝ : Semiring S
I✝ I' : Ideal R
J J' I : Ideal S
h : (⊤.prod I).IsPrime
⊢ (map (↑RingEquiv.prodComm) (⊤.prod I)).IsPrime

tactic: exact map_isPrime_of_equiv (RingEquiv.prodComm (R := R) (S := S))
state_before: R : Type u
S : Type v
inst✝¹ : Semiring R
inst✝ : Semiring S
I✝ I' : Ideal R
J J' I : Ideal S
h : (⊤.prod I).IsPrime
⊢ (map (↑RingEquiv.prodComm) (⊤.prod I)).IsPrime
state_after: no goals
Theorem: FreeGroup.map.id
File: Mathlib/GroupTheory/FreeGroup/Basic.lean

tactic: rcases x with ⟨L⟩
state_before: α : Type u
L L₁ L₂ L₃ L₄ : List (α × Bool)
β : Type v
f : α → β
x✝ y x : FreeGroup α
⊢ (map _root_.id) x = x
state_after: case mk
α : Type u
L✝ L₁ L₂ L₃ L₄ : List (α × Bool)
β : Type v
f : α → β
x✝ y x : FreeGroup α
L : List (α × Bool)
⊢ (map _root_.id) (Quot.mk Red.Step L) = Quot.mk Red.Step L

tactic: simp [List.map_id']
state_before: case mk
α : Type u
L✝ L₁ L₂ L₃ L₄ : List (α × Bool)
β : Type v
f : α → β
x✝ y x : FreeGroup α
L : List (α × Bool)
⊢ (map _root_.id) (Quot.mk Red.Step L) = Quot.mk Red.Step L
state_after: no goals
Theorem: logEmbeddingQuot_injective
File: Mathlib/NumberTheory/NumberField/Units/DirichletTheorem.lean

tactic: unfold logEmbeddingQuot
state_before: K : Type u_1
inst✝² : Field K
inst✝¹ inst✝ : NumberField K
⊢ Function.Injective ⇑(logEmbeddingQuot K)
state_after: K : Type u_1
inst✝² : Field K
inst✝¹ inst✝ : NumberField K
⊢ Function.Injective
    ⇑(MonoidHom.toAdditive'
        ((QuotientGroup.kerLift (AddMonoidHom.toMultiplicative' (logEmbedding K))).comp
          (QuotientGroup.quotientMulEquivOfEq ⋯).toMonoidHom))

tactic: intro _ _ h
state_before: K : Type u_1
inst✝² : Field K
inst✝¹ inst✝ : NumberField K
⊢ Function.Injective
    ⇑(MonoidHom.toAdditive'
        ((QuotientGroup.kerLift (AddMonoidHom.toMultiplicative' (logEmbedding K))).comp
          (QuotientGroup.quotientMulEquivOfEq ⋯).toMonoidHom))
state_after: K : Type u_1
inst✝² : Field K
inst✝¹ inst✝ : NumberField K
a₁✝ a₂✝ : Additive ((𝓞 K)ˣ ⧸ torsion K)
h :
  (MonoidHom.toAdditive'
        ((QuotientGroup.kerLift (AddMonoidHom.toMultiplicative' (logEmbedding K))).comp
          (QuotientGroup.quotientMulEquivOfEq ⋯).toMonoidHom))
      a₁✝ =
    (MonoidHom.toAdditive'
        ((QuotientGroup.kerLift (AddMonoidHom.toMultiplicative' (logEmbedding K))).comp
          (QuotientGroup.quotientMulEquivOfEq ⋯).toMonoidHom))
      a₂✝
⊢ a₁✝ = a₂✝

tactic: simp_rw [MonoidHom.toAdditive'_apply_apply, MonoidHom.coe_comp, MulEquiv.coe_toMonoidHom,
  Function.comp_apply, EmbeddingLike.apply_eq_iff_eq] at h
state_before: K : Type u_1
inst✝² : Field K
inst✝¹ inst✝ : NumberField K
a₁✝ a₂✝ : Additive ((𝓞 K)ˣ ⧸ torsion K)
h :
  (MonoidHom.toAdditive'
        ((QuotientGroup.kerLift (AddMonoidHom.toMultiplicative' (logEmbedding K))).comp
          (QuotientGroup.quotientMulEquivOfEq ⋯).toMonoidHom))
      a₁✝ =
    (MonoidHom.toAdditive'
        ((QuotientGroup.kerLift (AddMonoidHom.toMultiplicative' (logEmbedding K))).comp
          (QuotientGroup.quotientMulEquivOfEq ⋯).toMonoidHom))
      a₂✝
⊢ a₁✝ = a₂✝
state_after: K : Type u_1
inst✝² : Field K
inst✝¹ inst✝ : NumberField K
a₁✝ a₂✝ : Additive ((𝓞 K)ˣ ⧸ torsion K)
h :
  (QuotientGroup.kerLift (AddMonoidHom.toMultiplicative' (logEmbedding K)))
      ((QuotientGroup.quotientMulEquivOfEq ⋯) (Additive.toMul a₁✝)) =
    (QuotientGroup.kerLift (AddMonoidHom.toMultiplicative' (logEmbedding K)))
      ((QuotientGroup.quotientMulEquivOfEq ⋯) (Additive.toMul a₂✝))
⊢ a₁✝ = a₂✝

tactic: exact (EmbeddingLike.apply_eq_iff_eq _).mp <| (QuotientGroup.kerLift_injective _).eq_iff.mp h
state_before: K : Type u_1
inst✝² : Field K
inst✝¹ inst✝ : NumberField K
a₁✝ a₂✝ : Additive ((𝓞 K)ˣ ⧸ torsion K)
h :
  (QuotientGroup.kerLift (AddMonoidHom.toMultiplicative' (logEmbedding K)))
      ((QuotientGroup.quotientMulEquivOfEq ⋯) (Additive.toMul a₁✝)) =
    (QuotientGroup.kerLift (AddMonoidHom.toMultiplicative' (logEmbedding K)))
      ((QuotientGroup.quotientMulEquivOfEq ⋯) (Additive.toMul a₂✝))
⊢ a₁✝ = a₂✝
state_after: no goals
Theorem: descPochhammer_one
File: Mathlib/RingTheory/Polynomial/Pochhammer.lean

tactic: simp [descPochhammer]
state_before: R : Type u
inst✝ : Ring R
⊢ descPochhammer R 1 = X
state_after: no goals
Theorem: LieAlgebra.IsKilling.chainBotCoeff_of_eq_zsmul_add
File: Mathlib/Algebra/Lie/Weights/RootSystem.lean

tactic: have : (β' : H → K) = -n • (-α) + β := by rwa [neg_smul, smul_neg, neg_neg]
state_before: K : Type u_1
L : Type u_2
inst✝⁷ : Field K
inst✝⁶ : CharZero K
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra K L
inst✝³ : IsKilling K L
inst✝² : FiniteDimensional K L
H : LieSubalgebra K L
inst✝¹ : H.IsCartanSubalgebra
inst✝ : IsTriangularizable K (↥H) L
α β : Weight K (↥H) L
hα : α.IsNonZero
β' : Weight K (↥H) L
n : ℤ
hβ' : ⇑β' = n • ⇑α + ⇑β
⊢ ↑(chainBotCoeff (⇑α) β') = ↑(chainBotCoeff (⇑α) β) + n
state_after: K : Type u_1
L : Type u_2
inst✝⁷ : Field K
inst✝⁶ : CharZero K
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra K L
inst✝³ : IsKilling K L
inst✝² : FiniteDimensional K L
H : LieSubalgebra K L
inst✝¹ : H.IsCartanSubalgebra
inst✝ : IsTriangularizable K (↥H) L
α β : Weight K (↥H) L
hα : α.IsNonZero
β' : Weight K (↥H) L
n : ℤ
hβ' : ⇑β' = n • ⇑α + ⇑β
this : ⇑β' = -n • -⇑α + ⇑β
⊢ ↑(chainBotCoeff (⇑α) β') = ↑(chainBotCoeff (⇑α) β) + n

tactic: rw [chainBotCoeff, chainBotCoeff, ← Weight.coe_neg,
  chainTopCoeff_of_eq_zsmul_add (-α) β hα.neg β' (-n) this, sub_neg_eq_add]
state_before: K : Type u_1
L : Type u_2
inst✝⁷ : Field K
inst✝⁶ : CharZero K
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra K L
inst✝³ : IsKilling K L
inst✝² : FiniteDimensional K L
H : LieSubalgebra K L
inst✝¹ : H.IsCartanSubalgebra
inst✝ : IsTriangularizable K (↥H) L
α β : Weight K (↥H) L
hα : α.IsNonZero
β' : Weight K (↥H) L
n : ℤ
hβ' : ⇑β' = n • ⇑α + ⇑β
this : ⇑β' = -n • -⇑α + ⇑β
⊢ ↑(chainBotCoeff (⇑α) β') = ↑(chainBotCoeff (⇑α) β) + n
state_after: no goals

tactic: rwa [neg_smul, smul_neg, neg_neg]
state_before: K : Type u_1
L : Type u_2
inst✝⁷ : Field K
inst✝⁶ : CharZero K
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra K L
inst✝³ : IsKilling K L
inst✝² : FiniteDimensional K L
H : LieSubalgebra K L
inst✝¹ : H.IsCartanSubalgebra
inst✝ : IsTriangularizable K (↥H) L
α β : Weight K (↥H) L
hα : α.IsNonZero
β' : Weight K (↥H) L
n : ℤ
hβ' : ⇑β' = n • ⇑α + ⇑β
⊢ ⇑β' = -n • -⇑α + ⇑β
state_after: no goals
Theorem: Sym2.mem_iff'
File: Mathlib/Data/Sym/Sym2.lean

tactic: rintro ⟨_, h⟩
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
a b c : α
⊢ Sym2.Mem a s(b, c) → a = b ∨ a = c
state_after: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
a b c w✝ : α
h : s(b, c) = s(a, w✝)
⊢ a = b ∨ a = c

tactic: rw [eq_iff] at h
state_before: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
a b c w✝ : α
h : s(b, c) = s(a, w✝)
⊢ a = b ∨ a = c
state_after: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
a b c w✝ : α
h : b = a ∧ c = w✝ ∨ b = w✝ ∧ c = a
⊢ a = b ∨ a = c

tactic: aesop
state_before: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
a b c w✝ : α
h : b = a ∧ c = w✝ ∨ b = w✝ ∧ c = a
⊢ a = b ∨ a = c
state_after: no goals

tactic: rintro (rfl | rfl)
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
a b c : α
⊢ a = b ∨ a = c → Sym2.Mem a s(b, c)
state_after: case inl
α : Type u_1
β : Type u_2
γ : Type u_3
a c : α
⊢ Sym2.Mem a s(a, c)

case inr
α : Type u_1
β : Type u_2
γ : Type u_3
a b : α
⊢ Sym2.Mem a s(b, a)

tactic: rw [eq_swap]
state_before: case inr
α : Type u_1
β : Type u_2
γ : Type u_3
a b : α
⊢ Sym2.Mem a s(b, a)
state_after: case inr
α : Type u_1
β : Type u_2
γ : Type u_3
a b : α
⊢ Sym2.Mem a s(a, b)

tactic: exact ⟨_, rfl⟩
state_before: case inr
α : Type u_1
β : Type u_2
γ : Type u_3
a b : α
⊢ Sym2.Mem a s(a, b)
state_after: no goals

tactic: exact ⟨_, rfl⟩
state_before: case inl
α : Type u_1
β : Type u_2
γ : Type u_3
a c : α
⊢ Sym2.Mem a s(a, c)
state_after: no goals
Theorem: DualNumber.lift_apply_inl
File: Mathlib/Algebra/DualNumber.lean

tactic: rw [lift_apply_apply, fst_inl, snd_inl, map_zero, zero_mul, add_zero]
state_before: R : Type u_1
A✝ : Type u_2
B : Type u_3
A : Type u_4
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Semiring B
inst✝¹ : Algebra R A
inst✝ : Algebra R B
fe : { fe // fe.2 * fe.2 = 0 ∧ ∀ (a : A), Commute fe.2 (fe.1 a) }
a : A
⊢ (lift fe) (inl a) = (↑fe).1 a
state_after: no goals
Theorem: Finset.image₂_singleton
File: Mathlib/Data/Finset/NAry.lean

tactic: simp
state_before: α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
γ' : Type u_6
δ : Type u_7
δ' : Type u_8
ε : Type u_9
ε' : Type u_10
ζ : Type u_11
ζ' : Type u_12
ν : Type u_13
inst✝⁷ : DecidableEq α'
inst✝⁶ : DecidableEq β'
inst✝⁵ : DecidableEq γ
inst✝⁴ : DecidableEq γ'
inst✝³ : DecidableEq δ
inst✝² : DecidableEq δ'
inst✝¹ : DecidableEq ε
inst✝ : DecidableEq ε'
f f' : α → β → γ
g g' : α → β → γ → δ
s s' : Finset α
t t' : Finset β
u u' : Finset γ
a a' : α
b b' : β
c : γ
⊢ image₂ f {a} {b} = {f a b}
state_after: no goals
Theorem: BoxIntegral.Prepartition.iUnion_restrict
File: Mathlib/Analysis/BoxIntegral/Partition/Basic.lean

tactic: simp [restrict, ← inter_iUnion, ← iUnion_def]
state_before: ι : Type u_1
I J J₁ J₂ : Box ι
π π₁ π₂ : Prepartition I
x : ι → ℝ
πi πi₁ πi₂ : (J : Box ι) → Prepartition J
⊢ (π.restrict J).iUnion = ↑J ∩ π.iUnion
state_after: no goals
Theorem: AffineMap.homothety_one
File: Mathlib/LinearAlgebra/AffineSpace/AffineMap.lean

tactic: ext p
state_before: R : Type u_1
k : Type u_2
V1 : Type u_3
P1 : Type u_4
V2 : Type u_5
P2 : Type u_6
V3 : Type u_7
P3 : Type u_8
inst✝⁵ : CommRing k
inst✝⁴ : AddCommGroup V1
inst✝³ : AffineSpace V1 P1
inst✝² : AddCommGroup V2
inst✝¹ : Module k V1
inst✝ : Module k V2
c : P1
⊢ homothety c 1 = id k P1
state_after: case h
R : Type u_1
k : Type u_2
V1 : Type u_3
P1 : Type u_4
V2 : Type u_5
P2 : Type u_6
V3 : Type u_7
P3 : Type u_8
inst✝⁵ : CommRing k
inst✝⁴ : AddCommGroup V1
inst✝³ : AffineSpace V1 P1
inst✝² : AddCommGroup V2
inst✝¹ : Module k V1
inst✝ : Module k V2
c p : P1
⊢ (homothety c 1) p = (id k P1) p

tactic: simp [homothety_apply]
state_before: case h
R : Type u_1
k : Type u_2
V1 : Type u_3
P1 : Type u_4
V2 : Type u_5
P2 : Type u_6
V3 : Type u_7
P3 : Type u_8
inst✝⁵ : CommRing k
inst✝⁴ : AddCommGroup V1
inst✝³ : AffineSpace V1 P1
inst✝² : AddCommGroup V2
inst✝¹ : Module k V1
inst✝ : Module k V2
c p : P1
⊢ (homothety c 1) p = (id k P1) p
state_after: no goals
Theorem: Filter.tendsto_iff_ptendsto_univ
File: Mathlib/Order/Filter/Partial.lean

tactic: rw [← tendsto_iff_ptendsto]
state_before: α : Type u
β : Type v
γ : Type w
l₁ : Filter α
l₂ : Filter β
f : α → β
⊢ Tendsto f l₁ l₂ ↔ PTendsto (PFun.res f Set.univ) l₁ l₂
state_after: α : Type u
β : Type v
γ : Type w
l₁ : Filter α
l₂ : Filter β
f : α → β
⊢ Tendsto f l₁ l₂ ↔ Tendsto f (l₁ ⊓ 𝓟 Set.univ) l₂

tactic: simp [principal_univ]
state_before: α : Type u
β : Type v
γ : Type w
l₁ : Filter α
l₂ : Filter β
f : α → β
⊢ Tendsto f l₁ l₂ ↔ Tendsto f (l₁ ⊓ 𝓟 Set.univ) l₂
state_after: no goals
Theorem: DiscreteQuotient.LEComap.comp
File: Mathlib/Topology/DiscreteQuotient.lean

tactic: tauto
state_before: α : Type u_1
X : Type u_2
Y : Type u_3
Z : Type u_4
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : TopologicalSpace Z
S : DiscreteQuotient X
f : C(X, Y)
A A' : DiscreteQuotient X
B B' : DiscreteQuotient Y
g : C(Y, Z)
C : DiscreteQuotient Z
⊢ LEComap g B C → LEComap f A B → LEComap (g.comp f) A C
state_after: no goals
Theorem: IsDedekindDomain.HeightOneSpectrum.valuation_le_one
File: Mathlib/RingTheory/DedekindDomain/AdicValuation.lean

tactic: rw [valuation_of_algebraMap]
state_before: R : Type u_1
inst✝⁴ : CommRing R
inst✝³ : IsDedekindDomain R
K : Type u_2
inst✝² : Field K
inst✝¹ : Algebra R K
inst✝ : IsFractionRing R K
v : HeightOneSpectrum R
r : R
⊢ v.valuation ((algebraMap R K) r) ≤ 1
state_after: R : Type u_1
inst✝⁴ : CommRing R
inst✝³ : IsDedekindDomain R
K : Type u_2
inst✝² : Field K
inst✝¹ : Algebra R K
inst✝ : IsFractionRing R K
v : HeightOneSpectrum R
r : R
⊢ v.intValuation r ≤ 1

tactic: exact v.int_valuation_le_one r
state_before: R : Type u_1
inst✝⁴ : CommRing R
inst✝³ : IsDedekindDomain R
K : Type u_2
inst✝² : Field K
inst✝¹ : Algebra R K
inst✝ : IsFractionRing R K
v : HeightOneSpectrum R
r : R
⊢ v.intValuation r ≤ 1
state_after: no goals
Theorem: Option.pbind_eq_bind
File: Mathlib/Data/Option/Basic.lean

tactic: cases x <;> simp only [pbind, none_bind', some_bind']
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
p : α → Prop
f✝ : (a : α) → p a → β
x✝ : Option α
f : α → Option β
x : Option α
⊢ (x.pbind fun a x => f a) = x.bind f
state_after: no goals
Theorem: Path.Homotopic.pi_proj
File: Mathlib/Topology/Homotopy/Product.lean

tactic: apply Quotient.inductionOn (motive := _) p
state_before: ι : Type u_1
X : ι → Type u_2
inst✝ : (i : ι) → TopologicalSpace (X i)
as bs cs : (i : ι) → X i
p : Homotopic.Quotient as bs
⊢ (pi fun i => proj i p) = p
state_after: ι : Type u_1
X : ι → Type u_2
inst✝ : (i : ι) → TopologicalSpace (X i)
as bs cs : (i : ι) → X i
p : Homotopic.Quotient as bs
⊢ ∀ (a : Path as bs), (pi fun i => proj i ⟦a⟧) = ⟦a⟧

tactic: intro
state_before: ι : Type u_1
X : ι → Type u_2
inst✝ : (i : ι) → TopologicalSpace (X i)
as bs cs : (i : ι) → X i
p : Homotopic.Quotient as bs
⊢ ∀ (a : Path as bs), (pi fun i => proj i ⟦a⟧) = ⟦a⟧
state_after: ι : Type u_1
X : ι → Type u_2
inst✝ : (i : ι) → TopologicalSpace (X i)
as bs cs : (i : ι) → X i
p : Homotopic.Quotient as bs
a✝ : Path as bs
⊢ (pi fun i => proj i ⟦a✝⟧) = ⟦a✝⟧

tactic: unfold proj
state_before: ι : Type u_1
X : ι → Type u_2
inst✝ : (i : ι) → TopologicalSpace (X i)
as bs cs : (i : ι) → X i
p : Homotopic.Quotient as bs
a✝ : Path as bs
⊢ (pi fun i => proj i ⟦a✝⟧) = ⟦a✝⟧
state_after: ι : Type u_1
X : ι → Type u_2
inst✝ : (i : ι) → TopologicalSpace (X i)
as bs cs : (i : ι) → X i
p : Homotopic.Quotient as bs
a✝ : Path as bs
⊢ (pi fun i => Quotient.mapFn ⟦a✝⟧ { toFun := fun p => p i, continuous_toFun := ⋯ }) = ⟦a✝⟧

tactic: simp_rw [← Path.Homotopic.map_lift]
state_before: ι : Type u_1
X : ι → Type u_2
inst✝ : (i : ι) → TopologicalSpace (X i)
as bs cs : (i : ι) → X i
p : Homotopic.Quotient as bs
a✝ : Path as bs
⊢ (pi fun i => Quotient.mapFn ⟦a✝⟧ { toFun := fun p => p i, continuous_toFun := ⋯ }) = ⟦a✝⟧
state_after: ι : Type u_1
X : ι → Type u_2
inst✝ : (i : ι) → TopologicalSpace (X i)
as bs cs : (i : ι) → X i
p : Homotopic.Quotient as bs
a✝ : Path as bs
⊢ (pi fun i => ⟦a✝.map ⋯⟧) = ⟦a✝⟧

tactic: erw [pi_lift]
state_before: ι : Type u_1
X : ι → Type u_2
inst✝ : (i : ι) → TopologicalSpace (X i)
as bs cs : (i : ι) → X i
p : Homotopic.Quotient as bs
a✝ : Path as bs
⊢ (pi fun i => ⟦a✝.map ⋯⟧) = ⟦a✝⟧
state_after: ι : Type u_1
X : ι → Type u_2
inst✝ : (i : ι) → TopologicalSpace (X i)
as bs cs : (i : ι) → X i
p : Homotopic.Quotient as bs
a✝ : Path as bs
⊢ ⟦Path.pi fun i => a✝.map ⋯⟧ = ⟦a✝⟧

tactic: congr
state_before: ι : Type u_1
X : ι → Type u_2
inst✝ : (i : ι) → TopologicalSpace (X i)
as bs cs : (i : ι) → X i
p : Homotopic.Quotient as bs
a✝ : Path as bs
⊢ ⟦Path.pi fun i => a✝.map ⋯⟧ = ⟦a✝⟧
state_after: no goals
Theorem: Set.Countable.ae_not_mem
File: Mathlib/MeasureTheory/Measure/Typeclasses.lean

tactic: simpa only [ae_iff, Classical.not_not] using h.measure_zero μ
state_before: α : Type u_1
β : Type u_2
δ : Type u_3
ι : Type u_4
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
μ✝ ν ν₁ ν₂ : Measure α
s t : Set α
inst✝¹ : NoAtoms μ✝
h : s.Countable
μ : Measure α
inst✝ : NoAtoms μ
⊢ ∀ᵐ (x : α) ∂μ, x ∉ s
state_after: no goals
Theorem: Metric.closedBall_subset_cthickening
File: Mathlib/Topology/MetricSpace/Thickening.lean

tactic: refine (closedBall_subset_cthickening_singleton _ _).trans (cthickening_subset_of_subset _ ?_)
state_before: ι : Sort u_1
α✝ : Type u
β : Type v
inst✝¹ : PseudoEMetricSpace α✝
δ✝ ε : ℝ
s t : Set α✝
x✝ : α✝
α : Type u_2
inst✝ : PseudoMetricSpace α
x : α
E : Set α
hx : x ∈ E
δ : ℝ
⊢ closedBall x δ ⊆ cthickening δ E
state_after: ι : Sort u_1
α✝ : Type u
β : Type v
inst✝¹ : PseudoEMetricSpace α✝
δ✝ ε : ℝ
s t : Set α✝
x✝ : α✝
α : Type u_2
inst✝ : PseudoMetricSpace α
x : α
E : Set α
hx : x ∈ E
δ : ℝ
⊢ {x} ⊆ E

tactic: simpa using hx
state_before: ι : Sort u_1
α✝ : Type u
β : Type v
inst✝¹ : PseudoEMetricSpace α✝
δ✝ ε : ℝ
s t : Set α✝
x✝ : α✝
α : Type u_2
inst✝ : PseudoMetricSpace α
x : α
E : Set α
hx : x ∈ E
δ : ℝ
⊢ {x} ⊆ E
state_after: no goals
Theorem: EquicontinuousOn.isClosed_range_uniformOnFun_iff_pi
File: Mathlib/Topology/UniformSpace/Ascoli.lean

tactic: simp_rw [isClosed_iff_clusterPt, ← Filter.map_top, ← mapClusterPt_def,
  mapClusterPt_iff_ultrafilter, range_comp, (UniformOnFun.ofFun 𝔖).surjective.forall,
  ← EquicontinuousOn.tendsto_uniformOnFun_iff_pi 𝔖_compact 𝔖_covers F_eqcont,
  (UniformOnFun.ofFun 𝔖).injective.mem_set_image]
state_before: ι : Type u_1
X : Type u_2
Y : Type u_3
α : Type u_4
β : Type u_5
inst✝² : TopologicalSpace X
inst✝¹ : UniformSpace α
inst✝ : UniformSpace β
F : ι → X → α
G : ι → β → α
𝔖 : Set (Set X)
𝔖_compact : ∀ K ∈ 𝔖, IsCompact K
𝔖_covers : ⋃₀ 𝔖 = univ
F_eqcont : ∀ K ∈ 𝔖, EquicontinuousOn F K
⊢ IsClosed (range (⇑(UniformOnFun.ofFun 𝔖) ∘ F)) ↔ IsClosed (range F)
state_after: no goals
Theorem: Submonoid.bot_prod_bot
File: Mathlib/Algebra/Group/Submonoid/Operations.lean

tactic: simp [coe_prod, Prod.one_eq_mk]
state_before: M : Type u_1
N : Type u_2
P : Type u_3
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : MulOneClass P
S : Submonoid M
A : Type u_4
inst✝ : SetLike A M
hA : SubmonoidClass A M
S' : A
⊢ ↑(⊥.prod ⊥) = ↑⊥
state_after: no goals
Theorem: Ordinal.cof_blsub_le
File: Mathlib/SetTheory/Cardinal/Cofinality.lean

tactic: rw [← o.card.lift_id]
state_before: α : Type u_1
r : α → α → Prop
o : Ordinal.{u}
f : (a : Ordinal.{u}) → a < o → Ordinal.{u}
⊢ (o.blsub f).cof ≤ o.card
state_after: α : Type u_1
r : α → α → Prop
o : Ordinal.{u}
f : (a : Ordinal.{u}) → a < o → Ordinal.{u}
⊢ (o.blsub f).cof ≤ Cardinal.lift.{u, u} o.card

tactic: exact cof_blsub_le_lift f
state_before: α : Type u_1
r : α → α → Prop
o : Ordinal.{u}
f : (a : Ordinal.{u}) → a < o → Ordinal.{u}
⊢ (o.blsub f).cof ≤ Cardinal.lift.{u, u} o.card
state_after: no goals
Theorem: IntermediateField.bot_eq_top_of_finrank_adjoin_eq_one
File: Mathlib/FieldTheory/Adjoin.lean

tactic: ext y
state_before: F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
α : E
S : Set E
K L : IntermediateField F E
h : ∀ (x : E), finrank F ↥F⟮x⟯ = 1
⊢ ⊥ = ⊤
state_after: case h
F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
α : E
S : Set E
K L : IntermediateField F E
h : ∀ (x : E), finrank F ↥F⟮x⟯ = 1
y : E
⊢ y ∈ ⊥ ↔ y ∈ ⊤

tactic: rw [iff_true_right IntermediateField.mem_top]
state_before: case h
F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
α : E
S : Set E
K L : IntermediateField F E
h : ∀ (x : E), finrank F ↥F⟮x⟯ = 1
y : E
⊢ y ∈ ⊥ ↔ y ∈ ⊤
state_after: case h
F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
α : E
S : Set E
K L : IntermediateField F E
h : ∀ (x : E), finrank F ↥F⟮x⟯ = 1
y : E
⊢ y ∈ ⊥

tactic: exact finrank_adjoin_simple_eq_one_iff.mp (h y)
state_before: case h
F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
α : E
S : Set E
K L : IntermediateField F E
h : ∀ (x : E), finrank F ↥F⟮x⟯ = 1
y : E
⊢ y ∈ ⊥
state_after: no goals