ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Submodule.lTensorOne'_tmul
File: Mathlib/LinearAlgebra/TensorProduct/Submodule.lean

Proof steps:
state_before: R : Type u
S : Type v
inst✝² : CommSemiring R
inst✝¹ : Semiring S
inst✝ : Algebra R S
M N : Submodule R S
y : R
n : ↥N
⊢ ↑(N.lTensorOne' ((algebraMap R ↥⊥) y ⊗ₜ[R] n)) = ↑(y • n)
state_after: R : Type u
S : Type v
inst✝² : CommSemiring R
inst✝¹ : Semiring S
inst✝ : Algebra R S
M N : Submodule R S
y : R
n : ↥N
⊢ (mulMap 1 N) ((algebraMap R ↥⊥) y ⊗ₜ[R] n) = (algebraMap R S) y * ↑n
tactic: simp_rw [lTensorOne', LinearMap.coe_comp, LinearEquiv.coe_coe, Function.comp_apply,
    LinearEquiv.coe_ofEq_apply, LinearMap.codRestrict_apply, SetLike.val_smul, Algebra.smul_def]
state_before: R : Type u
S : Type v
inst✝² : CommSemiring R
inst✝¹ : Semiring S
inst✝ : Algebra R S
M N : Submodule R S
y : R
n : ↥N
⊢ (mulMap 1 N) ((algebraMap R ↥⊥) y ⊗ₜ[R] n) = (algebraMap R S) y * ↑n
state_after: no goals
tactic: exact mulMap_tmul 1 N _ _
Theorem: Set.encard_ne_top_iff
File: Mathlib/Data/Set/Card.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
s t : Set α
⊢ s.encard ≠ ⊤ ↔ s.Finite
state_after: no goals
tactic: simp
Theorem: _private.Mathlib.Combinatorics.Additive.ErdosGinzburgZiv.0.Int.erdos_ginzburg_ziv_prime
File: Mathlib/Combinatorics/Additive/ErdosGinzburgZiv.lean

Proof steps:
state_before: ι : Type u_1
p : ℕ
inst✝ : Fact (Nat.Prime p)
s : Finset ι
a : ι → ℤ
hs : s.card = 2 * p - 1
⊢ ∃ t ⊆ s, t.card = p ∧ ↑p ∣ ∑ i ∈ t, a i
state_after: no goals
tactic: simpa [← Int.cast_sum, ZMod.intCast_zmod_eq_zero_iff_dvd]
    using ZMod.erdos_ginzburg_ziv_prime (Int.cast ∘ a) hs
Theorem: OmegaCompletePartialOrder.ContinuousHom.ite_continuous'
File: Mathlib/Order/OmegaCompletePartialOrder.lean

Proof steps:
state_before: α : Type u
α' : Type u_1
β : Type v
β' : Type u_2
γ : Type u_3
φ : Type u_4
inst✝⁵ : OmegaCompletePartialOrder α
inst✝⁴ : OmegaCompletePartialOrder β
inst✝³ : OmegaCompletePartialOrder γ
inst✝² : OmegaCompletePartialOrder φ
inst✝¹ : OmegaCompletePartialOrder α'
inst✝ : OmegaCompletePartialOrder β'
p : Prop
hp : Decidable p
f g : α → β
hf : Continuous' f
hg : Continuous' g
⊢ Continuous' fun x => if p then f x else g x
state_after: no goals
tactic: split_ifs <;> simp [*]
Theorem: Fin.insertNth_mem_Icc
File: Mathlib/Order/Fin/Tuple.lean

Proof steps:
state_before: m n : ℕ
α : Fin (n + 1) → Type u_1
x✝ : α 0
q : (i : Fin (n + 1)) → α i
p✝ : (i : Fin n) → α i.succ
i✝ : Fin n
y : α i✝.succ
z : α 0
inst✝ : (i : Fin (n + 1)) → Preorder (α i)
i : Fin (n + 1)
x : α i
p : (j : Fin n) → α (i.succAbove j)
q₁ q₂ : (j : Fin (n + 1)) → α j
⊢ i.insertNth x p ∈ Icc q₁ q₂ ↔
    x ∈ Icc (q₁ i) (q₂ i) ∧ p ∈ Icc (fun j => q₁ (i.succAbove j)) fun j => q₂ (i.succAbove j)
state_after: no goals
tactic: simp only [mem_Icc, insertNth_le_iff, le_insertNth_iff, and_assoc, @and_left_comm (x ≤ q₂ i)]
Theorem: AlgebraicGeometry.Spec.locallyRingedSpaceMap_id
File: Mathlib/AlgebraicGeometry/Spec.lean

Proof steps:
state_before: R : CommRingCat
⊢ (locallyRingedSpaceMap (𝟙 R)).val = (𝟙 (locallyRingedSpaceObj R)).val
state_after: R : CommRingCat
⊢ 𝟙 (sheafedSpaceObj R) = (𝟙 (locallyRingedSpaceObj R)).val
tactic: rw [Spec.locallyRingedSpaceMap_val, Spec.sheafedSpaceMap_id]
state_before: R : CommRingCat
⊢ 𝟙 (sheafedSpaceObj R) = (𝟙 (locallyRingedSpaceObj R)).val
state_after: no goals
tactic: rfl
Theorem: LinearMap.toMvPolynomial_eval_eq_apply
File: Mathlib/Algebra/Module/LinearMap/Polynomial.lean

Proof steps:
state_before: R : Type u_1
M₁ : Type u_2
M₂ : Type u_3
ι₁ : Type u_4
ι₂ : Type u_5
inst✝⁷ : CommRing R
inst✝⁶ : AddCommGroup M₁
inst✝⁵ : AddCommGroup M₂
inst✝⁴ : Module R M₁
inst✝³ : Module R M₂
inst✝² : Fintype ι₁
inst✝¹ : Finite ι₂
inst✝ : DecidableEq ι₁
b₁ : Basis ι₁ R M₁
b₂ : Basis ι₂ R M₂
f : M₁ →ₗ[R] M₂
i : ι₂
c : ι₁ →₀ R
⊢ (eval ⇑c) (toMvPolynomial b₁ b₂ f i) = (b₂.repr (f (b₁.repr.symm c))) i
state_after: no goals
tactic: rw [toMvPolynomial, Matrix.toMvPolynomial_eval_eq_apply,
    ← LinearMap.toMatrix_mulVec_repr b₁ b₂, LinearEquiv.apply_symm_apply]
Theorem: CategoryTheory.rightDistributor_hom_comp_biproduct_π
File: Mathlib/CategoryTheory/Monoidal/Preadditive.lean

Proof steps:
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).hom ≫ biproduct.π (fun j => f j ⊗ X) j = biproduct.π f j ▷ X
state_after: no goals
tactic: simp [rightDistributor_hom, Preadditive.sum_comp, biproduct.ι_π, comp_dite]
Theorem: IsLocalization.toInvSubmonoid_eq_mk'
File: Mathlib/RingTheory/Localization/InvSubmonoid.lean

