ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: CategoryTheory.Limits.biproduct.toSubtype_fromSubtype
File: Mathlib/CategoryTheory/Limits/Shapes/Biproducts.lean

Proof steps:
state_before: J : Type w
K : Type u_1
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroMorphisms C
f : J → C
inst✝² : HasBiproduct f
p : J → Prop
inst✝¹ : HasBiproduct (Subtype.restrict p f)
inst✝ : DecidablePred p
⊢ toSubtype f p ≫ fromSubtype f p = map fun j => if p j then 𝟙 (f j) else 0
state_after: case w
J : Type w
K : Type u_1
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroMorphisms C
f : J → C
inst✝² : HasBiproduct f
p : J → Prop
inst✝¹ : HasBiproduct (Subtype.restrict p f)
inst✝ : DecidablePred p
i : J
⊢ (toSubtype f p ≫ fromSubtype f p) ≫ π f i = (map fun j => if p j then 𝟙 (f j) else 0) ≫ π f i
tactic: ext1 i
state_before: case w
J : Type w
K : Type u_1
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroMorphisms C
f : J → C
inst✝² : HasBiproduct f
p : J → Prop
inst✝¹ : HasBiproduct (Subtype.restrict p f)
inst✝ : DecidablePred p
i : J
⊢ (toSubtype f p ≫ fromSubtype f p) ≫ π f i = (map fun j => if p j then 𝟙 (f j) else 0) ≫ π f i
state_after: case pos
J : Type w
K : Type u_1
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroMorphisms C
f : J → C
inst✝² : HasBiproduct f
p : J → Prop
inst✝¹ : HasBiproduct (Subtype.restrict p f)
inst✝ : DecidablePred p
i : J
h : p i
⊢ (toSubtype f p ≫ fromSubtype f p) ≫ π f i = (map fun j => if p j then 𝟙 (f j) else 0) ≫ π f i

case neg
J : Type w
K : Type u_1
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroMorphisms C
f : J → C
inst✝² : HasBiproduct f
p : J → Prop
inst✝¹ : HasBiproduct (Subtype.restrict p f)
inst✝ : DecidablePred p
i : J
h : ¬p i
⊢ (toSubtype f p ≫ fromSubtype f p) ≫ π f i = (map fun j => if p j then 𝟙 (f j) else 0) ≫ π f i
tactic: by_cases h : p i
Theorem: FractionalIdeal.one_le
File: Mathlib/RingTheory/FractionalIdeal/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝² : CommRing R
S : Submonoid R
P : Type u_2
inst✝¹ : CommRing P
inst✝ : Algebra R P
loc : IsLocalization S P
I : FractionalIdeal S P
⊢ 1 ≤ I ↔ 1 ∈ I
state_after: no goals
tactic: rw [← coe_le_coe, coe_one, Submodule.one_le, mem_coe]
Theorem: DiscreteValuationRing.addVal_le_iff_dvd
File: Mathlib/RingTheory/DiscreteValuationRing/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : DiscreteValuationRing R
a b : R
⊢ (addVal R) a ≤ (addVal R) b ↔ a ∣ b
state_after: R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : DiscreteValuationRing R
a b : R
hp : Prime (Classical.choose ⋯)
⊢ (addVal R) a ≤ (addVal R) b ↔ a ∣ b
tactic: have hp := Classical.choose_spec (exists_prime R)
state_before: R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : DiscreteValuationRing R
a b : R
hp : Prime (Classical.choose ⋯)
⊢ (addVal R) a ≤ (addVal R) b ↔ a ∣ b
state_after: case mp
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : DiscreteValuationRing R
a b : R
hp : Prime (Classical.choose ⋯)
h : (addVal R) a ≤ (addVal R) b
⊢ a ∣ b

case mpr
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : DiscreteValuationRing R
a b : R
hp : Prime (Classical.choose ⋯)
h : a ∣ b
⊢ (addVal R) a ≤ (addVal R) b
tactic: constructor <;> intro h
Theorem: dvd_add_right
File: Mathlib/Algebra/Ring/Divisibility/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : NonUnitalRing α
a b c : α
h : a ∣ b
⊢ a ∣ b + c ↔ a ∣ c
state_after: α : Type u_1
β : Type u_2
inst✝ : NonUnitalRing α
a b c : α
h : a ∣ b
⊢ a ∣ c + b ↔ a ∣ c
tactic: rw [add_comm]
state_before: α : Type u_1
β : Type u_2
inst✝ : NonUnitalRing α
a b c : α
h : a ∣ b
⊢ a ∣ c + b ↔ a ∣ c
state_after: no goals
tactic: exact dvd_add_left h
Theorem: Ideal.isIdempotentElem_iff_of_fg
File: Mathlib/RingTheory/Ideal/IdempotentFG.lean

