1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: MeasureTheory.integral_fintype_prod_eq_prod
File: Mathlib/MeasureTheory/Integral/Pi.lean

tactic: let e := (equivFin ι).symm
state_before: 𝕜 : Type u_1
inst✝³ : RCLike 𝕜
ι : Type u_2
inst✝² : Fintype ι
E : ι → Type u_3
f : (i : ι) → E i → 𝕜
inst✝¹ : (i : ι) → MeasureSpace (E i)
inst✝ : ∀ (i : ι), SigmaFinite volume
⊢ ∫ (x : (i : ι) → E i), ∏ i : ι, f i (x i) = ∏ i : ι, ∫ (x : E i), f i x
state_after: 𝕜 : Type u_1
inst✝³ : RCLike 𝕜
ι : Type u_2
inst✝² : Fintype ι
E : ι → Type u_3
f : (i : ι) → E i → 𝕜
inst✝¹ : (i : ι) → MeasureSpace (E i)
inst✝ : ∀ (i : ι), SigmaFinite volume
e : Fin (card ι) ≃ ι := (equivFin ι).symm
⊢ ∫ (x : (i : ι) → E i), ∏ i : ι, f i (x i) = ∏ i : ι, ∫ (x : E i), f i x

tactic: rw [← (volume_measurePreserving_piCongrLeft _ e).integral_comp']
state_before: 𝕜 : Type u_1
inst✝³ : RCLike 𝕜
ι : Type u_2
inst✝² : Fintype ι
E : ι → Type u_3
f : (i : ι) → E i → 𝕜
inst✝¹ : (i : ι) → MeasureSpace (E i)
inst✝ : ∀ (i : ι), SigmaFinite volume
e : Fin (card ι) ≃ ι := (equivFin ι).symm
⊢ ∫ (x : (i : ι) → E i), ∏ i : ι, f i (x i) = ∏ i : ι, ∫ (x : E i), f i x
state_after: 𝕜 : Type u_1
inst✝³ : RCLike 𝕜
ι : Type u_2
inst✝² : Fintype ι
E : ι → Type u_3
f : (i : ι) → E i → 𝕜
inst✝¹ : (i : ι) → MeasureSpace (E i)
inst✝ : ∀ (i : ι), SigmaFinite volume
e : Fin (card ι) ≃ ι := (equivFin ι).symm
⊢ ∫ (x : (b : Fin (card ι)) → E (e b)), ∏ i : ι, f i ((MeasurableEquiv.piCongrLeft E e) x i) =
    ∏ i : ι, ∫ (x : E i), f i x

tactic: simp_rw [← e.prod_comp, MeasurableEquiv.coe_piCongrLeft, Equiv.piCongrLeft_apply_apply,
  MeasureTheory.integral_fin_nat_prod_eq_prod]
state_before: 𝕜 : Type u_1
inst✝³ : RCLike 𝕜
ι : Type u_2
inst✝² : Fintype ι
E : ι → Type u_3
f : (i : ι) → E i → 𝕜
inst✝¹ : (i : ι) → MeasureSpace (E i)
inst✝ : ∀ (i : ι), SigmaFinite volume
e : Fin (card ι) ≃ ι := (equivFin ι).symm
⊢ ∫ (x : (b : Fin (card ι)) → E (e b)), ∏ i : ι, f i ((MeasurableEquiv.piCongrLeft E e) x i) =
    ∏ i : ι, ∫ (x : E i), f i x
state_after: no goals
Theorem: Monoid.PushoutI.NormalWord.prod_cons
File: Mathlib/GroupTheory/PushoutI.lean

tactic: simp only [prod, cons, Word.prod, List.map, ← of_apply_eq_base φ i, equiv_fst_eq_mul_inv,
  mul_assoc, MonoidHom.apply_ofInjective_symm, List.prod_cons, map_mul, map_inv,
  ofCoprodI_of, inv_mul_cancel_left]
state_before: ι : Type u_1
G : ι → Type u_2
H : Type u_3
K : Type u_4
inst✝⁴ : Monoid K
inst✝³ : (i : ι) → Group (G i)
inst✝² : Group H
φ : (i : ι) → H →* G i
d : Transversal φ
inst✝¹ : DecidableEq ι
inst✝ : (i : ι) → DecidableEq (G i)
i : ι
g : G i
w : NormalWord d
hmw : w.fstIdx ≠ some i
hgr : g ∉ (φ i).range
⊢ (cons g w hmw hgr).prod = (of i) g * w.prod
state_after: no goals
Theorem: Real.log_ne_zero
File: Mathlib/Analysis/SpecialFunctions/Log/Basic.lean

tactic: simpa only [not_or] using log_eq_zero.not
state_before: x✝ y x : ℝ
⊢ log x ≠ 0 ↔ x ≠ 0 ∧ x ≠ 1 ∧ x ≠ -1
state_after: no goals
Theorem: WeierstrassCurve.Projective.eval_polynomialY
File: Mathlib/AlgebraicGeometry/EllipticCurve/Projective.lean

tactic: rw [polynomialY_eq]
state_before: R : Type u
inst✝ : CommRing R
W : Projective R
P : Fin 3 → R
⊢ (eval P) W.polynomialY = 2 * P 1 * P 2 + W.a₁ * P 0 * P 2 + W.a₃ * P 2 ^ 2
state_after: R : Type u
inst✝ : CommRing R
W : Projective R
P : Fin 3 → R
⊢ (eval P) (C 2 * X 1 * X 2 + C W.a₁ * X 0 * X 2 + C W.a₃ * X 2 ^ 2) = 2 * P 1 * P 2 + W.a₁ * P 0 * P 2 + W.a₃ * P 2 ^ 2

tactic: eval_simp
state_before: R : Type u
inst✝ : CommRing R
W : Projective R
P : Fin 3 → R
⊢ (eval P) (C 2 * X 1 * X 2 + C W.a₁ * X 0 * X 2 + C W.a₃ * X 2 ^ 2) = 2 * P 1 * P 2 + W.a₁ * P 0 * P 2 + W.a₃ * P 2 ^ 2
state_after: no goals
Theorem: DiscreteTopology.of_forall_le_norm'
File: Mathlib/Analysis/Normed/Group/Basic.lean

tactic: simp only [dist_eq_norm_div]
state_before: 𝓕 : Type u_1
𝕜 : Type u_2
α : Type u_3
ι : Type u_4
κ : Type u_5
E : Type u_6
F : Type u_7
G : Type u_8
inst✝² : SeminormedGroup E
inst✝¹ : SeminormedGroup F
inst✝ : SeminormedGroup G
s : Set E
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
hpos : 0 < r
hr : ∀ (x : E), x ≠ 1 → r ≤ ‖x‖
x y : E
hne : x ≠ y
⊢ (fun x x_1 => r ≤ dist x x_1) x y
state_after: 𝓕 : Type u_1
𝕜 : Type u_2
α : Type u_3
ι : Type u_4
κ : Type u_5
E : Type u_6
F : Type u_7
G : Type u_8
inst✝² : SeminormedGroup E
inst✝¹ : SeminormedGroup F
inst✝ : SeminormedGroup G
s : Set E
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
hpos : 0 < r
hr : ∀ (x : E), x ≠ 1 → r ≤ ‖x‖
x y : E
hne : x ≠ y
⊢ r ≤ ‖x / y‖

tactic: exact hr _ (div_ne_one.2 hne)
state_before: 𝓕 : Type u_1
𝕜 : Type u_2
α : Type u_3
ι : Type u_4
κ : Type u_5
E : Type u_6
F : Type u_7
G : Type u_8
inst✝² : SeminormedGroup E
inst✝¹ : SeminormedGroup F
inst✝ : SeminormedGroup G
s : Set E
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
hpos : 0 < r
hr : ∀ (x : E), x ≠ 1 → r ≤ ‖x‖
x y : E
hne : x ≠ y
⊢ r ≤ ‖x / y‖
state_after: no goals
Theorem: padicValRat.one
File: Mathlib/NumberTheory/Padics/PadicVal.lean

tactic: simp [padicValRat]
state_before: p : ℕ
⊢ padicValRat p 1 = 0
state_after: no goals
Theorem: Module.DirectLimit.exists_of
File: Mathlib/Algebra/DirectLimit.lean

tactic: infer_instance
state_before: R : Type u
inst✝⁶ : Ring R
ι : Type v
inst✝⁵ : Preorder ι
G : ι → Type w
inst✝⁴ : (i : ι) → AddCommGroup (G i)
inst✝³ : (i : ι) → Module R (G i)
f : (i j : ι) → i ≤ j → G i →ₗ[R] G j
inst✝² : DecidableEq ι
inst✝¹ : Nonempty ι
inst✝ : IsDirected ι fun x x_1 => x ≤ x_1
z : DirectLimit G f
⊢ Nonempty ι
state_after: no goals

tactic: rw [LinearMap.map_add, of_f, of_f, ihx, ihy]
state_before: R : Type u
inst✝⁶ : Ring R
ι : Type v
inst✝⁵ : Preorder ι
G : ι → Type w
inst✝⁴ : (i : ι) → AddCommGroup (G i)
inst✝³ : (i : ι) → Module R (G i)
f : (i j : ι) → i ≤ j → G i →ₗ[R] G j
inst✝² : DecidableEq ι
inst✝¹ : Nonempty ι
inst✝ : IsDirected ι fun x x_1 => x ≤ x_1
z✝ : DirectLimit G f
ind : ι
z p q : DirectSum ι fun i => G i
x✝¹ : ∃ i x, (of R ι G f i) x = Quotient.mk'' p
x✝ : ∃ i x, (of R ι G f i) x = Quotient.mk'' q
i : ι
x : G i
ihx : (of R ι G f i) x = Quotient.mk'' p
j : ι
y : G j
ihy : (of R ι G f j) y = Quotient.mk'' q
k : ι
hik : i ≤ k
hjk : j ≤ k
⊢ (of R ι G f k) ((f i k hik) x + (f j k hjk) y) = Quotient.mk'' (p + q)
state_after: R : Type u
inst✝⁶ : Ring R
ι : Type v
inst✝⁵ : Preorder ι
G : ι → Type w
inst✝⁴ : (i : ι) → AddCommGroup (G i)
inst✝³ : (i : ι) → Module R (G i)
f : (i j : ι) → i ≤ j → G i →ₗ[R] G j
inst✝² : DecidableEq ι
inst✝¹ : Nonempty ι
inst✝ : IsDirected ι fun x x_1 => x ≤ x_1
z✝ : DirectLimit G f
ind : ι
z p q : DirectSum ι fun i => G i
x✝¹ : ∃ i x, (of R ι G f i) x = Quotient.mk'' p
x✝ : ∃ i x, (of R ι G f i) x = Quotient.mk'' q
i : ι
x : G i
ihx : (of R ι G f i) x = Quotient.mk'' p
j : ι
y : G j
ihy : (of R ι G f j) y = Quotient.mk'' q
k : ι
hik : i ≤ k
hjk : j ≤ k
⊢ Quotient.mk'' p + Quotient.mk'' q = Quotient.mk'' (p + q)

tactic: rfl
state_before: R : Type u
inst✝⁶ : Ring R
ι : Type v
inst✝⁵ : Preorder ι
G : ι → Type w
inst✝⁴ : (i : ι) → AddCommGroup (G i)
inst✝³ : (i : ι) → Module R (G i)
f : (i j : ι) → i ≤ j → G i →ₗ[R] G j
inst✝² : DecidableEq ι
inst✝¹ : Nonempty ι
inst✝ : IsDirected ι fun x x_1 => x ≤ x_1
z✝ : DirectLimit G f
ind : ι
z p q : DirectSum ι fun i => G i
x✝¹ : ∃ i x, (of R ι G f i) x = Quotient.mk'' p
x✝ : ∃ i x, (of R ι G f i) x = Quotient.mk'' q
i : ι
x : G i
ihx : (of R ι G f i) x = Quotient.mk'' p
j : ι
y : G j
ihy : (of R ι G f j) y = Quotient.mk'' q
k : ι
hik : i ≤ k
hjk : j ≤ k
⊢ Quotient.mk'' p + Quotient.mk'' q = Quotient.mk'' (p + q)
state_after: no goals
Theorem: AffineSubspace.right_mem_perpBisector
File: Mathlib/Geometry/Euclidean/PerpBisector.lean

tactic: simpa [mem_perpBisector_iff_inner_eq_inner] using eq_comm
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
c c₁ c₂ p₁ p₂ : P
⊢ p₂ ∈ perpBisector p₁ p₂ ↔ p₁ = p₂
state_after: no goals
Theorem: Multiset.Ico_filter_le_of_right_le
File: Mathlib/Order/Interval/Multiset.lean

tactic: rw [Ico, ← Finset.filter_val, Finset.Ico_filter_le_of_right_le]
state_before: α : Type u_1
inst✝² : Preorder α
inst✝¹ : LocallyFiniteOrder α
a b c : α
inst✝ : DecidablePred fun x => b ≤ x
⊢ filter (fun x => b ≤ x) (Ico a b) = ∅
state_after: α : Type u_1
inst✝² : Preorder α
inst✝¹ : LocallyFiniteOrder α
a b c : α
inst✝ : DecidablePred fun x => b ≤ x
⊢ ∅.val = ∅

tactic: rfl
state_before: α : Type u_1
inst✝² : Preorder α
inst✝¹ : LocallyFiniteOrder α
a b c : α
inst✝ : DecidablePred fun x => b ≤ x
⊢ ∅.val = ∅
state_after: no goals
Theorem: MvPolynomial.coeff_mul_X'
File: Mathlib/Algebra/MvPolynomial/Basic.lean

tactic: refine (coeff_mul_monomial' _ _ _ _).trans ?_
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m✝ : σ
s✝ : σ →₀ ℕ
inst✝² : CommSemiring R
inst✝¹ : CommSemiring S₁
p✝ q : MvPolynomial σ R
inst✝ : DecidableEq σ
m : σ →₀ ℕ
s : σ
p : MvPolynomial σ R
⊢ coeff m (p * X s) = if s ∈ m.support then coeff (m - Finsupp.single s 1) p else 0
state_after: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m✝ : σ
s✝ : σ →₀ ℕ
inst✝² : CommSemiring R
inst✝¹ : CommSemiring S₁
p✝ q : MvPolynomial σ R
inst✝ : DecidableEq σ
m : σ →₀ ℕ
s : σ
p : MvPolynomial σ R
⊢ (if Finsupp.single s 1 ≤ m then coeff (m - Finsupp.single s 1) p * 1 else 0) =
    if s ∈ m.support then coeff (m - Finsupp.single s 1) p else 0

tactic: simp_rw [Finsupp.single_le_iff, Finsupp.mem_support_iff, Nat.succ_le_iff, pos_iff_ne_zero,
  mul_one]
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m✝ : σ
s✝ : σ →₀ ℕ
inst✝² : CommSemiring R
inst✝¹ : CommSemiring S₁
p✝ q : MvPolynomial σ R
inst✝ : DecidableEq σ
m : σ →₀ ℕ
s : σ
p : MvPolynomial σ R
⊢ (if Finsupp.single s 1 ≤ m then coeff (m - Finsupp.single s 1) p * 1 else 0) =
    if s ∈ m.support then coeff (m - Finsupp.single s 1) p else 0
state_after: no goals
Theorem: Set.range_comp_subset_range
File: Mathlib/Data/Set/Image.lean

tactic: rw [range_comp]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
f✝ : ι → α
s t : Set α
f : α → β
g : β → γ
⊢ range (g ∘ f) ⊆ range g
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
f✝ : ι → α
s t : Set α
f : α → β
g : β → γ
⊢ g '' range f ⊆ range g

tactic: apply image_subset_range
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
f✝ : ι → α
s t : Set α
f : α → β
g : β → γ
⊢ g '' range f ⊆ range g
state_after: no goals
Theorem: Multiset.map_eq_zero
File: Mathlib/Data/Multiset/Basic.lean

tactic: rw [← Multiset.card_eq_zero, Multiset.card_map, Multiset.card_eq_zero]
state_before: α : Type u_1
β : Type v
γ : Type u_2
s : Multiset α
f : α → β
⊢ map f s = 0 ↔ s = 0
state_after: no goals
Theorem: RingTheory.Sequence.eq_nil_of_isRegular_on_artinian
File: Mathlib/RingTheory/Regular/RegularSequence.lean

tactic: rw [isRegular_iff, ne_comm, ← lt_top_iff_ne_top, Ideal.ofList_cons,
  sup_smul, ideal_span_singleton_smul, isWeaklyRegular_cons_iff] at h
state_before: R : Type u_1
S : Type u_2
M : Type u_3
M₂ : Type u_4
M₃ : Type u_5
M₄ : Type u_6
inst✝⁹ : CommRing R
inst✝⁸ : AddCommGroup M
inst✝⁷ : AddCommGroup M₂
inst✝⁶ : AddCommGroup M₃
inst✝⁵ : AddCommGroup M₄
inst✝⁴ : Module R M
inst✝³ : Module R M₂
inst✝² : Module R M₃
inst✝¹ : Module R M₄
inst✝ : IsArtinian R M
r : R
rs : List R
h : IsRegular M (r :: rs)
⊢ r :: rs = []
state_after: R : Type u_1
S : Type u_2
M : Type u_3
M₂ : Type u_4
M₃ : Type u_5
M₄ : Type u_6
inst✝⁹ : CommRing R
inst✝⁸ : AddCommGroup M
inst✝⁷ : AddCommGroup M₂
inst✝⁶ : AddCommGroup M₃
inst✝⁵ : AddCommGroup M₄
inst✝⁴ : Module R M
inst✝³ : Module R M₂
inst✝² : Module R M₃
inst✝¹ : Module R M₄
inst✝ : IsArtinian R M
r : R
rs : List R
h : (IsSMulRegular M r ∧ IsWeaklyRegular (QuotSMulTop r M) rs) ∧ r • ⊤ ⊔ Ideal.ofList rs • ⊤ < ⊤
⊢ r :: rs = []

tactic: refine absurd ?_ (ne_of_lt (lt_of_le_of_lt le_sup_left h.right))
state_before: R : Type u_1
S : Type u_2
M : Type u_3
M₂ : Type u_4
M₃ : Type u_5
M₄ : Type u_6
inst✝⁹ : CommRing R
inst✝⁸ : AddCommGroup M
inst✝⁷ : AddCommGroup M₂
inst✝⁶ : AddCommGroup M₃
inst✝⁵ : AddCommGroup M₄
inst✝⁴ : Module R M
inst✝³ : Module R M₂
inst✝² : Module R M₃
inst✝¹ : Module R M₄
inst✝ : IsArtinian R M
r : R
rs : List R
h : (IsSMulRegular M r ∧ IsWeaklyRegular (QuotSMulTop r M) rs) ∧ r • ⊤ ⊔ Ideal.ofList rs • ⊤ < ⊤
⊢ r :: rs = []
state_after: R : Type u_1
S : Type u_2
M : Type u_3
M₂ : Type u_4
M₃ : Type u_5
M₄ : Type u_6
inst✝⁹ : CommRing R
inst✝⁸ : AddCommGroup M
inst✝⁷ : AddCommGroup M₂
inst✝⁶ : AddCommGroup M₃
inst✝⁵ : AddCommGroup M₄
inst✝⁴ : Module R M
inst✝³ : Module R M₂
inst✝² : Module R M₃
inst✝¹ : Module R M₄
inst✝ : IsArtinian R M
r : R
rs : List R
h : (IsSMulRegular M r ∧ IsWeaklyRegular (QuotSMulTop r M) rs) ∧ r • ⊤ ⊔ Ideal.ofList rs • ⊤ < ⊤
⊢ r • ⊤ = ⊤

tactic: exact Eq.trans (Submodule.map_top _) <| LinearMap.range_eq_top.mpr <|
  surjective_of_injective_endomorphism (LinearMap.lsmul R M r) h.left.left
state_before: R : Type u_1
S : Type u_2
M : Type u_3
M₂ : Type u_4
M₃ : Type u_5
M₄ : Type u_6
inst✝⁹ : CommRing R
inst✝⁸ : AddCommGroup M
inst✝⁷ : AddCommGroup M₂
inst✝⁶ : AddCommGroup M₃
inst✝⁵ : AddCommGroup M₄
inst✝⁴ : Module R M
inst✝³ : Module R M₂
inst✝² : Module R M₃
inst✝¹ : Module R M₄
inst✝ : IsArtinian R M
r : R
rs : List R
h : (IsSMulRegular M r ∧ IsWeaklyRegular (QuotSMulTop r M) rs) ∧ r • ⊤ ⊔ Ideal.ofList rs • ⊤ < ⊤
⊢ r • ⊤ = ⊤
state_after: no goals
Theorem: CliffordAlgebra.changeFormAux_changeFormAux
File: Mathlib/LinearAlgebra/CliffordAlgebra/Contraction.lean

tactic: simp only [changeFormAux_apply_apply]
state_before: R : Type u1
inst✝² : CommRing R
M : Type u2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
B : BilinForm R M
v : M
x : CliffordAlgebra Q
⊢ ((changeFormAux Q B) v) (((changeFormAux Q B) v) x) = (Q v - (B v) v) • x
state_after: R : Type u1
inst✝² : CommRing R
M : Type u2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
B : BilinForm R M
v : M
x : CliffordAlgebra Q
⊢ (ι Q) v * ((ι Q) v * x - (contractLeft (B v)) x) - (contractLeft (B v)) ((ι Q) v * x - (contractLeft (B v)) x) =
    (Q v - (B v) v) • x

tactic: rw [mul_sub, ← mul_assoc, ι_sq_scalar, map_sub, contractLeft_ι_mul, ← sub_add, sub_sub_sub_comm,
  ← Algebra.smul_def, sub_self, sub_zero, contractLeft_contractLeft, add_zero, sub_smul]
state_before: R : Type u1
inst✝² : CommRing R
M : Type u2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
B : BilinForm R M
v : M
x : CliffordAlgebra Q
⊢ (ι Q) v * ((ι Q) v * x - (contractLeft (B v)) x) - (contractLeft (B v)) ((ι Q) v * x - (contractLeft (B v)) x) =
    (Q v - (B v) v) • x
state_after: no goals
Theorem: CategoryTheory.SimplicialCategory.sHomWhiskerLeft_comp
File: Mathlib/AlgebraicTopology/SimplicialCategory/Basic.lean

tactic: dsimp [sHomWhiskerLeft]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : SimplicialCategory C
K L L' L'' : C
g : L ⟶ L'
g' : L' ⟶ L''
⊢ sHomWhiskerLeft K (g ≫ g') = sHomWhiskerLeft K g ≫ sHomWhiskerLeft K g'
state_after: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : SimplicialCategory C
K L L' L'' : C
g : L ⟶ L'
g' : L' ⟶ L''
⊢ (ρ_ (sHom K L)).inv ≫ sHom K L ◁ (homEquiv L L'') (g ≫ g') ≫ sHomComp K L L'' =
    ((ρ_ (sHom K L)).inv ≫ sHom K L ◁ (homEquiv L L') g ≫ sHomComp K L L') ≫
      (ρ_ (sHom K L')).inv ≫ sHom K L' ◁ (homEquiv L' L'') g' ≫ sHomComp K L' L''

tactic: simp only [homEquiv_comp, MonoidalCategory.whiskerLeft_comp, assoc, ← e_assoc]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : SimplicialCategory C
K L L' L'' : C
g : L ⟶ L'
g' : L' ⟶ L''
⊢ (ρ_ (sHom K L)).inv ≫ sHom K L ◁ (homEquiv L L'') (g ≫ g') ≫ sHomComp K L L'' =
    ((ρ_ (sHom K L)).inv ≫ sHom K L ◁ (homEquiv L L') g ≫ sHomComp K L L') ≫
      (ρ_ (sHom K L')).inv ≫ sHom K L' ◁ (homEquiv L' L'') g' ≫ sHomComp K L' L''
state_after: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : SimplicialCategory C
K L L' L'' : C
g : L ⟶ L'
g' : L' ⟶ L''
⊢ (ρ_ (sHom K L)).inv ≫
      sHom K L ◁ (λ_ (𝟙_ SSet)).inv ≫
        sHom K L ◁ ((homEquiv L L') g ⊗ (homEquiv L' L'') g') ≫
          (α_ (EnrichedCategory.Hom K L) (EnrichedCategory.Hom L L') (EnrichedCategory.Hom L' L'')).inv ≫
            eComp SSet K L L' ▷ EnrichedCategory.Hom L' L'' ≫ eComp SSet K L' L'' =
    (ρ_ (sHom K L)).inv ≫
      sHom K L ◁ (homEquiv L L') g ≫
        sHomComp K L L' ≫ (ρ_ (sHom K L')).inv ≫ sHom K L' ◁ (homEquiv L' L'') g' ≫ sHomComp K L' L''

tactic: rfl
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : SimplicialCategory C
K L L' L'' : C
g : L ⟶ L'
g' : L' ⟶ L''
⊢ (ρ_ (sHom K L)).inv ≫
      sHom K L ◁ (λ_ (𝟙_ SSet)).inv ≫
        sHom K L ◁ ((homEquiv L L') g ⊗ (homEquiv L' L'') g') ≫
          (α_ (EnrichedCategory.Hom K L) (EnrichedCategory.Hom L L') (EnrichedCategory.Hom L' L'')).inv ≫
            eComp SSet K L L' ▷ EnrichedCategory.Hom L' L'' ≫ eComp SSet K L' L'' =
    (ρ_ (sHom K L)).inv ≫
      sHom K L ◁ (homEquiv L L') g ≫
        sHomComp K L L' ≫ (ρ_ (sHom K L')).inv ≫ sHom K L' ◁ (homEquiv L' L'') g' ≫ sHomComp K L' L''
state_after: no goals
Theorem: ProbabilityTheory.IsMeasurableRatCDF.measurable_stieltjesFunction
File: Mathlib/Probability/Kernel/Disintegration/MeasurableStieltjes.lean

tactic: have : (fun a ↦ hf.stieltjesFunction a x) = fun a ↦ ⨅ r : { r' : ℚ // x < r' }, f a ↑r := by
  ext1 a
  rw [← StieltjesFunction.iInf_rat_gt_eq]
  congr with q
  rw [stieltjesFunction_eq]
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : MeasurableSpace α
f : α → ℚ → ℝ
hf : IsMeasurableRatCDF f
x : ℝ
⊢ Measurable fun a => ↑(hf.stieltjesFunction a) x
state_after: α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : MeasurableSpace α
f : α → ℚ → ℝ
hf : IsMeasurableRatCDF f
x : ℝ
this : (fun a => ↑(hf.stieltjesFunction a) x) = fun a => ⨅ r, f a ↑r
⊢ Measurable fun a => ↑(hf.stieltjesFunction a) x

tactic: rw [this]
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : MeasurableSpace α
f : α → ℚ → ℝ
hf : IsMeasurableRatCDF f
x : ℝ
this : (fun a => ↑(hf.stieltjesFunction a) x) = fun a => ⨅ r, f a ↑r
⊢ Measurable fun a => ↑(hf.stieltjesFunction a) x
state_after: α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : MeasurableSpace α
f : α → ℚ → ℝ
hf : IsMeasurableRatCDF f
x : ℝ
this : (fun a => ↑(hf.stieltjesFunction a) x) = fun a => ⨅ r, f a ↑r
⊢ Measurable fun a => ⨅ r, f a ↑r

tactic: exact measurable_iInf (fun q ↦ hf.measurable.eval)
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : MeasurableSpace α
f : α → ℚ → ℝ
hf : IsMeasurableRatCDF f
x : ℝ
this : (fun a => ↑(hf.stieltjesFunction a) x) = fun a => ⨅ r, f a ↑r
⊢ Measurable fun a => ⨅ r, f a ↑r
state_after: no goals

tactic: ext1 a
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : MeasurableSpace α
f : α → ℚ → ℝ
hf : IsMeasurableRatCDF f
x : ℝ
⊢ (fun a => ↑(hf.stieltjesFunction a) x) = fun a => ⨅ r, f a ↑r
state_after: case h
α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : MeasurableSpace α
f : α → ℚ → ℝ
hf : IsMeasurableRatCDF f
x : ℝ
a : α
⊢ ↑(hf.stieltjesFunction a) x = ⨅ r, f a ↑r

tactic: rw [← StieltjesFunction.iInf_rat_gt_eq]
state_before: case h
α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : MeasurableSpace α
f : α → ℚ → ℝ
hf : IsMeasurableRatCDF f
x : ℝ
a : α
⊢ ↑(hf.stieltjesFunction a) x = ⨅ r, f a ↑r
state_after: case h
α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : MeasurableSpace α
f : α → ℚ → ℝ
hf : IsMeasurableRatCDF f
x : ℝ
a : α
⊢ ⨅ r, ↑(hf.stieltjesFunction a) ↑↑r = ⨅ r, f a ↑r

tactic: congr with q
state_before: case h
α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : MeasurableSpace α
f : α → ℚ → ℝ
hf : IsMeasurableRatCDF f
x : ℝ
a : α
⊢ ⨅ r, ↑(hf.stieltjesFunction a) ↑↑r = ⨅ r, f a ↑r
state_after: case h.e_s.h
α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : MeasurableSpace α
f : α → ℚ → ℝ
hf : IsMeasurableRatCDF f
x : ℝ
a : α
q : { r' // x < ↑r' }
⊢ ↑(hf.stieltjesFunction a) ↑↑q = f a ↑q

tactic: rw [stieltjesFunction_eq]
state_before: case h.e_s.h
α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : MeasurableSpace α
f : α → ℚ → ℝ
hf : IsMeasurableRatCDF f
x : ℝ
a : α
q : { r' // x < ↑r' }
⊢ ↑(hf.stieltjesFunction a) ↑↑q = f a ↑q
state_after: no goals
Theorem: Polynomial.map_comp
File: Mathlib/Algebra/Polynomial/Eval.lean

tactic: simp only [map_C, forall_const, C_comp, eq_self_iff_true]
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝¹ : Semiring R
p✝ q✝ r : R[X]
inst✝ : Semiring S
f : R →+* S
p q : R[X]
⊢ ∀ (a : R), map f ((C a).comp q) = (map f (C a)).comp (map f q)
state_after: no goals

tactic: simp (config := { contextual := true }) only [Polynomial.map_add, add_comp, forall_const,
  imp_true_iff, eq_self_iff_true]
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝¹ : Semiring R
p✝ q✝ r : R[X]
inst✝ : Semiring S
f : R →+* S
p q : R[X]
⊢ ∀ (p q_1 : R[X]),
    map f (p.comp q) = (map f p).comp (map f q) →
      map f (q_1.comp q) = (map f q_1).comp (map f q) → map f ((p + q_1).comp q) = (map f (p + q_1)).comp (map f q)
state_after: no goals

tactic: simp (config := { contextual := true }) only [pow_succ, ← mul_assoc, comp, forall_const,
  eval₂_mul_X, imp_true_iff, eq_self_iff_true, map_X, Polynomial.map_mul]
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝¹ : Semiring R
p✝ q✝ r : R[X]
inst✝ : Semiring S
f : R →+* S
p q : R[X]
⊢ ∀ (n : ℕ) (a : R),
    map f ((C a * X ^ n).comp q) = (map f (C a * X ^ n)).comp (map f q) →
      map f ((C a * X ^ (n + 1)).comp q) = (map f (C a * X ^ (n + 1))).comp (map f q)
state_after: no goals
Theorem: span_gcd
File: Mathlib/RingTheory/PrincipalIdealDomain.lean

tactic: rw [← IsBezout.span_gcd, IsBezout.span_gcd_eq_span_gcd]
state_before: R : Type u
M : Type v
inst✝³ : CommRing R
inst✝² : IsDomain R
inst✝¹ : IsBezout R
inst✝ : GCDMonoid R
x y : R
⊢ Ideal.span {gcd x y} = Ideal.span {x, y}
state_after: no goals
Theorem: String.front_eq
File: .lake/packages/batteries/Batteries/Data/String/Lemmas.lean

tactic: unfold front
state_before: s : String
⊢ s.front = s.data.headD default
state_after: s : String
⊢ s.get 0 = s.data.headD default

tactic: exact get_of_valid [] s.1
state_before: s : String
⊢ s.get 0 = s.data.headD default
state_after: no goals
Theorem: descPochhammer_eval_eq_descFactorial
File: Mathlib/RingTheory/Polynomial/Pochhammer.lean

tactic: rw [descPochhammer_zero, eval_one, Nat.descFactorial_zero, Nat.cast_one]
state_before: case zero
R : Type u
inst✝ : Ring R
n : ℕ
⊢ eval (↑n) (descPochhammer R 0) = ↑(n.descFactorial 0)
state_after: no goals

tactic: rw [descPochhammer_succ_right, Nat.descFactorial_succ, mul_sub, eval_sub, eval_mul_X,
  ← Nat.cast_comm k, eval_natCast_mul, ← Nat.cast_comm n, ← sub_mul, ih]
state_before: case succ
R : Type u
inst✝ : Ring R
n k : ℕ
ih : eval (↑n) (descPochhammer R k) = ↑(n.descFactorial k)
⊢ eval (↑n) (descPochhammer R (k + 1)) = ↑(n.descFactorial (k + 1))
state_after: case succ
R : Type u
inst✝ : Ring R
n k : ℕ
ih : eval (↑n) (descPochhammer R k) = ↑(n.descFactorial k)
⊢ (↑n - ↑k) * ↑(n.descFactorial k) = ↑((n - k) * n.descFactorial k)

tactic: by_cases h : n < k
state_before: case succ
R : Type u
inst✝ : Ring R
n k : ℕ
ih : eval (↑n) (descPochhammer R k) = ↑(n.descFactorial k)
⊢ (↑n - ↑k) * ↑(n.descFactorial k) = ↑((n - k) * n.descFactorial k)
state_after: case pos
R : Type u
inst✝ : Ring R
n k : ℕ
ih : eval (↑n) (descPochhammer R k) = ↑(n.descFactorial k)
h : n < k
⊢ (↑n - ↑k) * ↑(n.descFactorial k) = ↑((n - k) * n.descFactorial k)

case neg
R : Type u
inst✝ : Ring R
n k : ℕ
ih : eval (↑n) (descPochhammer R k) = ↑(n.descFactorial k)
h : ¬n < k
⊢ (↑n - ↑k) * ↑(n.descFactorial k) = ↑((n - k) * n.descFactorial k)

tactic: rw [Nat.descFactorial_eq_zero_iff_lt.mpr h, Nat.cast_zero, mul_zero, mul_zero, Nat.cast_zero]
state_before: case pos
R : Type u
inst✝ : Ring R
n k : ℕ
ih : eval (↑n) (descPochhammer R k) = ↑(n.descFactorial k)
h : n < k
⊢ (↑n - ↑k) * ↑(n.descFactorial k) = ↑((n - k) * n.descFactorial k)
state_after: no goals

tactic: rw [Nat.cast_mul, Nat.cast_sub <| not_lt.mp h]
state_before: case neg
R : Type u
inst✝ : Ring R
n k : ℕ
ih : eval (↑n) (descPochhammer R k) = ↑(n.descFactorial k)
h : ¬n < k
⊢ (↑n - ↑k) * ↑(n.descFactorial k) = ↑((n - k) * n.descFactorial k)
state_after: no goals
Theorem: Complex.log_mul_ofReal
File: Mathlib/Analysis/SpecialFunctions/Complex/Log.lean

tactic: rw [mul_comm, log_ofReal_mul hr hx]
state_before: r : ℝ
hr : 0 < r
x : ℂ
hx : x ≠ 0
⊢ log (x * ↑r) = ↑(Real.log r) + log x
state_after: no goals