Proof steps:
state_before: R : Type u_1
inst✝⁴ : CommRing R
M : Submonoid R
S : Type u_2
inst✝³ : CommRing S
inst✝² : Algebra R S
P : Type u_3
inst✝¹ : CommRing P
inst✝ : IsLocalization M S
x : ↥M
⊢ ↑((toInvSubmonoid M S) x) = mk' S 1 x
state_after: R : Type u_1
inst✝⁴ : CommRing R
M : Submonoid R
S : Type u_2
inst✝³ : CommRing S
inst✝² : Algebra R S
P : Type u_3
inst✝¹ : CommRing P
inst✝ : IsLocalization M S
x : ↥M
⊢ ↑((toInvSubmonoid M S) x) * (algebraMap R S) ↑x = mk' S 1 x * (algebraMap R S) ↑x
tactic: rw [← (IsLocalization.map_units S x).mul_left_inj]
state_before: R : Type u_1
inst✝⁴ : CommRing R
M : Submonoid R
S : Type u_2
inst✝³ : CommRing S
inst✝² : Algebra R S
P : Type u_3
inst✝¹ : CommRing P
inst✝ : IsLocalization M S
x : ↥M
⊢ ↑((toInvSubmonoid M S) x) * (algebraMap R S) ↑x = mk' S 1 x * (algebraMap R S) ↑x
state_after: no goals
tactic: simp
Theorem: EuclideanGeometry.dist_orthogonalProjection_eq_zero_iff
File: Mathlib/Geometry/Euclidean/Basic.lean

Proof steps:
state_before: V : Type u_1
P : Type u_2
inst✝⁵ : NormedAddCommGroup V
inst✝⁴ : InnerProductSpace ℝ V
inst✝³ : MetricSpace P
inst✝² : NormedAddTorsor V P
s : AffineSubspace ℝ P
inst✝¹ : Nonempty ↥s
inst✝ : HasOrthogonalProjection s.direction
p : P
⊢ dist p ↑((orthogonalProjection s) p) = 0 ↔ p ∈ s
state_after: no goals
tactic: rw [dist_comm, dist_eq_zero, orthogonalProjection_eq_self_iff]
Theorem: Int.cast_eq_one
File: Mathlib/Data/Int/Cast/Lemmas.lean

Proof steps:
state_before: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
inst✝¹ : AddGroupWithOne α
inst✝ : CharZero α
m n : ℤ
⊢ ↑n = 1 ↔ n = 1
state_after: no goals
tactic: rw [← cast_one, cast_inj]
Theorem: SemidirectProduct.rightHom_comp_inl
File: Mathlib/GroupTheory/SemidirectProduct.lean