Proof steps:
state_before: R : Type u_1
inst✝ : CommRing R
I : Ideal R
h : I.FG
⊢ IsIdempotentElem I ↔ ∃ e, IsIdempotentElem e ∧ I = Submodule.span R {e}
state_after: case mp
R : Type u_1
inst✝ : CommRing R
I : Ideal R
h : I.FG
⊢ IsIdempotentElem I → ∃ e, IsIdempotentElem e ∧ I = Submodule.span R {e}

case mpr
R : Type u_1
inst✝ : CommRing R
I : Ideal R
h : I.FG
⊢ (∃ e, IsIdempotentElem e ∧ I = Submodule.span R {e}) → IsIdempotentElem I
tactic: constructor
Theorem: LinearMap.flip_bijective_iff₁
File: Mathlib/LinearAlgebra/Dual.lean

Proof steps:
state_before: K : Type uK
inst✝⁵ : Field K
V₁ : Type uV₁
V₂ : Type uV₂
inst✝⁴ : AddCommGroup V₁
inst✝³ : Module K V₁
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
B : V₁ →ₗ[K] V₂ →ₗ[K] K
inst✝ : FiniteDimensional K V₁
⊢ Bijective ⇑B.flip ↔ Bijective ⇑B
state_after: no goals
tactic: simp_rw [Bijective, flip_injective_iff₁, flip_surjective_iff₁, and_comm]
Theorem: Booleanisation.lift_le_lift
File: Mathlib/Order/Booleanisation.lean

Proof steps:
state_before: α : Type u_1
inst✝ : GeneralizedBooleanAlgebra α
x y : Booleanisation α
a b : α
⊢ lift a ≤ lift b → a ≤ b
state_after: case lift
α : Type u_1
inst✝ : GeneralizedBooleanAlgebra α
x y : Booleanisation α
a b : α
a✝ : a ≤ b
⊢ a ≤ b
tactic: rintro ⟨_⟩
state_before: case lift
α : Type u_1
inst✝ : GeneralizedBooleanAlgebra α
x y : Booleanisation α
a b : α
a✝ : a ≤ b
⊢ a ≤ b
state_after: no goals
tactic: assumption
Theorem: CochainComplex.HomComplex.δ_comp_zero_cocycle
File: Mathlib/Algebra/Homology/HomotopyCategory/HomComplex.lean

Proof steps:
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
F G K L : CochainComplex C ℤ
n✝ m✝ n : ℤ
z₁ : Cochain F G n
z₂ : Cocycle G K 0
m : ℤ
⊢ δ n m (z₁.comp ↑z₂ ⋯) = (δ n m z₁).comp ↑z₂ ⋯
state_after: case pos
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
F G K L : CochainComplex C ℤ
n✝ m✝ n : ℤ
z₁ : Cochain F G n
z₂ : Cocycle G K 0
m : ℤ
hnm : n + 1 = m
⊢ δ n m (z₁.comp ↑z₂ ⋯) = (δ n m z₁).comp ↑z₂ ⋯

case neg
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
F G K L : CochainComplex C ℤ
n✝ m✝ n : ℤ
z₁ : Cochain F G n
z₂ : Cocycle G K 0
m : ℤ
hnm : ¬n + 1 = m
⊢ δ n m (z₁.comp ↑z₂ ⋯) = (δ n m z₁).comp ↑z₂ ⋯
tactic: by_cases hnm : n + 1 = m
Theorem: BoundedContinuousFunction.integral_const_sub
File: Mathlib/MeasureTheory/Integral/BoundedContinuousFunction.lean

Proof steps:
state_before: X : Type u_1
inst✝³ : TopologicalSpace X
inst✝² : MeasurableSpace X
inst✝¹ : OpensMeasurableSpace X
μ : Measure X
inst✝ : IsFiniteMeasure μ
f : X →ᵇ ℝ
c : ℝ
⊢ ∫ (x : X), (const X c - f) x ∂μ = (μ Set.univ).toReal • c - ∫ (x : X), f x ∂μ
state_after: no goals
tactic: simp [integral_sub (integrable_const c) (f.integrable _)]
Theorem: isSigmaCompact_iUnion_of_isCompact
File: Mathlib/Topology/Compactness/SigmaCompact.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
ι : Type u_3
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s✝ t : Set X
hι : Countable ι
s : ι → Set X
hcomp : ∀ (i : ι), IsCompact (s i)
⊢ IsSigmaCompact (⋃ i, s i)
state_after: case inl
X : Type u_1
Y : Type u_2
ι : Type u_3
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s✝ t : Set X
hι : Countable ι
s : ι → Set X
hcomp : ∀ (i : ι), IsCompact (s i)
h✝ : IsEmpty ι
⊢ IsSigmaCompact (⋃ i, s i)

