ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: LieModule.weightSpaceChain_neg
File: Mathlib/Algebra/Lie/Weights/Chain.lean

Proof steps:
state_before: R : Type u_1
L : Type u_2
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
M : Type u_3
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : LieRingModule L M
inst✝¹ : LieModule R L M
inst✝ : LieAlgebra.IsNilpotent R L
χ₁ χ₂ : L → R
p q : ℤ
⊢ weightSpaceChain M (-χ₁) χ₂ (-q) (-p) = weightSpaceChain M χ₁ χ₂ p q
state_after: R : Type u_1
L : Type u_2
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
M : Type u_3
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : LieRingModule L M
inst✝¹ : LieModule R L M
inst✝ : LieAlgebra.IsNilpotent R L
χ₁ χ₂ : L → R
p q : ℤ
e : ℤ ≃ ℤ := Involutive.toPerm Neg.neg ⋯
⊢ weightSpaceChain M (-χ₁) χ₂ (-q) (-p) = weightSpaceChain M χ₁ χ₂ p q
tactic: let e : ℤ ≃ ℤ := neg_involutive.toPerm
state_before: R : Type u_1
L : Type u_2
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
M : Type u_3
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : LieRingModule L M
inst✝¹ : LieModule R L M
inst✝ : LieAlgebra.IsNilpotent R L
χ₁ χ₂ : L → R
p q : ℤ
e : ℤ ≃ ℤ := Involutive.toPerm Neg.neg ⋯
⊢ weightSpaceChain M (-χ₁) χ₂ (-q) (-p) = weightSpaceChain M χ₁ χ₂ p q
state_after: R : Type u_1
L : Type u_2
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
M : Type u_3
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : LieRingModule L M
inst✝¹ : LieModule R L M
inst✝ : LieAlgebra.IsNilpotent R L
χ₁ χ₂ : L → R
p q : ℤ
e : ℤ ≃ ℤ := Involutive.toPerm Neg.neg ⋯
⊢ ⨆ k ∈ Ioo (-q) (-p), weightSpace M (k • -χ₁ + χ₂) = ⨆ i ∈ ⇑e.symm '' Ioo p q, weightSpace M (e i • χ₁ + χ₂)
tactic: simp_rw [weightSpaceChain, ← e.biSup_comp (Ioo p q)]
state_before: R : Type u_1
L : Type u_2
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
M : Type u_3
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : LieRingModule L M
inst✝¹ : LieModule R L M
inst✝ : LieAlgebra.IsNilpotent R L
χ₁ χ₂ : L → R
p q : ℤ
e : ℤ ≃ ℤ := Involutive.toPerm Neg.neg ⋯
⊢ ⨆ k ∈ Ioo (-q) (-p), weightSpace M (k • -χ₁ + χ₂) = ⨆ i ∈ ⇑e.symm '' Ioo p q, weightSpace M (e i • χ₁ + χ₂)
state_after: no goals
tactic: simp [e, -mem_Ioo, neg_mem_Ioo_iff]
Theorem: CategoryTheory.Limits.BinaryBiconeMorphism.ext
File: Mathlib/CategoryTheory/Limits/Shapes/Biproducts.lean