Proof steps:
state_before: N : Type u_1
G : Type u_2
H : Type u_3
inst✝² : Group N
inst✝¹ : Group G
inst✝ : Group H
φ : G →* MulAut N
⊢ rightHom.comp inl = 1
state_after: case h
N : Type u_1
G : Type u_2
H : Type u_3
inst✝² : Group N
inst✝¹ : Group G
inst✝ : Group H
φ : G →* MulAut N
x✝ : N
⊢ (rightHom.comp inl) x✝ = 1 x✝
tactic: ext
state_before: case h
N : Type u_1
G : Type u_2
H : Type u_3
inst✝² : Group N
inst✝¹ : Group G
inst✝ : Group H
φ : G →* MulAut N
x✝ : N
⊢ (rightHom.comp inl) x✝ = 1 x✝
state_after: no goals
tactic: simp [rightHom]
Theorem: Int.exists_prime_and_dvd
File: Mathlib/RingTheory/Int/Basic.lean

Proof steps:
state_before: n : ℤ
hn : n.natAbs ≠ 1
⊢ ∃ p, Prime p ∧ p ∣ n
state_after: case intro.intro
n : ℤ
hn : n.natAbs ≠ 1
p : ℕ
pp : Nat.Prime p
pd : p ∣ n.natAbs
⊢ ∃ p, Prime p ∧ p ∣ n
tactic: obtain ⟨p, pp, pd⟩ := Nat.exists_prime_and_dvd hn
state_before: case intro.intro
n : ℤ
hn : n.natAbs ≠ 1
p : ℕ
pp : Nat.Prime p
pd : p ∣ n.natAbs
⊢ ∃ p, Prime p ∧ p ∣ n
state_after: no goals
tactic: exact ⟨p, Nat.prime_iff_prime_int.mp pp, Int.natCast_dvd.mpr pd⟩
Theorem: TopologicalSpace.Opens.mapMapIso_counitIso
File: Mathlib/Topology/Category/TopCat/Opens.lean

Proof steps:
state_before: X✝ Y✝ Z X Y : TopCat
H : X ≅ Y
U : Opens ↑Y
⊢ (𝟭 (Opens ↑Y)).obj U = (map H.hom ⋙ map H.inv).obj U
state_after: no goals
tactic: simp [map, Set.preimage_preimage]
state_before: X✝ Y✝ Z X Y : TopCat
H : X ≅ Y
U : Opens ↑X
⊢ (map H.inv ⋙ map H.hom).obj U = (𝟭 (Opens ↑X)).obj U
state_after: no goals
tactic: simp [map, Set.preimage_preimage]
Theorem: CompHaus.Gleason
File: Mathlib/Topology/Category/Stonean/Basic.lean

Proof steps:
state_before: X : CompHaus
⊢ Projective X ↔ ExtremallyDisconnected ↑X.toTop
state_after: case mp
X : CompHaus
⊢ Projective X → ExtremallyDisconnected ↑X.toTop

case mpr
X : CompHaus
⊢ ExtremallyDisconnected ↑X.toTop → Projective X
tactic: constructor
Theorem: Set.image_subset_range
File: Mathlib/Data/Set/Image.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
f✝ : ι → α
s✝ t : Set α
f : α → β
s : Set α
⊢ f '' s ⊆ range f
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
f✝ : ι → α
s✝ t : Set α
f : α → β
s : Set α
⊢ f '' s ⊆ f '' univ
tactic: rw [← image_univ]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
f✝ : ι → α
s✝ t : Set α
f : α → β
s : Set α
⊢ f '' s ⊆ f '' univ
state_after: no goals
tactic: exact image_subset _ (subset_univ _)
Theorem: Nat.eq_of_factorization_eq
File: Mathlib/Data/Nat/Factorization/Defs.lean

Proof steps:
state_before: a✝ b✝ m n p a b : ℕ
ha : a ≠ 0
hb : b ≠ 0
h : ∀ (p : ℕ), a.factorization p = b.factorization p
⊢ a.primeFactorsList ~ b.primeFactorsList
state_after: no goals
tactic: simpa only [List.perm_iff_count, primeFactorsList_count_eq] using h
Theorem: Nat.dvd_of_mem_divisors
File: Mathlib/NumberTheory/Divisors.lean

Proof steps:
state_before: n m : ℕ
h : n ∈ m.divisors
⊢ n ∣ m
state_after: case zero
n : ℕ
h : n ∈ divisors 0
⊢ n ∣ 0