case inr
X : Type u_1
Y : Type u_2
ι : Type u_3
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s✝ t : Set X
hι : Countable ι
s : ι → Set X
hcomp : ∀ (i : ι), IsCompact (s i)
h✝ : Nonempty ι
⊢ IsSigmaCompact (⋃ i, s i)
tactic: rcases isEmpty_or_nonempty ι
Theorem: Filter.HasAntitoneBasis.mem_iff
File: Mathlib/Order/Filter/Bases.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Sort u_5
inst✝ : Preorder ι
l : Filter α
s : ι → Set α
hs : l.HasAntitoneBasis s
t : Set α
⊢ (∃ i, True ∧ s i ⊆ t) ↔ ∃ i, s i ⊆ t
state_after: no goals
tactic: simp only [exists_prop, true_and]
Theorem: CategoryTheory.Functor.isIso_lanAdjunction_counit_app_iff
File: Mathlib/CategoryTheory/Functor/KanExtension/Adjunction.lean

Proof steps:
state_before: C : Type u_1
D : Type u_2
inst✝³ : Category.{u_6, u_1} C
inst✝² : Category.{u_4, u_2} D
L : C ⥤ D
H : Type u_3
inst✝¹ : Category.{u_5, u_3} H
inst✝ : ∀ (F : C ⥤ H), L.HasLeftKanExtension F
G : D ⥤ H
⊢ L.lanUnit.app (L ⋙ G) ≫ whiskerLeft L ((L.lanAdjunction H).counit.app G) = 𝟙 (L ⋙ G)
state_after: no goals
tactic: simp
Theorem: ZMod.ker_intCastAddHom
File: Mathlib/Data/ZMod/Basic.lean

Proof steps:
state_before: m n✝ n : ℕ
⊢ (Int.castAddHom (ZMod n)).ker = AddSubgroup.zmultiples ↑n
state_after: case h
m n✝ n : ℕ
x✝ : ℤ
⊢ x✝ ∈ (Int.castAddHom (ZMod n)).ker ↔ x✝ ∈ AddSubgroup.zmultiples ↑n
tactic: ext
state_before: case h
m n✝ n : ℕ
x✝ : ℤ
⊢ x✝ ∈ (Int.castAddHom (ZMod n)).ker ↔ x✝ ∈ AddSubgroup.zmultiples ↑n
state_after: no goals
tactic: rw [Int.mem_zmultiples_iff, AddMonoidHom.mem_ker, Int.coe_castAddHom,
    intCast_zmod_eq_zero_iff_dvd]
Theorem: FixedPoints.minpoly.monic
File: Mathlib/FieldTheory/Fixed.lean

Proof steps:
state_before: M : Type u
inst✝⁵ : Monoid M
G : Type u
inst✝⁴ : Group G
F : Type v
inst✝³ : Field F
inst✝² : MulSemiringAction M F
inst✝¹ : MulSemiringAction G F
m : M
inst✝ : Fintype G
x : F
⊢ (minpoly G F x).Monic
state_after: M : Type u
inst✝⁵ : Monoid M
G : Type u
inst✝⁴ : Group G
F : Type v
inst✝³ : Field F
inst✝² : MulSemiringAction M F
inst✝¹ : MulSemiringAction G F
m : M
inst✝ : Fintype G
x : F
⊢ (prodXSubSMul G F x).Monic
tactic: simp only [minpoly, Polynomial.monic_toSubring]
state_before: M : Type u
inst✝⁵ : Monoid M
G : Type u
inst✝⁴ : Group G
F : Type v
inst✝³ : Field F
inst✝² : MulSemiringAction M F
inst✝¹ : MulSemiringAction G F
m : M
inst✝ : Fintype G
x : F
⊢ (prodXSubSMul G F x).Monic
state_after: no goals
tactic: exact prodXSubSMul.monic G F x
Theorem: Rat.mk'_mul_mk'
File: Mathlib/Data/Rat/Defs.lean