Proof steps:
state_before: J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
D : Type uD
inst✝¹ : Category.{uD', uD} D
inst✝ : HasZeroMorphisms D
P Q : C
c c' : BinaryBicone P Q
f g : c ⟶ c'
w : f.hom = g.hom
⊢ f = g
state_after: case mk
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
D : Type uD
inst✝¹ : Category.{uD', uD} D
inst✝ : HasZeroMorphisms D
P Q : C
c c' : BinaryBicone P Q
g : c ⟶ c'
hom✝ : c.pt ⟶ c'.pt
wfst✝ : hom✝ ≫ c'.fst = c.fst
wsnd✝ : hom✝ ≫ c'.snd = c.snd
winl✝ : c.inl ≫ hom✝ = c'.inl
winr✝ : c.inr ≫ hom✝ = c'.inr
w : { hom := hom✝, wfst := wfst✝, wsnd := wsnd✝, winl := winl✝, winr := winr✝ }.hom = g.hom
⊢ { hom := hom✝, wfst := wfst✝, wsnd := wsnd✝, winl := winl✝, winr := winr✝ } = g
tactic: cases f
state_before: case mk
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
D : Type uD
inst✝¹ : Category.{uD', uD} D
inst✝ : HasZeroMorphisms D
P Q : C
c c' : BinaryBicone P Q
g : c ⟶ c'
hom✝ : c.pt ⟶ c'.pt
wfst✝ : hom✝ ≫ c'.fst = c.fst
wsnd✝ : hom✝ ≫ c'.snd = c.snd
winl✝ : c.inl ≫ hom✝ = c'.inl
winr✝ : c.inr ≫ hom✝ = c'.inr
w : { hom := hom✝, wfst := wfst✝, wsnd := wsnd✝, winl := winl✝, winr := winr✝ }.hom = g.hom
⊢ { hom := hom✝, wfst := wfst✝, wsnd := wsnd✝, winl := winl✝, winr := winr✝ } = g
state_after: case mk.mk
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
D : Type uD
inst✝¹ : Category.{uD', uD} D
inst✝ : HasZeroMorphisms D
P Q : C
c c' : BinaryBicone P Q
hom✝¹ : c.pt ⟶ c'.pt
wfst✝¹ : hom✝¹ ≫ c'.fst = c.fst
wsnd✝¹ : hom✝¹ ≫ c'.snd = c.snd
winl✝¹ : c.inl ≫ hom✝¹ = c'.inl
winr✝¹ : c.inr ≫ hom✝¹ = c'.inr
hom✝ : c.pt ⟶ c'.pt
wfst✝ : hom✝ ≫ c'.fst = c.fst
wsnd✝ : hom✝ ≫ c'.snd = c.snd
winl✝ : c.inl ≫ hom✝ = c'.inl
winr✝ : c.inr ≫ hom✝ = c'.inr
w :
  { hom := hom✝¹, wfst := wfst✝¹, wsnd := wsnd✝¹, winl := winl✝¹, winr := winr✝¹ }.hom =
    { hom := hom✝, wfst := wfst✝, wsnd := wsnd✝, winl := winl✝, winr := winr✝ }.hom
⊢ { hom := hom✝¹, wfst := wfst✝¹, wsnd := wsnd✝¹, winl := winl✝¹, winr := winr✝¹ } =
    { hom := hom✝, wfst := wfst✝, wsnd := wsnd✝, winl := winl✝, winr := winr✝ }
tactic: cases g
state_before: case mk.mk
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
D : Type uD
inst✝¹ : Category.{uD', uD} D
inst✝ : HasZeroMorphisms D
P Q : C
c c' : BinaryBicone P Q
hom✝¹ : c.pt ⟶ c'.pt
wfst✝¹ : hom✝¹ ≫ c'.fst = c.fst
wsnd✝¹ : hom✝¹ ≫ c'.snd = c.snd
winl✝¹ : c.inl ≫ hom✝¹ = c'.inl
winr✝¹ : c.inr ≫ hom✝¹ = c'.inr
hom✝ : c.pt ⟶ c'.pt
wfst✝ : hom✝ ≫ c'.fst = c.fst
wsnd✝ : hom✝ ≫ c'.snd = c.snd
winl✝ : c.inl ≫ hom✝ = c'.inl
winr✝ : c.inr ≫ hom✝ = c'.inr
w :
  { hom := hom✝¹, wfst := wfst✝¹, wsnd := wsnd✝¹, winl := winl✝¹, winr := winr✝¹ }.hom =
    { hom := hom✝, wfst := wfst✝, wsnd := wsnd✝, winl := winl✝, winr := winr✝ }.hom
⊢ { hom := hom✝¹, wfst := wfst✝¹, wsnd := wsnd✝¹, winl := winl✝¹, winr := winr✝¹ } =
    { hom := hom✝, wfst := wfst✝, wsnd := wsnd✝, winl := winl✝, winr := winr✝ }
state_after: no goals
tactic: congr
Theorem: FirstOrder.Language.Substructure.cg_iff_countable
File: Mathlib/ModelTheory/FinitelyGenerated.lean

Proof steps:
state_before: L : Language
M : Type u_1
inst✝¹ : L.Structure M
inst✝ : Countable ((l : ℕ) × L.Functions l)
s : L.Substructure M
⊢ s.CG ↔ Countable ↥s
state_after: L : Language
M : Type u_1
inst✝¹ : L.Structure M
inst✝ : Countable ((l : ℕ) × L.Functions l)
s : L.Substructure M
⊢ s.CG → Countable ↥s
tactic: refine ⟨?_, fun h => ⟨s, h.to_set, s.closure_eq⟩⟩
state_before: L : Language
M : Type u_1
inst✝¹ : L.Structure M
inst✝ : Countable ((l : ℕ) × L.Functions l)
s : L.Substructure M
⊢ s.CG → Countable ↥s
state_after: case intro.intro
L : Language
M : Type u_1
inst✝¹ : L.Structure M
inst✝ : Countable ((l : ℕ) × L.Functions l)
s : Set M
h : s.Countable
⊢ Countable ↥((closure L).toFun s)
tactic: rintro ⟨s, h, rfl⟩
state_before: case intro.intro
L : Language
M : Type u_1
inst✝¹ : L.Structure M
inst✝ : Countable ((l : ℕ) × L.Functions l)
s : Set M
h : s.Countable
⊢ Countable ↥((closure L).toFun s)
state_after: no goals
tactic: exact h.substructure_closure L
Theorem: MeasureTheory.Integrable.fourier_inversion_inv
File: Mathlib/Analysis/Fourier/Inversion.lean

Proof steps:
state_before: V : Type u_1
E : Type u_2
inst✝⁷ : NormedAddCommGroup V
inst✝⁶ : InnerProductSpace ℝ V
inst✝⁵ : MeasurableSpace V
inst✝⁴ : BorelSpace V
inst✝³ : FiniteDimensional ℝ V
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
f : V → E
inst✝ : CompleteSpace E
hf : Integrable f volume
h'f : Integrable (𝓕 f) volume
v : V
hv : ContinuousAt f v
⊢ 𝓕 (𝓕⁻ f) v = f v
state_after: V : Type u_1
E : Type u_2
inst✝⁷ : NormedAddCommGroup V
inst✝⁶ : InnerProductSpace ℝ V
inst✝⁵ : MeasurableSpace V
inst✝⁴ : BorelSpace V
inst✝³ : FiniteDimensional ℝ V
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
f : V → E
inst✝ : CompleteSpace E
hf : Integrable f volume
h'f : Integrable (𝓕 f) volume
v : V
hv : ContinuousAt f v
⊢ 𝓕⁻ (𝓕 f) v = f v
tactic: rw [fourierIntegralInv_comm]
state_before: V : Type u_1
E : Type u_2
inst✝⁷ : NormedAddCommGroup V
inst✝⁶ : InnerProductSpace ℝ V
inst✝⁵ : MeasurableSpace V
inst✝⁴ : BorelSpace V
inst✝³ : FiniteDimensional ℝ V
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
f : V → E
inst✝ : CompleteSpace E
hf : Integrable f volume
h'f : Integrable (𝓕 f) volume
v : V
hv : ContinuousAt f v
⊢ 𝓕⁻ (𝓕 f) v = f v
state_after: no goals
tactic: exact fourier_inversion hf h'f hv
Theorem: intervalIntegral.intervalIntegrable_cpow'
File: Mathlib/Analysis/SpecialFunctions/Integrals.lean

Proof steps:
state_before: a b : ℝ
n : ℕ
f : ℝ → ℝ
μ ν : Measure ℝ
inst✝ : IsLocallyFiniteMeasure μ
c d : ℝ
r : ℂ
h : -1 < r.re
⊢ IntervalIntegrable (fun x => ↑x ^ r) volume a b
state_after: a b : ℝ
n : ℕ
f : ℝ → ℝ
μ ν : Measure ℝ
inst✝ : IsLocallyFiniteMeasure μ
c d : ℝ
r : ℂ
h : -1 < r.re
⊢ ∀ (c : ℝ), IntervalIntegrable (fun x => ↑x ^ r) volume 0 c
tactic: suffices ∀ c : ℝ, IntervalIntegrable (fun x => (x : ℂ) ^ r) volume 0 c by
    exact IntervalIntegrable.trans (this a).symm (this b)
state_before: a b : ℝ
n : ℕ
f : ℝ → ℝ
μ ν : Measure ℝ
inst✝ : IsLocallyFiniteMeasure μ
c d : ℝ
r : ℂ
h : -1 < r.re
this : ∀ (c : ℝ), 0 ≤ c → IntervalIntegrable (fun x => ↑x ^ r) volume 0 c
⊢ ∀ (c : ℝ), IntervalIntegrable (fun x => ↑x ^ r) volume 0 c
state_after: a b : ℝ
n : ℕ
f : ℝ → ℝ
μ ν : Measure ℝ
inst✝ : IsLocallyFiniteMeasure μ
c✝ d : ℝ
r : ℂ
h : -1 < r.re
this : ∀ (c : ℝ), 0 ≤ c → IntervalIntegrable (fun x => ↑x ^ r) volume 0 c
c : ℝ
⊢ IntervalIntegrable (fun x => ↑x ^ r) volume 0 c
tactic: intro c
state_before: a b : ℝ
n : ℕ
f : ℝ → ℝ
μ ν : Measure ℝ
inst✝ : IsLocallyFiniteMeasure μ
c✝ d : ℝ
r : ℂ
h : -1 < r.re
this : ∀ (c : ℝ), 0 ≤ c → IntervalIntegrable (fun x => ↑x ^ r) volume 0 c
c : ℝ
⊢ IntervalIntegrable (fun x => ↑x ^ r) volume 0 c
state_after: case inl
a b : ℝ
n : ℕ
f : ℝ → ℝ
μ ν : Measure ℝ
inst✝ : IsLocallyFiniteMeasure μ
c✝ d : ℝ
r : ℂ
h : -1 < r.re
this : ∀ (c : ℝ), 0 ≤ c → IntervalIntegrable (fun x => ↑x ^ r) volume 0 c
c : ℝ
hc : 0 ≤ c
⊢ IntervalIntegrable (fun x => ↑x ^ r) volume 0 c

case inr
a b : ℝ
n : ℕ
f : ℝ → ℝ
μ ν : Measure ℝ
inst✝ : IsLocallyFiniteMeasure μ
c✝ d : ℝ
r : ℂ
h : -1 < r.re
this : ∀ (c : ℝ), 0 ≤ c → IntervalIntegrable (fun x => ↑x ^ r) volume 0 c
c : ℝ
hc : c ≤ 0
⊢ IntervalIntegrable (fun x => ↑x ^ r) volume 0 c
tactic: rcases le_total 0 c with (hc | hc)
Theorem: Real.sin_pi_div_eight
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

Proof steps:
state_before: x : ℝ
⊢ sin (π / 8) = √(2 - √2) / 2
state_after: x : ℝ
⊢ sin (π / 8) = sin (π / 2 ^ 3)

x : ℝ
⊢ sin (π / 2 ^ 3) = √(2 - √2) / 2
tactic: trans sin (π / 2 ^ 3)
Theorem: Fin.orderIsoSubtype_apply
File: Mathlib/Order/Fin/Basic.lean

Proof steps:
state_before: m n : ℕ
p : Fin (n + 1)
i j : Fin n
⊢ Monotone ⇑equivSubtype
state_after: no goals
tactic: simp [Monotone]
state_before: m n : ℕ
p : Fin (n + 1)
i j : Fin n
⊢ Monotone ⇑equivSubtype.symm
state_after: no goals
tactic: simp [Monotone]
Theorem: SetTheory.PGame.le_neg_iff
File: Mathlib/SetTheory/Game/PGame.lean

Proof steps:
state_before: xl xr : Type u
x y : PGame
⊢ y ≤ -x ↔ x ≤ -y
state_after: no goals
tactic: rw [← neg_neg x, neg_le_neg_iff, neg_neg]
Theorem: mem_sphere_zero_iff_norm
File: Mathlib/Analysis/Normed/Group/Basic.lean

Proof steps:
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₂ : ℝ
⊢ a ∈ sphere 1 r ↔ ‖a‖ = r
state_after: no goals
tactic: simp [dist_eq_norm_div]
Theorem: WeierstrassCurve.natDegree_preΨ_le
File: Mathlib/AlgebraicGeometry/EllipticCurve/DivisionPolynomial/Degree.lean

Proof steps:
state_before: R : Type u
inst✝ : CommRing R
W : WeierstrassCurve R
n : ℤ
⊢ (W.preΨ n).natDegree ≤ (n.natAbs ^ 2 - if Even n then 4 else 1) / 2
state_after: no goals
tactic: induction n using Int.negInduction with
  | nat n => exact_mod_cast W.preΨ_ofNat n ▸ W.natDegree_preΨ'_le n
  | neg => simpa only [preΨ_neg, natDegree_neg, Int.natAbs_neg, even_neg]
Theorem: Polynomial.monic_restriction
File: Mathlib/RingTheory/Polynomial/Basic.lean

Proof steps:
state_before: R : Type u
S : Type u_1
inst✝ : Ring R
p : R[X]
⊢ p.restriction.Monic ↔ p.Monic
state_after: R : Type u
S : Type u_1
inst✝ : Ring R
p : R[X]
⊢ p.restriction.coeff p.natDegree = 1 ↔ p.coeff p.natDegree = 1
tactic: simp only [Monic, leadingCoeff, natDegree_restriction]
state_before: R : Type u
S : Type u_1
inst✝ : Ring R
p : R[X]
⊢ p.restriction.coeff p.natDegree = 1 ↔ p.coeff p.natDegree = 1
state_after: R : Type u
S : Type u_1
inst✝ : Ring R
p : R[X]
⊢ p.restriction.coeff p.natDegree = 1 ↔ ↑(p.restriction.coeff p.natDegree) = 1
tactic: rw [← @coeff_restriction _ _ p]
state_before: R : Type u
S : Type u_1
inst✝ : Ring R
p : R[X]
⊢ p.restriction.coeff p.natDegree = 1 ↔ ↑(p.restriction.coeff p.natDegree) = 1
state_after: no goals
tactic: exact ⟨fun H => by rw [H, OneMemClass.coe_one], fun H => Subtype.coe_injective H⟩
Theorem: CategoryTheory.Presheaf.isLocallySurjective_comp_iff
File: Mathlib/CategoryTheory/Sites/LocallySurjective.lean

Proof steps:
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
J : GrothendieckTopology C
A : Type u'
inst✝³ : Category.{v', u'} A
inst✝² : ConcreteCategory A
F₁ F₂ F₃ : Cᵒᵖ ⥤ A
f₁ : F₁ ⟶ F₂
f₂ : F₂ ⟶ F₃
inst✝¹ : IsLocallyInjective J f₂
inst✝ : IsLocallySurjective J f₂
⊢ IsLocallySurjective J (f₁ ≫ f₂) ↔ IsLocallySurjective J f₁
state_after: case mp
C : Type u
inst✝⁴ : Category.{v, u} C
J : GrothendieckTopology C
A : Type u'
inst✝³ : Category.{v', u'} A
inst✝² : ConcreteCategory A
F₁ F₂ F₃ : Cᵒᵖ ⥤ A
f₁ : F₁ ⟶ F₂
f₂ : F₂ ⟶ F₃
inst✝¹ : IsLocallyInjective J f₂
inst✝ : IsLocallySurjective J f₂
⊢ IsLocallySurjective J (f₁ ≫ f₂) → IsLocallySurjective J f₁

case mpr
C : Type u
inst✝⁴ : Category.{v, u} C
J : GrothendieckTopology C
A : Type u'
inst✝³ : Category.{v', u'} A
inst✝² : ConcreteCategory A
F₁ F₂ F₃ : Cᵒᵖ ⥤ A
f₁ : F₁ ⟶ F₂
f₂ : F₂ ⟶ F₃
inst✝¹ : IsLocallyInjective J f₂
inst✝ : IsLocallySurjective J f₂
⊢ IsLocallySurjective J f₁ → IsLocallySurjective J (f₁ ≫ f₂)
tactic: constructor
Theorem: CategoryTheory.StructuredArrow.lift_projectSubobject
File: Mathlib/CategoryTheory/Subobject/Comma.lean

Proof steps:
state_before: C : Type u₁
inst✝³ : Category.{v, u₁} C
D : Type u₂
inst✝² : Category.{v, u₂} D
S : D
T : C ⥤ D
inst✝¹ : HasLimits C
inst✝ : PreservesLimits T
A : StructuredArrow S T
⊢ ∀ ⦃A_1 : StructuredArrow S T⦄ (f : A_1 ⟶ A) [inst : Mono f]
    {q : (Functor.fromPUnit S).obj A.left ⟶ T.obj (Subobject.underlying.obj (projectSubobject (Subobject.mk f)))}
    (hq : q ≫ T.map (projectSubobject (Subobject.mk f)).arrow = A.hom),
    liftSubobject (projectSubobject (Subobject.mk f)) hq = Subobject.mk f
state_after: C : Type u₁
inst✝³ : Category.{v, u₁} C
D : Type u₂
inst✝² : Category.{v, u₂} D
S : D
T : C ⥤ D
inst✝¹ : HasLimits C
inst✝ : PreservesLimits T
A P : StructuredArrow S T
f : P ⟶ A
hf : Mono f
q : (Functor.fromPUnit S).obj A.left ⟶ T.obj (Subobject.underlying.obj (projectSubobject (Subobject.mk f)))
hq : q ≫ T.map (projectSubobject (Subobject.mk f)).arrow = A.hom
⊢ liftSubobject (projectSubobject (Subobject.mk f)) hq = Subobject.mk f
tactic: intro P f hf q hq
state_before: C : Type u₁
inst✝³ : Category.{v, u₁} C
D : Type u₂
inst✝² : Category.{v, u₂} D
S : D
T : C ⥤ D
inst✝¹ : HasLimits C
inst✝ : PreservesLimits T
A P : StructuredArrow S T
f : P ⟶ A
hf : Mono f
q : (Functor.fromPUnit S).obj A.left ⟶ T.obj (Subobject.underlying.obj (projectSubobject (Subobject.mk f)))
hq : q ≫ T.map (projectSubobject (Subobject.mk f)).arrow = A.hom
⊢ liftSubobject (projectSubobject (Subobject.mk f)) hq = Subobject.mk f
state_after: case i
C : Type u₁
inst✝³ : Category.{v, u₁} C
D : Type u₂
inst✝² : Category.{v, u₂} D
S : D
T : C ⥤ D
inst✝¹ : HasLimits C
inst✝ : PreservesLimits T
A P : StructuredArrow S T
f : P ⟶ A
hf : Mono f
q : (Functor.fromPUnit S).obj A.left ⟶ T.obj (Subobject.underlying.obj (projectSubobject (Subobject.mk f)))
hq : q ≫ T.map (projectSubobject (Subobject.mk f)).arrow = A.hom
⊢ mk q ≅ P

case w
C : Type u₁
inst✝³ : Category.{v, u₁} C
D : Type u₂
inst✝² : Category.{v, u₂} D
S : D
T : C ⥤ D
inst✝¹ : HasLimits C
inst✝ : PreservesLimits T
A P : StructuredArrow S T
f : P ⟶ A
hf : Mono f
q : (Functor.fromPUnit S).obj A.left ⟶ T.obj (Subobject.underlying.obj (projectSubobject (Subobject.mk f)))
hq : q ≫ T.map (projectSubobject (Subobject.mk f)).arrow = A.hom
⊢ ?i.hom ≫ f = homMk (projectSubobject (Subobject.mk f)).arrow hq
tactic: fapply Subobject.mk_eq_mk_of_comm
Theorem: OrthonormalBasis.orthonormal_adjustToOrientation
File: Mathlib/Analysis/InnerProductSpace/Orientation.lean

Proof steps:
state_before: E : Type u_1
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace ℝ E
ι : Type u_2
inst✝¹ : Fintype ι
inst✝ : DecidableEq ι
ne : Nonempty ι
e f : OrthonormalBasis ι ℝ E
x : Orientation ℝ E ι
⊢ Orthonormal ℝ ⇑(e.toBasis.adjustToOrientation x)
state_after: E : Type u_1
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace ℝ E
ι : Type u_2
inst✝¹ : Fintype ι
inst✝ : DecidableEq ι
ne : Nonempty ι
e f : OrthonormalBasis ι ℝ E
x : Orientation ℝ E ι
⊢ ∀ (i : ι), (e.toBasis.adjustToOrientation x) i = e i ∨ (e.toBasis.adjustToOrientation x) i = -e i
tactic: apply e.orthonormal.orthonormal_of_forall_eq_or_eq_neg
state_before: E : Type u_1
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace ℝ E
ι : Type u_2
inst✝¹ : Fintype ι
inst✝ : DecidableEq ι
ne : Nonempty ι
e f : OrthonormalBasis ι ℝ E
x : Orientation ℝ E ι
⊢ ∀ (i : ι), (e.toBasis.adjustToOrientation x) i = e i ∨ (e.toBasis.adjustToOrientation x) i = -e i
state_after: no goals
tactic: simpa using e.toBasis.adjustToOrientation_apply_eq_or_eq_neg x
Theorem: Finset.exists_card_fiber_lt_of_card_lt_nsmul
File: Mathlib/Combinatorics/Pigeonhole.lean

Proof steps:
state_before: α : Type u
β : Type v
M : Type w
inst✝¹ : DecidableEq β
s : Finset α
t : Finset β
f : α → β
w : α → M
b : M
n : ℕ
inst✝ : LinearOrderedCommSemiring M
ht : ↑s.card < t.card • b
⊢ ∃ y ∈ t, ↑(filter (fun x => f x = y) s).card < b
state_after: α : Type u
β : Type v
M : Type w
inst✝¹ : DecidableEq β
s : Finset α
t : Finset β
f : α → β
w : α → M
b : M
n : ℕ
inst✝ : LinearOrderedCommSemiring M
ht : ∑ a ∈ s, 1 < t.card • b
⊢ ∃ y ∈ t, ∑ a ∈ filter (fun x => f x = y) s, 1 < b
tactic: simp_rw [cast_card] at ht ⊢
state_before: α : Type u
β : Type v
M : Type w
inst✝¹ : DecidableEq β
s : Finset α
t : Finset β
f : α → β
w : α → M
b : M
n : ℕ
inst✝ : LinearOrderedCommSemiring M
ht : ∑ a ∈ s, 1 < t.card • b
⊢ ∃ y ∈ t, ∑ a ∈ filter (fun x => f x = y) s, 1 < b
state_after: no goals
tactic: exact
    exists_sum_fiber_lt_of_sum_fiber_nonneg_of_sum_lt_nsmul
      (fun _ _ => sum_nonneg fun _ _ => zero_le_one) ht
Theorem: mem_measurableAtom_self
File: Mathlib/MeasureTheory/MeasurableSpace/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort uι
s t u : Set α
inst✝ : MeasurableSpace β
x : β
⊢ x ∈ measurableAtom x
state_after: no goals
tactic: simp (config := {contextual := true}) [measurableAtom]
Theorem: CategoryTheory.Comonad.comparison_map_f
File: Mathlib/CategoryTheory/Monad/Adjunction.lean

Proof steps:
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
L : C ⥤ D
R : D ⥤ C
h : L ⊣ R
X : C
⊢ L.map (h.unit.app X) ≫ h.toComonad.δ.app (L.obj X) = L.map (h.unit.app X) ≫ h.toComonad.map (L.map (h.unit.app X))
state_after: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
L : C ⥤ D
R : D ⥤ C
h : L ⊣ R
X : C
⊢ L.map (h.unit.app X) ≫ L.map (h.unit.app (R.obj (L.obj X))) =
    L.map (h.unit.app X) ≫ L.map (R.map (L.map (h.unit.app X)))
tactic: dsimp
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
L : C ⥤ D
R : D ⥤ C
h : L ⊣ R
X : C
⊢ L.map (h.unit.app X) ≫ L.map (h.unit.app (R.obj (L.obj X))) =
    L.map (h.unit.app X) ≫ L.map (R.map (L.map (h.unit.app X)))
state_after: no goals
tactic: rw [← L.map_comp, ← Adjunction.unit_naturality, L.map_comp]
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
L : C ⥤ D
R : D ⥤ C
h : L ⊣ R
X✝ Y✝ : C
f : X✝ ⟶ Y✝
⊢ ((fun X => { A := L.obj X, a := L.map (h.unit.app X), counit := ⋯, coassoc := ⋯ }) X✝).a ≫ h.toComonad.map (L.map f) =
    L.map f ≫ ((fun X => { A := L.obj X, a := L.map (h.unit.app X), counit := ⋯, coassoc := ⋯ }) Y✝).a
state_after: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
L : C ⥤ D
R : D ⥤ C
h : L ⊣ R
X✝ Y✝ : C
f : X✝ ⟶ Y✝
⊢ L.map (h.unit.app X✝) ≫ L.map (R.map (L.map f)) = L.map f ≫ L.map (h.unit.app Y✝)
tactic: dsimp
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
L : C ⥤ D
R : D ⥤ C
h : L ⊣ R
X✝ Y✝ : C
f : X✝ ⟶ Y✝
⊢ L.map (h.unit.app X✝) ≫ L.map (R.map (L.map f)) = L.map f ≫ L.map (h.unit.app Y✝)
state_after: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
L : C ⥤ D
R : D ⥤ C
h : L ⊣ R
X✝ Y✝ : C
f : X✝ ⟶ Y✝
⊢ L.map (h.unit.app X✝ ≫ R.map (L.map f)) = L.map f ≫ L.map (h.unit.app Y✝)
tactic: rw [← L.map_comp]
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
L : C ⥤ D
R : D ⥤ C
h : L ⊣ R
X✝ Y✝ : C
f : X✝ ⟶ Y✝
⊢ L.map (h.unit.app X✝ ≫ R.map (L.map f)) = L.map f ≫ L.map (h.unit.app Y✝)
state_after: no goals
tactic: simp
Theorem: TensorProduct.finsuppScalarRight_apply_tmul
File: Mathlib/LinearAlgebra/DirectSum/Finsupp.lean

Proof steps:
state_before: R : Type u_1
inst✝⁹ : CommSemiring R
M : Type u_2
inst✝⁸ : AddCommMonoid M
inst✝⁷ : Module R M
N : Type u_3
inst✝⁶ : AddCommMonoid N
inst✝⁵ : Module R N
ι : Type u_4
inst✝⁴ : DecidableEq ι
S : Type u_5
inst✝³ : CommSemiring S
inst✝² : Algebra R S
inst✝¹ : Module S M
inst✝ : IsScalarTower R S M
m : M
p : ι →₀ R
⊢ (finsuppScalarRight R M ι) (m ⊗ₜ[R] p) = p.sum fun i n => Finsupp.single i (n • m)
state_after: case h
R : Type u_1
inst✝⁹ : CommSemiring R
M : Type u_2
inst✝⁸ : AddCommMonoid M
inst✝⁷ : Module R M
N : Type u_3
inst✝⁶ : AddCommMonoid N
inst✝⁵ : Module R N
ι : Type u_4
inst✝⁴ : DecidableEq ι
S : Type u_5
inst✝³ : CommSemiring S
inst✝² : Algebra R S
inst✝¹ : Module S M
inst✝ : IsScalarTower R S M
m : M
p : ι →₀ R
i : ι
⊢ ((finsuppScalarRight R M ι) (m ⊗ₜ[R] p)) i = (p.sum fun i n => Finsupp.single i (n • m)) i
tactic: ext i
state_before: case h
R : Type u_1
inst✝⁹ : CommSemiring R
M : Type u_2
inst✝⁸ : AddCommMonoid M
inst✝⁷ : Module R M
N : Type u_3
inst✝⁶ : AddCommMonoid N
inst✝⁵ : Module R N
ι : Type u_4
inst✝⁴ : DecidableEq ι
S : Type u_5
inst✝³ : CommSemiring S
inst✝² : Algebra R S
inst✝¹ : Module S M
inst✝ : IsScalarTower R S M
m : M
p : ι →₀ R
i : ι
⊢ ((finsuppScalarRight R M ι) (m ⊗ₜ[R] p)) i = (p.sum fun i n => Finsupp.single i (n • m)) i
state_after: no goals
tactic: rw [finsuppScalarRight_apply_tmul_apply, Finsupp.sum_apply,
    Finsupp.sum_eq_single i (fun _ _ ↦ Finsupp.single_eq_of_ne) (by simp), Finsupp.single_eq_same]
Theorem: isRegular_iff_ne_zero'
File: Mathlib/Algebra/Ring/Regular.lean

Proof steps:
state_before: α : Type u_1
inst✝² : Nontrivial α
inst✝¹ : NonUnitalNonAssocRing α
inst✝ : NoZeroDivisors α
k : α
h : IsRegular k
⊢ k ≠ 0
state_after: α : Type u_1
inst✝² : Nontrivial α
inst✝¹ : NonUnitalNonAssocRing α
inst✝ : NoZeroDivisors α
h : IsRegular 0
⊢ False
tactic: rintro rfl
state_before: α : Type u_1
inst✝² : Nontrivial α
inst✝¹ : NonUnitalNonAssocRing α
inst✝ : NoZeroDivisors α
h : IsRegular 0
⊢ False
state_after: no goals
tactic: exact not_not.mpr h.left not_isLeftRegular_zero