case succ
n n✝ : ℕ
h : n ∈ (n✝ + 1).divisors
⊢ n ∣ n✝ + 1
tactic: cases m
Theorem: Tuple.monotone_sort
File: Mathlib/Data/Fin/Tuple/Sort.lean

Proof steps:
state_before: n : ℕ
α : Type u_1
inst✝ : LinearOrder α
f : Fin n → α
⊢ Monotone (f ∘ ⇑(sort f))
state_after: n : ℕ
α : Type u_1
inst✝ : LinearOrder α
f : Fin n → α
⊢ Monotone (graph.proj ∘ ⇑(graphEquiv₂ f))
tactic: rw [self_comp_sort]
state_before: n : ℕ
α : Type u_1
inst✝ : LinearOrder α
f : Fin n → α
⊢ Monotone (graph.proj ∘ ⇑(graphEquiv₂ f))
state_after: no goals
tactic: exact (monotone_proj f).comp (graphEquiv₂ f).monotone
Theorem: Matrix.fromColumns_mul_fromRows_eq_one_comm
File: Mathlib/Data/Matrix/ColumnRowPartitioned.lean

Proof steps:
state_before: R : Type u_1
m : Type u_2
m₁ : Type u_3
m₂ : Type u_4
n : Type u_5
n₁ : Type u_6
n₂ : Type u_7
inst✝¹² : Fintype m
inst✝¹¹ : Fintype m₁
inst✝¹⁰ : Fintype m₂
inst✝⁹ : Fintype n
inst✝⁸ : Fintype n₁
inst✝⁷ : Fintype n₂
inst✝⁶ : DecidableEq m
inst✝⁵ : DecidableEq m₁
inst✝⁴ : DecidableEq m₂
inst✝³ : DecidableEq n
inst✝² : DecidableEq n₁
inst✝¹ : DecidableEq n₂
inst✝ : CommRing R
e : n ≃ n₁ ⊕ n₂
A₁ : Matrix n n₁ R
A₂ : Matrix n n₂ R
B₁ : Matrix n₁ n R
B₂ : Matrix n₂ n R
⊢ A₁.fromColumns A₂ * B₁.fromRows B₂ = 1 ↔ B₁.fromRows B₂ * A₁.fromColumns A₂ = 1
state_after: no goals
tactic: calc fromColumns A₁ A₂ * fromRows B₁ B₂ = 1
  _ ↔ submatrix (fromColumns A₁ A₂) id e * submatrix (fromRows B₁ B₂) e id = 1 := by
    simp
  _ ↔ submatrix (fromRows B₁ B₂) e id * submatrix (fromColumns A₁ A₂) id e = 1 :=
    mul_eq_one_comm
  _ ↔ reindex e.symm e.symm (fromRows B₁ B₂ * fromColumns A₁ A₂) = reindex e.symm e.symm 1 := by
    simp only [reindex_apply, Equiv.symm_symm, submatrix_one_equiv,
        submatrix_mul (he₂ := Function.bijective_id)]
  _ ↔ fromRows B₁ B₂ * fromColumns A₁ A₂ = 1 :=
    (reindex _ _).injective.eq_iff
Theorem: Matrix.row_mulVec
File: Mathlib/Data/Matrix/RowCol.lean

Proof steps:
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
R : Type u_5
α : Type v
β : Type w
ι : Type u_6
inst✝¹ : Fintype n
inst✝ : NonUnitalNonAssocSemiring α
M : Matrix m n α
v : n → α
⊢ row ι (M *ᵥ v) = (M * col ι v)ᵀ
state_after: case a
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
R : Type u_5
α : Type v
β : Type w
ι : Type u_6
inst✝¹ : Fintype n
inst✝ : NonUnitalNonAssocSemiring α
M : Matrix m n α
v : n → α
i✝ : ι
j✝ : m
⊢ row ι (M *ᵥ v) i✝ j✝ = (M * col ι v)ᵀ i✝ j✝
tactic: ext
state_before: case a
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
R : Type u_5
α : Type v
β : Type w
ι : Type u_6
inst✝¹ : Fintype n
inst✝ : NonUnitalNonAssocSemiring α
M : Matrix m n α
v : n → α
i✝ : ι
j✝ : m
⊢ row ι (M *ᵥ v) i✝ j✝ = (M * col ι v)ᵀ i✝ j✝
state_after: no goals
tactic: rfl
Theorem: Zsqrtd.norm_eq_zero
File: Mathlib/NumberTheory/Zsqrtd/Basic.lean