Proof steps:
state_before: q : ℚ
n₁ n₂ : ℤ
d₁ d₂ : ℕ
hd₁ : d₁ ≠ 0
hd₂ : d₂ ≠ 0
hnd₁ : n₁.natAbs.Coprime d₁
hnd₂ : n₂.natAbs.Coprime d₂
h₁₂ : n₁.natAbs.Coprime d₂
h₂₁ : n₂.natAbs.Coprime d₁
⊢ (n₁ * n₂).natAbs.Coprime (d₁ * d₂)
state_after: q : ℚ
n₁ n₂ : ℤ
d₁ d₂ : ℕ
hd₁ : d₁ ≠ 0
hd₂ : d₂ ≠ 0
hnd₁ : n₁.natAbs.Coprime d₁
hnd₂ : n₂.natAbs.Coprime d₂
h₁₂ : n₁.natAbs.Coprime d₂
h₂₁ : n₂.natAbs.Coprime d₁
⊢ (n₁.natAbs * n₂.natAbs).Coprime (d₁ * d₂)
tactic: rw [Int.natAbs_mul]
state_before: q : ℚ
n₁ n₂ : ℤ
d₁ d₂ : ℕ
hd₁ : d₁ ≠ 0
hd₂ : d₂ ≠ 0
hnd₁ : n₁.natAbs.Coprime d₁
hnd₂ : n₂.natAbs.Coprime d₂
h₁₂ : n₁.natAbs.Coprime d₂
h₂₁ : n₂.natAbs.Coprime d₁
⊢ (n₁.natAbs * n₂.natAbs).Coprime (d₁ * d₂)
state_after: no goals
tactic: exact (hnd₁.mul h₂₁).mul_right (h₁₂.mul hnd₂)
state_before: q : ℚ
n₁ n₂ : ℤ
d₁ d₂ : ℕ
hd₁ : d₁ ≠ 0
hd₂ : d₂ ≠ 0
hnd₁ : n₁.natAbs.Coprime d₁
hnd₂ : n₂.natAbs.Coprime d₂
h₁₂ : n₁.natAbs.Coprime d₂
h₂₁ : n₂.natAbs.Coprime d₁
⊢ { num := n₁, den := d₁, den_nz := hd₁, reduced := hnd₁ } * { num := n₂, den := d₂, den_nz := hd₂, reduced := hnd₂ } =
    { num := n₁ * n₂, den := d₁ * d₂, den_nz := ⋯, reduced := ⋯ }
state_after: q : ℚ
n₁ n₂ : ℤ
d₁ d₂ : ℕ
hd₁ : d₁ ≠ 0
hd₂ : d₂ ≠ 0
hnd₁ : n₁.natAbs.Coprime d₁
hnd₂ : n₂.natAbs.Coprime d₂
h₁₂ : n₁.natAbs.Coprime d₂
h₂₁ : n₂.natAbs.Coprime d₁
⊢ normalize
      ({ num := n₁, den := d₁, den_nz := hd₁, reduced := hnd₁ }.num *
        { num := n₂, den := d₂, den_nz := hd₂, reduced := hnd₂ }.num)
      ({ num := n₁, den := d₁, den_nz := hd₁, reduced := hnd₁ }.den *
        { num := n₂, den := d₂, den_nz := hd₂, reduced := hnd₂ }.den)
      ⋯ =
    { num := n₁ * n₂, den := d₁ * d₂, den_nz := ⋯, reduced := ⋯ }
tactic: rw [mul_def]
state_before: q : ℚ
n₁ n₂ : ℤ
d₁ d₂ : ℕ
hd₁ : d₁ ≠ 0
hd₂ : d₂ ≠ 0
hnd₁ : n₁.natAbs.Coprime d₁
hnd₂ : n₂.natAbs.Coprime d₂
h₁₂ : n₁.natAbs.Coprime d₂
h₂₁ : n₂.natAbs.Coprime d₁
⊢ normalize
      ({ num := n₁, den := d₁, den_nz := hd₁, reduced := hnd₁ }.num *
        { num := n₂, den := d₂, den_nz := hd₂, reduced := hnd₂ }.num)
      ({ num := n₁, den := d₁, den_nz := hd₁, reduced := hnd₁ }.den *
        { num := n₂, den := d₂, den_nz := hd₂, reduced := hnd₂ }.den)
      ⋯ =
    { num := n₁ * n₂, den := d₁ * d₂, den_nz := ⋯, reduced := ⋯ }
state_after: q : ℚ
n₁ n₂ : ℤ
d₁ d₂ : ℕ
hd₁ : d₁ ≠ 0
hd₂ : d₂ ≠ 0
hnd₁ : n₁.natAbs.Coprime d₁
hnd₂ : n₂.natAbs.Coprime d₂
h₁₂ : n₁.natAbs.Coprime d₂
h₂₁ : n₂.natAbs.Coprime d₁
⊢ normalize (n₁ * n₂) (d₁ * d₂) ⋯ = { num := n₁ * n₂, den := d₁ * d₂, den_nz := ⋯, reduced := ⋯ }
tactic: dsimp
state_before: q : ℚ
n₁ n₂ : ℤ
d₁ d₂ : ℕ
hd₁ : d₁ ≠ 0
hd₂ : d₂ ≠ 0
hnd₁ : n₁.natAbs.Coprime d₁
hnd₂ : n₂.natAbs.Coprime d₂
h₁₂ : n₁.natAbs.Coprime d₂
h₂₁ : n₂.natAbs.Coprime d₁
⊢ normalize (n₁ * n₂) (d₁ * d₂) ⋯ = { num := n₁ * n₂, den := d₁ * d₂, den_nz := ⋯, reduced := ⋯ }
state_after: no goals
tactic: simp [mk_eq_normalize]
Theorem: UV.compress_mem_compression
File: Mathlib/Combinatorics/SetFamily/Compression/UV.lean

Proof steps:
state_before: α : Type u_1
inst✝³ : GeneralizedBooleanAlgebra α
inst✝² : DecidableRel Disjoint
inst✝¹ : DecidableRel fun x x_1 => x ≤ x_1
s : Finset α
u v a b : α
inst✝ : DecidableEq α
ha : a ∈ s
⊢ compress u v a ∈ 𝓒 u v s
state_after: α : Type u_1
inst✝³ : GeneralizedBooleanAlgebra α
inst✝² : DecidableRel Disjoint
inst✝¹ : DecidableRel fun x x_1 => x ≤ x_1
s : Finset α
u v a b : α
inst✝ : DecidableEq α
ha : a ∈ s
⊢ compress u v a ∈ s ∧ compress u v (compress u v a) ∈ s ∨ compress u v a ∉ s ∧ ∃ b ∈ s, compress u v b = compress u v a
tactic: rw [mem_compression]
state_before: α : Type u_1
inst✝³ : GeneralizedBooleanAlgebra α
inst✝² : DecidableRel Disjoint
inst✝¹ : DecidableRel fun x x_1 => x ≤ x_1
s : Finset α
u v a b : α
inst✝ : DecidableEq α
ha : a ∈ s
⊢ compress u v a ∈ s ∧ compress u v (compress u v a) ∈ s ∨ compress u v a ∉ s ∧ ∃ b ∈ s, compress u v b = compress u v a
state_after: case pos
α : Type u_1
inst✝³ : GeneralizedBooleanAlgebra α
inst✝² : DecidableRel Disjoint
inst✝¹ : DecidableRel fun x x_1 => x ≤ x_1
s : Finset α
u v a b : α
inst✝ : DecidableEq α
ha : a ∈ s
h : compress u v a ∈ s
⊢ compress u v a ∈ s ∧ compress u v (compress u v a) ∈ s ∨ compress u v a ∉ s ∧ ∃ b ∈ s, compress u v b = compress u v a

case neg
α : Type u_1
inst✝³ : GeneralizedBooleanAlgebra α
inst✝² : DecidableRel Disjoint
inst✝¹ : DecidableRel fun x x_1 => x ≤ x_1
s : Finset α
u v a b : α
inst✝ : DecidableEq α
ha : a ∈ s
h : compress u v a ∉ s
⊢ compress u v a ∈ s ∧ compress u v (compress u v a) ∈ s ∨ compress u v a ∉ s ∧ ∃ b ∈ s, compress u v b = compress u v a
tactic: by_cases h : compress u v a ∈ s
Theorem: CategoryTheory.ShortComplex.RightHomologyData.ofZeros_p
File: Mathlib/Algebra/Homology/ShortComplex/RightHomology.lean

Proof steps:
state_before: C : Type u_1
inst✝¹ : Category.{?u.30360, u_1} C
inst✝ : HasZeroMorphisms C
S S₁ S₂ S₃ : ShortComplex C
h : S.RightHomologyData
A : C
hf : S.f = 0
hg : S.g = 0
⊢ S.f ≫ 𝟙 S.X₂ = 0
state_after: no goals
tactic: rw [comp_id, hf]
state_before: C : Type u_1
inst✝¹ : Category.{?u.30360, u_1} C
inst✝ : HasZeroMorphisms C
S S₁ S₂ S₃ : ShortComplex C
h : S.RightHomologyData
A : C
hf : S.f = 0
hg : S.g = 0
⊢ 𝟙 S.X₂ ≫ (CokernelCofork.IsColimit.ofId S.f hf).desc (CokernelCofork.ofπ S.g ⋯) = 0
state_after: C : Type u_1
inst✝¹ : Category.{?u.30360, u_1} C
inst✝ : HasZeroMorphisms C
S S₁ S₂ S₃ : ShortComplex C
h : S.RightHomologyData
A : C
hf : S.f = 0
hg : S.g = 0
⊢ 𝟙 S.X₂ ≫ S.g = 0
tactic: change 𝟙 _ ≫ S.g = 0
state_before: C : Type u_1
inst✝¹ : Category.{?u.30360, u_1} C
inst✝ : HasZeroMorphisms C
S S₁ S₂ S₃ : ShortComplex C
h : S.RightHomologyData
A : C
hf : S.f = 0
hg : S.g = 0
⊢ 𝟙 S.X₂ ≫ S.g = 0
state_after: no goals
tactic: simp only [hg, comp_zero]
Theorem: Polynomial.natDegree_mul
File: Mathlib/Algebra/Polynomial/RingDivision.lean