Proof steps:
state_before: d : ℤ
h_nonsquare : ∀ (n : ℤ), d ≠ n * n
a : ℤ√d
⊢ a.norm = 0 ↔ a = 0
state_after: d : ℤ
h_nonsquare : ∀ (n : ℤ), d ≠ n * n
a : ℤ√d
ha : a.norm = 0
⊢ a.re = re 0 ∧ a.im = im 0
tactic: refine ⟨fun ha => (Zsqrtd.ext_iff _ _).mpr ?_, fun h => by rw [h, norm_zero]⟩
state_before: d : ℤ
h_nonsquare : ∀ (n : ℤ), d ≠ n * n
a : ℤ√d
ha : a.norm = 0
⊢ a.re = re 0 ∧ a.im = im 0
state_after: d : ℤ
h_nonsquare : ∀ (n : ℤ), d ≠ n * n
a : ℤ√d
ha : a.re * a.re - d * a.im * a.im = 0
⊢ a.re = re 0 ∧ a.im = im 0
tactic: dsimp only [norm] at ha
state_before: d : ℤ
h_nonsquare : ∀ (n : ℤ), d ≠ n * n
a : ℤ√d
ha : a.re * a.re - d * a.im * a.im = 0
⊢ a.re = re 0 ∧ a.im = im 0
state_after: d : ℤ
h_nonsquare : ∀ (n : ℤ), d ≠ n * n
a : ℤ√d
ha : a.re * a.re = d * a.im * a.im
⊢ a.re = re 0 ∧ a.im = im 0
tactic: rw [sub_eq_zero] at ha
state_before: d : ℤ
h_nonsquare : ∀ (n : ℤ), d ≠ n * n
a : ℤ√d
ha : a.re * a.re = d * a.im * a.im
⊢ a.re = re 0 ∧ a.im = im 0
state_after: case pos
d : ℤ
h_nonsquare : ∀ (n : ℤ), d ≠ n * n
a : ℤ√d
ha : a.re * a.re = d * a.im * a.im
h : 0 ≤ d
⊢ a.re = re 0 ∧ a.im = im 0

case neg
d : ℤ
h_nonsquare : ∀ (n : ℤ), d ≠ n * n
a : ℤ√d
ha : a.re * a.re = d * a.im * a.im
h : ¬0 ≤ d
⊢ a.re = re 0 ∧ a.im = im 0
tactic: by_cases h : 0 ≤ d
Theorem: LipschitzOnWith.ae_differentiableWithinAt_of_mem_of_real
File: Mathlib/Analysis/Calculus/Rademacher.lean

Proof steps:
state_before: E : Type u_1
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : FiniteDimensional ℝ E
inst✝⁵ : MeasurableSpace E
inst✝⁴ : BorelSpace E
F : Type u_2
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace ℝ F
C D : ℝ≥0
f g : E → ℝ
s : Set E
μ : Measure E
inst✝¹ : μ.IsAddHaarMeasure
inst✝ : FiniteDimensional ℝ F
hf : LipschitzOnWith C f s
⊢ ∀ᵐ (x : E) ∂μ, x ∈ s → DifferentiableWithinAt ℝ f s x
state_after: case intro.intro
E : Type u_1
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : FiniteDimensional ℝ E
inst✝⁵ : MeasurableSpace E
inst✝⁴ : BorelSpace E
F : Type u_2
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace ℝ F
C D : ℝ≥0
f g✝ : E → ℝ
s : Set E
μ : Measure E
inst✝¹ : μ.IsAddHaarMeasure
inst✝ : FiniteDimensional ℝ F
hf : LipschitzOnWith C f s
g : E → ℝ
g_lip : LipschitzWith C g
hg : EqOn f g s
⊢ ∀ᵐ (x : E) ∂μ, x ∈ s → DifferentiableWithinAt ℝ f s x
tactic: obtain ⟨g, g_lip, hg⟩ : ∃ (g : E → ℝ), LipschitzWith C g ∧ EqOn f g s := hf.extend_real
state_before: case intro.intro
E : Type u_1
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : FiniteDimensional ℝ E
inst✝⁵ : MeasurableSpace E
inst✝⁴ : BorelSpace E
F : Type u_2
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace ℝ F
C D : ℝ≥0
f g✝ : E → ℝ
s : Set E
μ : Measure E
inst✝¹ : μ.IsAddHaarMeasure
inst✝ : FiniteDimensional ℝ F
hf : LipschitzOnWith C f s
g : E → ℝ
g_lip : LipschitzWith C g
hg : EqOn f g s
⊢ ∀ᵐ (x : E) ∂μ, x ∈ s → DifferentiableWithinAt ℝ f s x
state_after: case h
E : Type u_1
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : FiniteDimensional ℝ E
inst✝⁵ : MeasurableSpace E
inst✝⁴ : BorelSpace E
F : Type u_2
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace ℝ F
C D : ℝ≥0
f g✝ : E → ℝ
s : Set E
μ : Measure E
inst✝¹ : μ.IsAddHaarMeasure
inst✝ : FiniteDimensional ℝ F
hf : LipschitzOnWith C f s
g : E → ℝ
g_lip : LipschitzWith C g
hg : EqOn f g s
x : E
hx : DifferentiableAt ℝ g x
xs : x ∈ s
⊢ DifferentiableWithinAt ℝ f s x
tactic: filter_upwards [g_lip.ae_differentiableAt_of_real] with x hx xs
state_before: case h
E : Type u_1
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : FiniteDimensional ℝ E
inst✝⁵ : MeasurableSpace E
inst✝⁴ : BorelSpace E
F : Type u_2
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace ℝ F
C D : ℝ≥0
f g✝ : E → ℝ
s : Set E
μ : Measure E
inst✝¹ : μ.IsAddHaarMeasure
inst✝ : FiniteDimensional ℝ F
hf : LipschitzOnWith C f s
g : E → ℝ
g_lip : LipschitzWith C g
hg : EqOn f g s
x : E
hx : DifferentiableAt ℝ g x
xs : x ∈ s
⊢ DifferentiableWithinAt ℝ f s x
state_after: no goals
tactic: exact hx.differentiableWithinAt.congr hg (hg xs)
Theorem: ZMod.unitsMap_comp
File: Mathlib/Data/ZMod/Units.lean

Proof steps:
state_before: n m d : ℕ
hm : n ∣ m
hd : m ∣ d
⊢ (unitsMap hm).comp (unitsMap hd) = unitsMap ⋯
state_after: n m d : ℕ
hm : n ∣ m
hd : m ∣ d
⊢ (Units.map ↑(castHom hm (ZMod n))).comp (Units.map ↑(castHom hd (ZMod m))) = Units.map ↑(castHom ⋯ (ZMod n))
tactic: simp only [unitsMap_def]
state_before: n m d : ℕ
hm : n ∣ m
hd : m ∣ d
⊢ (Units.map ↑(castHom hm (ZMod n))).comp (Units.map ↑(castHom hd (ZMod m))) = Units.map ↑(castHom ⋯ (ZMod n))
state_after: n m d : ℕ
hm : n ∣ m
hd : m ∣ d
⊢ Units.map ((↑(castHom hm (ZMod n))).comp ↑(castHom hd (ZMod m))) = Units.map ↑(castHom ⋯ (ZMod n))
tactic: rw [← Units.map_comp]
state_before: n m d : ℕ
hm : n ∣ m
hd : m ∣ d
⊢ Units.map ((↑(castHom hm (ZMod n))).comp ↑(castHom hd (ZMod m))) = Units.map ↑(castHom ⋯ (ZMod n))
state_after: no goals
tactic: exact congr_arg Units.map <| congr_arg RingHom.toMonoidHom <| castHom_comp hm hd
Theorem: MeasureTheory.pdf.integral_mul_eq_integral
File: Mathlib/Probability/Density.lean

Proof steps:
state_before: Ω : Type u_1
E : Type u_2
inst✝² : MeasurableSpace E
m : MeasurableSpace Ω
ℙ : Measure Ω
μ : Measure E
inst✝¹ : IsFiniteMeasure ℙ
X : Ω → ℝ
inst✝ : HasPDF X ℙ volume
⊢ ∫ (x : ℝ), x * (pdf X ℙ volume x).toReal = ∫ (x : ℝ), (pdf X ℙ volume x).toReal * x
state_after: case e_f.h
Ω : Type u_1
E : Type u_2
inst✝² : MeasurableSpace E
m : MeasurableSpace Ω
ℙ : Measure Ω
μ : Measure E
inst✝¹ : IsFiniteMeasure ℙ
X : Ω → ℝ
inst✝ : HasPDF X ℙ volume
x : ℝ
⊢ x * (pdf X ℙ volume x).toReal = (pdf X ℙ volume x).toReal * x
tactic: congr with x
state_before: case e_f.h
Ω : Type u_1
E : Type u_2
inst✝² : MeasurableSpace E
m : MeasurableSpace Ω
ℙ : Measure Ω
μ : Measure E
inst✝¹ : IsFiniteMeasure ℙ
X : Ω → ℝ
inst✝ : HasPDF X ℙ volume
x : ℝ
⊢ x * (pdf X ℙ volume x).toReal = (pdf X ℙ volume x).toReal * x
state_after: no goals
tactic: exact mul_comm _ _
Theorem: Cycle.map_eq_nil
File: Mathlib/Data/List/Cycle.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
f : α → β
s : Cycle α
⊢ ∀ (a : List α), map f (Quotient.mk'' a) = nil ↔ Quotient.mk'' a = nil
state_after: no goals
tactic: simp
Theorem: Set.Finite.closure_sUnion
File: Mathlib/Topology/Basic.lean