Proof steps:
state_before: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : Semiring R
inst✝ : NoZeroDivisors R
p q : R[X]
hp : p ≠ 0
hq : q ≠ 0
⊢ (p * q).natDegree = p.natDegree + q.natDegree
state_after: no goals
tactic: rw [← Nat.cast_inj (R := WithBot ℕ), ← degree_eq_natDegree (mul_ne_zero hp hq),
    Nat.cast_add, ← degree_eq_natDegree hp, ← degree_eq_natDegree hq, degree_mul]
Theorem: NNReal.le_iInf_add_iInf
File: Mathlib/Data/NNReal/Basic.lean

Proof steps:
state_before: r r₁ r₂ : ℝ≥0
x y : ℝ
ι : Sort u_1
ι' : Sort u_2
inst✝¹ : Nonempty ι
inst✝ : Nonempty ι'
f : ι → ℝ≥0
g : ι' → ℝ≥0
a : ℝ≥0
h : ∀ (i : ι) (j : ι'), a ≤ f i + g j
⊢ a ≤ (⨅ i, f i) + ⨅ j, g j
state_after: r r₁ r₂ : ℝ≥0
x y : ℝ
ι : Sort u_1
ι' : Sort u_2
inst✝¹ : Nonempty ι
inst✝ : Nonempty ι'
f : ι → ℝ≥0
g : ι' → ℝ≥0
a : ℝ≥0
h : ∀ (i : ι) (j : ι'), a ≤ f i + g j
⊢ ↑a ≤ (⨅ i, ↑(f i)) + ⨅ i, ↑(g i)
tactic: rw [← NNReal.coe_le_coe, NNReal.coe_add, coe_iInf, coe_iInf]
state_before: r r₁ r₂ : ℝ≥0
x y : ℝ
ι : Sort u_1
ι' : Sort u_2
inst✝¹ : Nonempty ι
inst✝ : Nonempty ι'
f : ι → ℝ≥0
g : ι' → ℝ≥0
a : ℝ≥0
h : ∀ (i : ι) (j : ι'), a ≤ f i + g j
⊢ ↑a ≤ (⨅ i, ↑(f i)) + ⨅ i, ↑(g i)
state_after: no goals
tactic: exact le_ciInf_add_ciInf h
Theorem: CategoryTheory.CostructuredArrow.w
File: Mathlib/CategoryTheory/Comma/StructuredArrow.lean

Proof steps:
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
T T' T'' : D
Y Y' Y'' : C
S S' : C ⥤ D
A B : CostructuredArrow S T
f : A ⟶ B
⊢ S.map f.left ≫ B.hom = A.hom
state_after: no goals
tactic: simp
Theorem: le_sdiff
File: Mathlib/Order/BooleanAlgebra.lean

Proof steps:
state_before: α : Type u
β : Type u_1
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
h : x ≤ y ∧ Disjoint x z
⊢ x ≤ y \ z
state_after: α : Type u
β : Type u_1
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
h : x ≤ y ∧ Disjoint x z
⊢ x \ z ≤ y \ z
tactic: rw [← h.2.sdiff_eq_left]
state_before: α : Type u
β : Type u_1
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
h : x ≤ y ∧ Disjoint x z
⊢ x \ z ≤ y \ z
state_after: no goals
tactic: exact sdiff_le_sdiff_right h.1
Theorem: SetTheory.PGame.bddAbove_range_of_small
File: Mathlib/SetTheory/Game/PGame.lean

Proof steps:
state_before: xl xr : Type u
ι : Type u_1
inst✝ : Small.{u, u_1} ι
f : ι → PGame
⊢ BddAbove (Set.range f)
state_after: xl xr : Type u
ι : Type u_1
inst✝ : Small.{u, u_1} ι
f : ι → PGame
x : PGame :=
  mk ((i : Shrink.{u, u_1} ι) × (f ((equivShrink ι).symm i)).LeftMoves) PEmpty.{u + 1}
    (fun x => (f ((equivShrink ι).symm x.fst)).moveLeft x.snd) PEmpty.elim
⊢ BddAbove (Set.range f)
tactic: let x : PGame.{u} := ⟨Σ i, (f $ (equivShrink.{u} ι).symm i).LeftMoves, PEmpty,
    fun x ↦ moveLeft _ x.2, PEmpty.elim⟩
state_before: xl xr : Type u
ι : Type u_1
inst✝ : Small.{u, u_1} ι
f : ι → PGame
x : PGame :=
  mk ((i : Shrink.{u, u_1} ι) × (f ((equivShrink ι).symm i)).LeftMoves) PEmpty.{u + 1}
    (fun x => (f ((equivShrink ι).symm x.fst)).moveLeft x.snd) PEmpty.elim
⊢ BddAbove (Set.range f)
state_after: xl xr : Type u
ι : Type u_1
inst✝ : Small.{u, u_1} ι
f : ι → PGame
x : PGame :=
  mk ((i : Shrink.{u, u_1} ι) × (f ((equivShrink ι).symm i)).LeftMoves) PEmpty.{u + 1}
    (fun x => (f ((equivShrink ι).symm x.fst)).moveLeft x.snd) PEmpty.elim
i : ι
⊢ f i ≤ x
tactic: refine ⟨x, Set.forall_mem_range.2 fun i ↦ ?_⟩
state_before: xl xr : Type u
ι : Type u_1
inst✝ : Small.{u, u_1} ι
f : ι → PGame
x : PGame :=
  mk ((i : Shrink.{u, u_1} ι) × (f ((equivShrink ι).symm i)).LeftMoves) PEmpty.{u + 1}
    (fun x => (f ((equivShrink ι).symm x.fst)).moveLeft x.snd) PEmpty.elim
i : ι
⊢ f i ≤ x
state_after: xl xr : Type u
ι : Type u_1
inst✝ : Small.{u, u_1} ι
f : ι → PGame
x : PGame :=
  mk ((i : Shrink.{u, u_1} ι) × (f ((equivShrink ι).symm i)).LeftMoves) PEmpty.{u + 1}
    (fun x => (f ((equivShrink ι).symm x.fst)).moveLeft x.snd) PEmpty.elim
i : ι
⊢ (∀ (i_1 : (f ((equivShrink ι).symm ((equivShrink ι) i))).LeftMoves),
      (f ((equivShrink ι).symm ((equivShrink ι) i))).moveLeft i_1 ⧏ x) ∧
    ∀ (j : x.RightMoves), f ((equivShrink ι).symm ((equivShrink ι) i)) ⧏ x.moveRight j
tactic: rw [← (equivShrink ι).symm_apply_apply i, le_iff_forall_lf]
state_before: xl xr : Type u
ι : Type u_1
inst✝ : Small.{u, u_1} ι
f : ι → PGame
x : PGame :=
  mk ((i : Shrink.{u, u_1} ι) × (f ((equivShrink ι).symm i)).LeftMoves) PEmpty.{u + 1}
    (fun x => (f ((equivShrink ι).symm x.fst)).moveLeft x.snd) PEmpty.elim
i : ι
⊢ (∀ (i_1 : (f ((equivShrink ι).symm ((equivShrink ι) i))).LeftMoves),
      (f ((equivShrink ι).symm ((equivShrink ι) i))).moveLeft i_1 ⧏ x) ∧
    ∀ (j : x.RightMoves), f ((equivShrink ι).symm ((equivShrink ι) i)) ⧏ x.moveRight j
state_after: no goals
tactic: simpa [x] using fun j ↦ @moveLeft_lf x ⟨equivShrink ι i, j⟩
Theorem: dvd_and_not_dvd_iff
File: Mathlib/Algebra/GroupWithZero/Divisibility.lean

Proof steps:
state_before: α : Type u_1
inst✝ : CancelCommMonoidWithZero α
x y : α
x✝ : x ∣ y ∧ ¬y ∣ x
d : α
hd : y = x * d
hyx : ¬y ∣ x
hx0 : x = 0
⊢ False
state_after: no goals
tactic: simp [hx0] at hyx
state_before: α : Type u_1
inst✝ : CancelCommMonoidWithZero α
x y : α
x✝¹ : x ∣ y ∧ ¬y ∣ x
d : α
hd : y = x * d
hyx : ¬y ∣ x
x✝ : d ∣ 1
e : α
he : 1 = d * e
⊢ x = y * e
state_after: no goals
tactic: rw [hd, mul_assoc, ← he, mul_one]
state_before: α : Type u_1
inst✝ : CancelCommMonoidWithZero α
x y : α
x✝¹ : DvdNotUnit x y
hx0 : x ≠ 0
d : α
hdu : ¬IsUnit d
hdx : y = x * d
x✝ : y ∣ x
e : α
he : x = y * e
⊢ x * 1 = x * (d * e)
state_after: no goals
tactic: conv =>
            lhs
            rw [he, hdx]
            simp [mul_assoc]
Theorem: Matrix.mulVec_injective_iff_isUnit
File: Mathlib/LinearAlgebra/Matrix/NonsingularInverse.lean

Proof steps:
state_before: l : Type u_1
m : Type u
n : Type u'
α : Type v
inst✝⁴ : DecidableEq m
inst✝³ : DecidableEq n
R : Type u_2
K : Type u_3
inst✝² : CommRing R
inst✝¹ : Field K
inst✝ : Fintype m
A : Matrix m m K
⊢ Function.Injective A.mulVec ↔ IsUnit A
state_after: l : Type u_1
m : Type u
n : Type u'
α : Type v
inst✝⁴ : DecidableEq m
inst✝³ : DecidableEq n
R : Type u_2
K : Type u_3
inst✝² : CommRing R
inst✝¹ : Field K
inst✝ : Fintype m
A : Matrix m m K
⊢ Function.Injective A.mulVec ↔ Function.Injective fun v => v ᵥ* Aᵀ
tactic: rw [← isUnit_transpose, ← vecMul_injective_iff_isUnit]
state_before: l : Type u_1
m : Type u
n : Type u'
α : Type v
inst✝⁴ : DecidableEq m
inst✝³ : DecidableEq n
R : Type u_2
K : Type u_3
inst✝² : CommRing R
inst✝¹ : Field K
inst✝ : Fintype m
A : Matrix m m K
⊢ Function.Injective A.mulVec ↔ Function.Injective fun v => v ᵥ* Aᵀ
state_after: no goals
tactic: simp_rw [vecMul_transpose]
Theorem: Filter.atTop_eq_pure_of_isTop
File: Mathlib/Order/Filter/Ultrafilter.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type u_1
f : Filter α
s : Set α
a : α
inst✝ : LinearOrder α
x : α
hx : IsTop x
⊢ atTop = pure x
state_after: α : Type u
β : Type v
γ : Type u_1
f : Filter α
s : Set α
a : α
inst✝ : LinearOrder α
x : α
hx : IsTop x
this : Nonempty α
⊢ atTop = pure x
tactic: have : Nonempty α := ⟨x⟩
state_before: α : Type u
β : Type v
γ : Type u_1
f : Filter α
s : Set α
a : α
inst✝ : LinearOrder α
x : α
hx : IsTop x
this : Nonempty α
⊢ atTop = pure x
state_after: α : Type u
β : Type v
γ : Type u_1
f : Filter α
s : Set α
a : α
inst✝ : LinearOrder α
x : α
hx : IsTop x
this : Nonempty α
⊢ {x} ∈ atTop
tactic: apply atTop_neBot.eq_pure_iff.2
state_before: α : Type u
β : Type v
γ : Type u_1
f : Filter α
s : Set α
a : α
inst✝ : LinearOrder α
x : α
hx : IsTop x
this : Nonempty α
⊢ {x} ∈ atTop
state_after: case h.e'_4
α : Type u
β : Type v
γ : Type u_1
f : Filter α
s : Set α
a : α
inst✝ : LinearOrder α
x : α
hx : IsTop x
this : Nonempty α
⊢ {x} = Ici x
tactic: convert Ici_mem_atTop x using 1
state_before: case h.e'_4
α : Type u
β : Type v
γ : Type u_1
f : Filter α
s : Set α
a : α
inst✝ : LinearOrder α
x : α
hx : IsTop x
this : Nonempty α
⊢ {x} = Ici x
state_after: no goals
tactic: exact (Ici_eq_singleton_iff_isTop.2 hx).symm
Theorem: MeasureTheory.average_eq_integral
File: Mathlib/MeasureTheory/Integral/Average.lean

Proof steps:
state_before: α : Type u_1
E : Type u_2
F : Type u_3
m0 : MeasurableSpace α
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : CompleteSpace E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace ℝ F
inst✝¹ : CompleteSpace F
μ ν : Measure α
s t : Set α
f✝ g : α → E
inst✝ : IsProbabilityMeasure μ
f : α → E
⊢ ⨍ (x : α), f x ∂μ = ∫ (x : α), f x ∂μ
state_after: no goals
tactic: rw [average, measure_univ, inv_one, one_smul]