Proof steps:
state_before: X : Type u
Y : Type v
ι : Sort w
α : Type u_1
β : Type u_2
x : X
s s₁ s₂ t : Set X
p p₁ p₂ : X → Prop
inst✝ : TopologicalSpace X
S : Set (Set X)
hS : S.Finite
⊢ closure (⋃₀ S) = ⋃ s ∈ S, closure s
state_after: no goals
tactic: rw [sUnion_eq_biUnion, hS.closure_biUnion]
Theorem: PFunctor.liftp_iff
File: Mathlib/Data/PFunctor/Univariate/Basic.lean

Proof steps:
state_before: P : PFunctor.{u}
α : Type u
p : α → Prop
x : ↑P α
⊢ Liftp p x ↔ ∃ a f, x = ⟨a, f⟩ ∧ ∀ (i : P.B a), p (f i)
state_after: case mp
P : PFunctor.{u}
α : Type u
p : α → Prop
x : ↑P α
⊢ Liftp p x → ∃ a f, x = ⟨a, f⟩ ∧ ∀ (i : P.B a), p (f i)

case mpr
P : PFunctor.{u}
α : Type u
p : α → Prop
x : ↑P α
⊢ (∃ a f, x = ⟨a, f⟩ ∧ ∀ (i : P.B a), p (f i)) → Liftp p x
tactic: constructor
state_before: case mpr
P : PFunctor.{u}
α : Type u
p : α → Prop
x : ↑P α
⊢ (∃ a f, x = ⟨a, f⟩ ∧ ∀ (i : P.B a), p (f i)) → Liftp p x
state_after: case mpr.intro.intro.intro
P : PFunctor.{u}
α : Type u
p : α → Prop
x : ↑P α
a : P.A
f : P.B a → α
xeq : x = ⟨a, f⟩
pf : ∀ (i : P.B a), p (f i)
⊢ Liftp p x
tactic: rintro ⟨a, f, xeq, pf⟩
state_before: case mpr.intro.intro.intro
P : PFunctor.{u}
α : Type u
p : α → Prop
x : ↑P α
a : P.A
f : P.B a → α
xeq : x = ⟨a, f⟩
pf : ∀ (i : P.B a), p (f i)
⊢ Liftp p x
state_after: case h
P : PFunctor.{u}
α : Type u
p : α → Prop
x : ↑P α
a : P.A
f : P.B a → α
xeq : x = ⟨a, f⟩
pf : ∀ (i : P.B a), p (f i)
⊢ Subtype.val <$> ⟨a, fun i => ⟨f i, ⋯⟩⟩ = x
tactic: use ⟨a, fun i => ⟨f i, pf i⟩⟩
state_before: case h
P : PFunctor.{u}
α : Type u
p : α → Prop
x : ↑P α
a : P.A
f : P.B a → α
xeq : x = ⟨a, f⟩
pf : ∀ (i : P.B a), p (f i)
⊢ Subtype.val <$> ⟨a, fun i => ⟨f i, ⋯⟩⟩ = x
state_after: case h
P : PFunctor.{u}
α : Type u
p : α → Prop
x : ↑P α
a : P.A
f : P.B a → α
xeq : x = ⟨a, f⟩
pf : ∀ (i : P.B a), p (f i)
⊢ Subtype.val <$> ⟨a, fun i => ⟨f i, ⋯⟩⟩ = ⟨a, f⟩
tactic: rw [xeq]
state_before: case h
P : PFunctor.{u}
α : Type u
p : α → Prop
x : ↑P α
a : P.A
f : P.B a → α
xeq : x = ⟨a, f⟩
pf : ∀ (i : P.B a), p (f i)
⊢ Subtype.val <$> ⟨a, fun i => ⟨f i, ⋯⟩⟩ = ⟨a, f⟩
state_after: no goals
tactic: rfl
Theorem: SimpleGraph.Subgraph.Connected.sup
File: Mathlib/Combinatorics/SimpleGraph/Connectivity/Subgraph.lean

Proof steps:
state_before: V : Type u
V' : Type v
G : SimpleGraph V
G' : SimpleGraph V'
H K : G.Subgraph
hH : H.Connected
hK : K.Connected
hn : (H ⊓ K).verts.Nonempty
⊢ (H ⊔ K).Connected
state_after: V : Type u
V' : Type v
G : SimpleGraph V
G' : SimpleGraph V'
H K : G.Subgraph
hH : H.Connected
hK : K.Connected
hn : (H ⊓ K).verts.Nonempty
⊢ ∃ v, ∀ (w : ↑(H ⊔ K).verts), (H ⊔ K).coe.Reachable v w
tactic: rw [Subgraph.connected_iff', connected_iff_exists_forall_reachable]
state_before: V : Type u
V' : Type v
G : SimpleGraph V
G' : SimpleGraph V'
H K : G.Subgraph
hH : H.Connected
hK : K.Connected
hn : (H ⊓ K).verts.Nonempty
⊢ ∃ v, ∀ (w : ↑(H ⊔ K).verts), (H ⊔ K).coe.Reachable v w
state_after: case intro.intro
V : Type u
V' : Type v
G : SimpleGraph V
G' : SimpleGraph V'
H K : G.Subgraph
hH : H.Connected
hK : K.Connected
u : V
hu : u ∈ H.verts
hu' : u ∈ K.verts
⊢ ∃ v, ∀ (w : ↑(H ⊔ K).verts), (H ⊔ K).coe.Reachable v w
tactic: obtain ⟨u, hu, hu'⟩ := hn
state_before: case intro.intro
V : Type u
V' : Type v
G : SimpleGraph V
G' : SimpleGraph V'
H K : G.Subgraph
hH : H.Connected
hK : K.Connected
u : V
hu : u ∈ H.verts
hu' : u ∈ K.verts
⊢ ∃ v, ∀ (w : ↑(H ⊔ K).verts), (H ⊔ K).coe.Reachable v w
state_after: case intro.intro
V : Type u
V' : Type v
G : SimpleGraph V
G' : SimpleGraph V'
H K : G.Subgraph
hH : H.Connected
hK : K.Connected
u : V
hu : u ∈ H.verts
hu' : u ∈ K.verts
⊢ ∀ (w : ↑(H ⊔ K).verts), (H ⊔ K).coe.Reachable ⟨u, ⋯⟩ w
tactic: exists ⟨u, Or.inl hu⟩
state_before: case intro.intro
V : Type u
V' : Type v
G : SimpleGraph V
G' : SimpleGraph V'
H K : G.Subgraph
hH : H.Connected
hK : K.Connected
u : V
hu : u ∈ H.verts
hu' : u ∈ K.verts
⊢ ∀ (w : ↑(H ⊔ K).verts), (H ⊔ K).coe.Reachable ⟨u, ⋯⟩ w
state_after: case intro.intro.mk.inl
V : Type u
V' : Type v
G : SimpleGraph V
G' : SimpleGraph V'
H K : G.Subgraph
hH : H.Connected
hK : K.Connected
u : V
hu : u ∈ H.verts
hu' : u ∈ K.verts
v : V
hv : v ∈ H.verts
⊢ (H ⊔ K).coe.Reachable ⟨u, ⋯⟩ ⟨v, ⋯⟩

case intro.intro.mk.inr
V : Type u
V' : Type v
G : SimpleGraph V
G' : SimpleGraph V'
H K : G.Subgraph
hH : H.Connected
hK : K.Connected
u : V
hu : u ∈ H.verts
hu' : u ∈ K.verts
v : V
hv : v ∈ K.verts
⊢ (H ⊔ K).coe.Reachable ⟨u, ⋯⟩ ⟨v, ⋯⟩
tactic: rintro ⟨v, (hv|hv)⟩
Theorem: padicNorm.eq_zpow_of_nonzero
File: Mathlib/NumberTheory/Padics/PadicNorm.lean

Proof steps:
state_before: p : ℕ
q : ℚ
hq : q ≠ 0
⊢ padicNorm p q = ↑p ^ (-padicValRat p q)
state_after: no goals
tactic: simp [hq, padicNorm]
Theorem: Ordinal.principal_mul_one
File: Mathlib/SetTheory/Ordinal/Principal.lean

Proof steps:
state_before: ⊢ Principal (fun x x_1 => x * x_1) 1
state_after: ⊢ 0 * 0 = 0
tactic: rw [principal_one_iff]
state_before: ⊢ 0 * 0 = 0
state_after: no goals
tactic: exact zero_mul _
Theorem: isClosed_frontier
File: Mathlib/Topology/Basic.lean

Proof steps:
state_before: X : Type u
Y : Type v
ι : Sort w
α : Type u_1
β : Type u_2
x : X
s s₁ s₂ t : Set X
p p₁ p₂ : X → Prop
inst✝ : TopologicalSpace X
⊢ IsClosed (frontier s)
state_after: X : Type u
Y : Type v
ι : Sort w
α : Type u_1
β : Type u_2
x : X
s s₁ s₂ t : Set X
p p₁ p₂ : X → Prop
inst✝ : TopologicalSpace X
⊢ IsClosed (closure s ∩ closure sᶜ)
tactic: rw [frontier_eq_closure_inter_closure]
state_before: X : Type u
Y : Type v
ι : Sort w
α : Type u_1
β : Type u_2
x : X
s s₁ s₂ t : Set X
p p₁ p₂ : X → Prop
inst✝ : TopologicalSpace X
⊢ IsClosed (closure s ∩ closure sᶜ)
state_after: no goals
tactic: exact IsClosed.inter isClosed_closure isClosed_closure