ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Set.WellFoundedOn.sigma_lex_of_wellFoundedOn_fiber
File: Mathlib/Order/WellFoundedSet.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
π : ι → Type u_5
rι : ι → ι → Prop
rπ : (i : ι) → π i → π i → Prop
f : γ → ι
g : (i : ι) → γ → π i
s : Set γ
hι : s.WellFoundedOn (rι on f)
hπ : ∀ (i : ι), (s ∩ f ⁻¹' {i}).WellFoundedOn (rπ i on g i)
⊢ s.WellFoundedOn (Sigma.Lex rι rπ on fun c => ⟨f c, g (f c) c⟩)
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
π : ι → Type u_5
rι : ι → ι → Prop
rπ : (i : ι) → π i → π i → Prop
f : γ → ι
g : (i : ι) → γ → π i
s : Set γ
hι : s.WellFoundedOn (rι on f)
hπ : ∀ (i : ι), (s ∩ f ⁻¹' {i}).WellFoundedOn (rπ i on g i)
⊢ WellFounded (Sigma.Lex rι rπ on fun c => ⟨f ↑c, g (f ↑c) ↑c⟩)
tactic: show WellFounded (Sigma.Lex rι rπ on fun c : s => ⟨f c, g (f c) c⟩)
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
π : ι → Type u_5
rι : ι → ι → Prop
rπ : (i : ι) → π i → π i → Prop
f : γ → ι
g : (i : ι) → γ → π i
s : Set γ
hι : s.WellFoundedOn (rι on f)
hπ : ∀ (i : ι), (s ∩ f ⁻¹' {i}).WellFoundedOn (rπ i on g i)
⊢ WellFounded (Sigma.Lex rι rπ on fun c => ⟨f ↑c, g (f ↑c) ↑c⟩)
state_after: no goals
tactic: exact
    @WellFounded.sigma_lex_of_wellFoundedOn_fiber _ s _ _ rπ (fun c => f c) (fun i c => g _ c) hι
      fun i => ((hπ i).onFun (f := fun x => ⟨x, x.1.2, x.2⟩)).mono (fun b c h => ‹_›)
Theorem: PowerSeries.coeff_zero_C
File: Mathlib/RingTheory/PowerSeries/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝ : Semiring R
a : R
⊢ (coeff R 0) ((C R) a) = a
state_after: no goals
tactic: rw [coeff_C, if_pos rfl]
Theorem: Polynomial.Gal.mul_splits_in_splittingField_of_mul
File: Mathlib/FieldTheory/PolynomialGaloisGroup.lean

Proof steps:
state_before: F : Type u_1
inst✝² : Field F
p q : F[X]
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
p₁ q₁ p₂ q₂ : F[X]
hq₁ : q₁ ≠ 0
hq₂ : q₂ ≠ 0
h₁ : Splits (algebraMap F q₁.SplittingField) p₁
h₂ : Splits (algebraMap F q₂.SplittingField) p₂
⊢ Splits (algebraMap F (q₁ * q₂).SplittingField) (p₁ * p₂)
state_after: case hf
F : Type u_1
inst✝² : Field F
p q : F[X]
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
p₁ q₁ p₂ q₂ : F[X]
hq₁ : q₁ ≠ 0
hq₂ : q₂ ≠ 0
h₁ : Splits (algebraMap F q₁.SplittingField) p₁
h₂ : Splits (algebraMap F q₂.SplittingField) p₂
⊢ Splits (algebraMap F (q₁ * q₂).SplittingField) p₁

case hg
F : Type u_1
inst✝² : Field F
p q : F[X]
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
p₁ q₁ p₂ q₂ : F[X]
hq₁ : q₁ ≠ 0
hq₂ : q₂ ≠ 0
h₁ : Splits (algebraMap F q₁.SplittingField) p₁
h₂ : Splits (algebraMap F q₂.SplittingField) p₂
⊢ Splits (algebraMap F (q₁ * q₂).SplittingField) p₂
tactic: apply splits_mul
Theorem: WeierstrassCurve.Affine.CoordinateRing.XYIdeal_eq₁
File: Mathlib/AlgebraicGeometry/EllipticCurve/Group.lean

Proof steps:
state_before: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
W : Affine R
f : R →+* S
x y L : R
⊢ XYIdeal W x (C y) = XYIdeal W x (linePolynomial x y L)
state_after: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
W : Affine R
f : R →+* S
x y L : R
⊢ span {(mk W) (C (X - C x)), (mk W) (Y - C (C y))} =
    span {(mk W) (C (X - C x)), (mk W) (Y - C (C L * (X - C x) + C y))}
tactic: simp only [XYIdeal, XClass, YClass, linePolynomial]
state_before: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
W : Affine R
f : R →+* S
x y L : R
⊢ span {(mk W) (C (X - C x)), (mk W) (Y - C (C y))} =
    span {(mk W) (C (X - C x)), (mk W) (Y - C (C L * (X - C x) + C y))}
state_after: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
W : Affine R
f : R →+* S
x y L : R
⊢ span {(mk W) (C (X - C x)), (mk W) (Y - C (C y) + C (X - C x) * C (C (-L)))} =
    span {(mk W) (C (X - C x)), (mk W) (Y - C (C L * (X - C x) + C y))}
tactic: rw [← span_pair_add_mul_right <| mk W <| C <| C <| -L, ← _root_.map_mul, ← map_add]
state_before: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
W : Affine R
f : R →+* S
x y L : R
⊢ span {(mk W) (C (X - C x)), (mk W) (Y - C (C y) + C (X - C x) * C (C (-L)))} =
    span {(mk W) (C (X - C x)), (mk W) (Y - C (C L * (X - C x) + C y))}
state_after: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
W : Affine R
f : R →+* S
x y L : R
⊢ Y - C (C y) + C (X - C x) * C (C (-L)) = Y - C (C L * (X - C x) + C y)
tactic: apply congr_arg (_ ∘ _ ∘ _ ∘ _)
state_before: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
W : Affine R
f : R →+* S
x y L : R
⊢ Y - C (C y) + C (X - C x) * C (C (-L)) = Y - C (C L * (X - C x) + C y)
state_after: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
W : Affine R
f : R →+* S
x y L : R
⊢ Y - C (C y) + (C X - C (C x)) * -C (C L) = Y - (C (C L) * (C X - C (C x)) + C (C y))
tactic: C_simp
state_before: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
W : Affine R
f : R →+* S
x y L : R
⊢ Y - C (C y) + (C X - C (C x)) * -C (C L) = Y - (C (C L) * (C X - C (C x)) + C (C y))
state_after: no goals
tactic: ring1
Theorem: Polynomial.natDegree_eq_of_natDegree_add_eq_zero
File: Mathlib/Algebra/Polynomial/Degree/Definitions.lean

Proof steps:
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p✝¹ p✝ q✝ : R[X]
ι : Type u_1
p q : R[X]
H : (p + q).natDegree = 0
⊢ p.natDegree = q.natDegree
state_after: case pos
R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p✝¹ p✝ q✝ : R[X]
ι : Type u_1
p q : R[X]
H : (p + q).natDegree = 0
h₁ : p.natDegree = 0
⊢ p.natDegree = q.natDegree

case neg
R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p✝¹ p✝ q✝ : R[X]
ι : Type u_1
p q : R[X]
H : (p + q).natDegree = 0
h₁ : ¬p.natDegree = 0
⊢ p.natDegree = q.natDegree
tactic: by_cases h₁ : natDegree p = 0
state_before: case pos
R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p✝¹ p✝ q✝ : R[X]
ι : Type u_1
p q : R[X]
H : (p + q).natDegree = 0
h₁ : p.natDegree = 0
⊢ p.natDegree = q.natDegree

case neg
R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p✝¹ p✝ q✝ : R[X]
ι : Type u_1
p q : R[X]
H : (p + q).natDegree = 0
h₁ : ¬p.natDegree = 0
⊢ p.natDegree = q.natDegree
state_after: case pos
R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p✝¹ p✝ q✝ : R[X]
ι : Type u_1
p q : R[X]
H : (p + q).natDegree = 0
h₁ : p.natDegree = 0
h₂ : q.natDegree = 0
⊢ p.natDegree = q.natDegree

case neg
R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p✝¹ p✝ q✝ : R[X]
ι : Type u_1
p q : R[X]
H : (p + q).natDegree = 0
h₁ : p.natDegree = 0
h₂ : ¬q.natDegree = 0
⊢ p.natDegree = q.natDegree

case neg
R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p✝¹ p✝ q✝ : R[X]
ι : Type u_1
p q : R[X]
H : (p + q).natDegree = 0
h₁ : ¬p.natDegree = 0
⊢ p.natDegree = q.natDegree
tactic: on_goal 1 => by_cases h₂ : natDegree q = 0
Theorem: Nat.decreasingInduction_self
File: Mathlib/Data/Nat/Defs.lean

Proof steps:
state_before: a b c d m n✝ k : ℕ
p q : ℕ → Prop
n : ℕ
motive : (m : ℕ) → m ≤ n → Sort u_1
of_succ : (k : ℕ) → (h : k < n) → motive (k + 1) h → motive k ⋯
self : motive n ⋯
⊢ decreasingInduction of_succ self ⋯ = self
state_after: a b c d m n✝ k : ℕ
p q : ℕ → Prop
n : ℕ
motive : (m : ℕ) → m ≤ n → Sort u_1
of_succ : (k : ℕ) → (h : k < n) → motive (k + 1) h → motive k ⋯
self : motive n ⋯
⊢ leRec (motive := fun {n_1} mn =>
      {motive : (m : ℕ) → m ≤ n_1 → Sort u_1} →
        ((k : ℕ) → (h : k < n_1) → motive (k + 1) h → motive k ⋯) → motive n_1 ⋯ → motive n mn)
      (fun {motive} of_succ self => self)
      (fun ⦃k⦄ h ih {motive} of_succ self => ih (fun i hi => of_succ i ⋯) (of_succ k ⋯ self)) ⋯ of_succ self =
    self
tactic: dsimp only [decreasingInduction]
state_before: a b c d m n✝ k : ℕ
p q : ℕ → Prop
n : ℕ
motive : (m : ℕ) → m ≤ n → Sort u_1
of_succ : (k : ℕ) → (h : k < n) → motive (k + 1) h → motive k ⋯
self : motive n ⋯
⊢ leRec (motive := fun {n_1} mn =>
      {motive : (m : ℕ) → m ≤ n_1 → Sort u_1} →
        ((k : ℕ) → (h : k < n_1) → motive (k + 1) h → motive k ⋯) → motive n_1 ⋯ → motive n mn)
      (fun {motive} of_succ self => self)
      (fun ⦃k⦄ h ih {motive} of_succ self => ih (fun i hi => of_succ i ⋯) (of_succ k ⋯ self)) ⋯ of_succ self =
    self
state_after: no goals
tactic: rw [leRec_self]
Theorem: LieSubmodule.map_incl_lt_iff_lt_top
File: Mathlib/Algebra/Lie/Submodule.lean

Proof steps:
state_before: R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
N : LieSubmodule R L M
N' : LieSubmodule R L ↥↑N
⊢ map N.incl N' < N ↔ N' < ⊤
state_after: case h.e'_1.h.e'_4
R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
N : LieSubmodule R L M
N' : LieSubmodule R L ↥↑N
⊢ N = (mapOrderEmbedding ⋯) ⊤
tactic: convert (LieSubmodule.mapOrderEmbedding (f := N.incl) Subtype.coe_injective).lt_iff_lt
state_before: case h.e'_1.h.e'_4
R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
N : LieSubmodule R L M
N' : LieSubmodule R L ↥↑N
⊢ N = (mapOrderEmbedding ⋯) ⊤
state_after: no goals
tactic: simp
Theorem: Cardinal.toPartENat_le_iff_of_lt_aleph0
File: Mathlib/SetTheory/Cardinal/PartENat.lean

Proof steps:
state_before: α : Type u
c c' : Cardinal.{u_1}
hc' : c' < ℵ₀
⊢ toPartENat c ≤ toPartENat c' ↔ c ≤ c'
state_after: case intro
α : Type u
c : Cardinal.{u_1}
c' : ℕ
⊢ toPartENat c ≤ toPartENat ↑c' ↔ c ≤ ↑c'
tactic: lift c' to ℕ using hc'
state_before: case intro
α : Type u
c : Cardinal.{u_1}
c' : ℕ
⊢ toPartENat c ≤ toPartENat ↑c' ↔ c ≤ ↑c'
state_after: no goals
tactic: simp_rw [← partENatOfENat_toENat, toENat_nat, ← toENat_le_nat,
   ← PartENat.withTopOrderIso.symm.le_iff_le, PartENat.ofENat_le, map_le_map_iff]
Theorem: toIcoDiv_add_right
File: Mathlib/Algebra/Order/ToIntervalMod.lean

Proof steps:
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c : α
n : ℤ
a b : α
⊢ toIcoDiv hp a (b + p) = toIcoDiv hp a b + 1
state_after: no goals
tactic: simpa only [one_zsmul] using toIcoDiv_add_zsmul hp a b 1
Theorem: Pi.support_single
File: Mathlib/Algebra/Group/Support.lean

Proof steps:
state_before: A : Type u_1
B : Type u_2
inst✝² : DecidableEq A
inst✝¹ : One B
a : A
b : B
inst✝ : DecidableEq B
⊢ mulSupport (mulSingle a b) = if b = 1 then ∅ else {a}
state_after: no goals
tactic: split_ifs with h <;> simp [h]
Theorem: Polynomial.mono_map_natDegree_eq
File: Mathlib/Algebra/Polynomial/EraseLead.lean

Proof steps:
state_before: R : Type u_1
inst✝³ : Semiring R
f : R[X]
S : Type u_2
F : Type u_3
inst✝² : Semiring S
inst✝¹ : FunLike F R[X] S[X]
inst✝ : AddMonoidHomClass F R[X] S[X]
φ : F
p : R[X]
k : ℕ
fu : ℕ → ℕ
fu0 : ∀ {n : ℕ}, n ≤ k → fu n = 0
fc : ∀ {n m : ℕ}, k ≤ n → n < m → fu n < fu m
φ_k : ∀ {f : R[X]}, f.natDegree < k → φ f = 0
φ_mon_nat : ∀ (n : ℕ) (c : R), c ≠ 0 → (φ ((monomial n) c)).natDegree = fu n
⊢ (φ p).natDegree = fu p.natDegree
state_after: case refine_1
R : Type u_1
inst✝³ : Semiring R
f : R[X]
S : Type u_2
F : Type u_3
inst✝² : Semiring S
inst✝¹ : FunLike F R[X] S[X]
inst✝ : AddMonoidHomClass F R[X] S[X]
φ : F
p : R[X]
k : ℕ
fu : ℕ → ℕ
fu0 : ∀ {n : ℕ}, n ≤ k → fu n = 0
fc : ∀ {n m : ℕ}, k ≤ n → n < m → fu n < fu m
φ_k : ∀ {f : R[X]}, f.natDegree < k → φ f = 0
φ_mon_nat : ∀ (n : ℕ) (c : R), c ≠ 0 → (φ ((monomial n) c)).natDegree = fu n
⊢ ∀ (n : ℕ) (r : R), r ≠ 0 → n ≤ p.natDegree → (fun p => (φ p).natDegree = fu p.natDegree) (C r * X ^ n)

case refine_2
R : Type u_1
inst✝³ : Semiring R
f : R[X]
S : Type u_2
F : Type u_3
inst✝² : Semiring S
inst✝¹ : FunLike F R[X] S[X]
inst✝ : AddMonoidHomClass F R[X] S[X]
φ : F
p : R[X]
k : ℕ
fu : ℕ → ℕ
fu0 : ∀ {n : ℕ}, n ≤ k → fu n = 0
fc : ∀ {n m : ℕ}, k ≤ n → n < m → fu n < fu m
φ_k : ∀ {f : R[X]}, f.natDegree < k → φ f = 0
φ_mon_nat : ∀ (n : ℕ) (c : R), c ≠ 0 → (φ ((monomial n) c)).natDegree = fu n
⊢ ∀ (f g : R[X]),
    f.natDegree < g.natDegree →
      g.natDegree ≤ p.natDegree →
        (fun p => (φ p).natDegree = fu p.natDegree) f →
          (fun p => (φ p).natDegree = fu p.natDegree) g → (fun p => (φ p).natDegree = fu p.natDegree) (f + g)
tactic: refine induction_with_natDegree_le (fun p => (φ p).natDegree = fu p.natDegree)
    p.natDegree (by simp [fu0]) ?_ ?_ _ rfl.le
Theorem: CategoryTheory.ShortComplex.isIso_homologyι
File: Mathlib/Algebra/Homology/ShortComplex/Homology.lean

Proof steps:
state_before: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
S S₁ S₂ S₃ S₄ : ShortComplex C
φ : S₁ ⟶ S₂
h₁ : S₁.HomologyData
h₂ : S₂.HomologyData
A : C
hg : S.g = 0
inst✝ : S.HasHomology
⊢ IsIso S.homologyι
state_after: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
S S₁ S₂ S₃ S₄ : ShortComplex C
φ : S₁ ⟶ S₂
h₁ : S₁.HomologyData
h₂ : S₂.HomologyData
A : C
hg : S.g = 0
inst✝ : S.HasHomology
this : IsIso S.rightHomologyι
⊢ IsIso S.homologyι
tactic: have := S.isIso_rightHomologyι hg
state_before: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
S S₁ S₂ S₃ S₄ : ShortComplex C
φ : S₁ ⟶ S₂
h₁ : S₁.HomologyData
h₂ : S₂.HomologyData
A : C
hg : S.g = 0
inst✝ : S.HasHomology
this : IsIso S.rightHomologyι
⊢ IsIso S.homologyι
state_after: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
S S₁ S₂ S₃ S₄ : ShortComplex C
φ : S₁ ⟶ S₂
h₁ : S₁.HomologyData
h₂ : S₂.HomologyData
A : C
hg : S.g = 0
inst✝ : S.HasHomology
this : IsIso S.rightHomologyι
⊢ IsIso (S.rightHomologyIso.inv ≫ S.rightHomologyι)
tactic: dsimp only [homologyι]
state_before: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
S S₁ S₂ S₃ S₄ : ShortComplex C
φ : S₁ ⟶ S₂
h₁ : S₁.HomologyData
h₂ : S₂.HomologyData
A : C
hg : S.g = 0
inst✝ : S.HasHomology
this : IsIso S.rightHomologyι
⊢ IsIso (S.rightHomologyIso.inv ≫ S.rightHomologyι)
state_after: no goals
tactic: infer_instance
Theorem: CategoryTheory.isSeparator_iff_epi
File: Mathlib/CategoryTheory/Generator.lean

Proof steps:
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
G : C
inst✝ : ∀ (A : C), HasCoproduct fun x => G
⊢ IsSeparator G ↔ ∀ (A : C), Epi (Sigma.desc fun f => f)
state_after: C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
G : C
inst✝ : ∀ (A : C), HasCoproduct fun x => G
⊢ (∀ ⦃X Y : C⦄ (f g : X ⟶ Y), (∀ (h : G ⟶ X), h ≫ f = h ≫ g) → f = g) ↔ ∀ (A : C), Epi (Sigma.desc fun f => f)
tactic: rw [isSeparator_def]
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
G : C
inst✝ : ∀ (A : C), HasCoproduct fun x => G
⊢ (∀ ⦃X Y : C⦄ (f g : X ⟶ Y), (∀ (h : G ⟶ X), h ≫ f = h ≫ g) → f = g) ↔ ∀ (A : C), Epi (Sigma.desc fun f => f)
state_after: case refine_1
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
G : C
inst✝ : ∀ (A : C), HasCoproduct fun x => G
h : ∀ ⦃X Y : C⦄ (f g : X ⟶ Y), (∀ (h : G ⟶ X), h ≫ f = h ≫ g) → f = g
A Z✝ : C
u v : A ⟶ Z✝
huv : (Sigma.desc fun f => f) ≫ u = (Sigma.desc fun f => f) ≫ v
i : G ⟶ A
⊢ i ≫ u = i ≫ v

case refine_2
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
G : C
inst✝ : ∀ (A : C), HasCoproduct fun x => G
h : ∀ (A : C), Epi (Sigma.desc fun f => f)
X Y : C
f g : X ⟶ Y
hh : ∀ (h : G ⟶ X), h ≫ f = h ≫ g
⊢ f = g
tactic: refine ⟨fun h A => ⟨fun u v huv => h _ _ fun i => ?_⟩, fun h X Y f g hh => ?_⟩
Theorem: smul_closedUnitBall_of_nonneg
File: Mathlib/Analysis/NormedSpace/Pointwise.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
inst✝³ : NormedField 𝕜
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : NormedSpace ℝ E
r : ℝ
hr : 0 ≤ r
⊢ r • closedBall 0 1 = closedBall 0 r
state_after: no goals
tactic: rw [smul_closedUnitBall, Real.norm_of_nonneg hr]
Theorem: MeasureTheory.HasFiniteIntegral.smul
File: Mathlib/MeasureTheory/Function/L1Space.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝⁵ : MeasurableSpace δ
inst✝⁴ : NormedAddCommGroup β
inst✝³ : NormedAddCommGroup γ
𝕜 : Type u_5
inst✝² : NormedAddCommGroup 𝕜
inst✝¹ : SMulZeroClass 𝕜 β
inst✝ : BoundedSMul 𝕜 β
c : 𝕜
f : α → β
⊢ HasFiniteIntegral f μ → HasFiniteIntegral (c • f) μ
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝⁵ : MeasurableSpace δ
inst✝⁴ : NormedAddCommGroup β
inst✝³ : NormedAddCommGroup γ
𝕜 : Type u_5
inst✝² : NormedAddCommGroup 𝕜
inst✝¹ : SMulZeroClass 𝕜 β
inst✝ : BoundedSMul 𝕜 β
c : 𝕜
f : α → β
⊢ ∫⁻ (a : α), ↑‖f a‖₊ ∂μ < ⊤ → ∫⁻ (a : α), ↑‖(c • f) a‖₊ ∂μ < ⊤
tactic: simp only [HasFiniteIntegral]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝⁵ : MeasurableSpace δ
inst✝⁴ : NormedAddCommGroup β
inst✝³ : NormedAddCommGroup γ
𝕜 : Type u_5
inst✝² : NormedAddCommGroup 𝕜
inst✝¹ : SMulZeroClass 𝕜 β
inst✝ : BoundedSMul 𝕜 β
c : 𝕜
f : α → β
⊢ ∫⁻ (a : α), ↑‖f a‖₊ ∂μ < ⊤ → ∫⁻ (a : α), ↑‖(c • f) a‖₊ ∂μ < ⊤
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝⁵ : MeasurableSpace δ
inst✝⁴ : NormedAddCommGroup β
inst✝³ : NormedAddCommGroup γ
𝕜 : Type u_5
inst✝² : NormedAddCommGroup 𝕜
inst✝¹ : SMulZeroClass 𝕜 β
inst✝ : BoundedSMul 𝕜 β
c : 𝕜
f : α → β
hfi : ∫⁻ (a : α), ↑‖f a‖₊ ∂μ < ⊤
⊢ ∫⁻ (a : α), ↑‖(c • f) a‖₊ ∂μ < ⊤
tactic: intro hfi
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝⁵ : MeasurableSpace δ
inst✝⁴ : NormedAddCommGroup β
inst✝³ : NormedAddCommGroup γ
𝕜 : Type u_5
inst✝² : NormedAddCommGroup 𝕜
inst✝¹ : SMulZeroClass 𝕜 β
inst✝ : BoundedSMul 𝕜 β
c : 𝕜
f : α → β
hfi : ∫⁻ (a : α), ↑‖f a‖₊ ∂μ < ⊤
⊢ ∫⁻ (a : α), ↑‖(c • f) a‖₊ ∂μ < ⊤
state_after: no goals
tactic: calc
    (∫⁻ a : α, ‖c • f a‖₊ ∂μ) ≤ ∫⁻ a : α, ‖c‖₊ * ‖f a‖₊ ∂μ := by
      refine lintegral_mono ?_
      intro i
      -- After leanprover/lean4#2734, we need to do beta reduction `exact mod_cast`
      beta_reduce
      exact mod_cast (nnnorm_smul_le c (f i))
    _ < ∞ := by
      rw [lintegral_const_mul']
      exacts [mul_lt_top coe_ne_top hfi.ne, coe_ne_top]
Theorem: Set.singleton_inter_nonempty
File: Mathlib/Data/Set/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s s₁ s₂ t t₁ t₂ u : Set α
⊢ ({a} ∩ s).Nonempty ↔ a ∈ s
state_after: no goals
tactic: simp only [Set.Nonempty, mem_inter_iff, mem_singleton_iff, exists_eq_left]
Theorem: SimpleGraph.coe_finsetWalkLength_eq
File: Mathlib/Combinatorics/SimpleGraph/Connectivity/WalkCounting.lean

Proof steps:
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
inst✝¹ : DecidableEq V
inst✝ : G.LocallyFinite
n : ℕ
u v : V
⊢ ↑(G.finsetWalkLength n u v) = {p | p.length = n}
state_after: case zero
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
inst✝¹ : DecidableEq V
inst✝ : G.LocallyFinite
u v : V
⊢ ↑(G.finsetWalkLength 0 u v) = {p | p.length = 0}

case succ
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
inst✝¹ : DecidableEq V
inst✝ : G.LocallyFinite
n : ℕ
ih : ∀ (u v : V), ↑(G.finsetWalkLength n u v) = {p | p.length = n}
u v : V
⊢ ↑(G.finsetWalkLength (n + 1) u v) = {p | p.length = n + 1}
tactic: induction' n with n ih generalizing u v
Theorem: CochainComplex.HomComplex.Cochain.smul_comp
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₁ n₂ n₁₂ : ℤ
k : R
z₁ : Cochain F G n₁
z₂ : Cochain G K n₂
h : n₁ + n₂ = n₁₂
⊢ (k • z₁).comp z₂ h = k • z₁.comp z₂ h
state_after: case h
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₁ n₂ n₁₂ : ℤ
k : R
z₁ : Cochain F G n₁
z₂ : Cochain G K n₂
h : n₁ + n₂ = n₁₂
p q : ℤ
hpq : p + n₁₂ = q
⊢ ((k • z₁).comp z₂ h).v p q hpq = (k • z₁.comp z₂ h).v p q hpq
tactic: ext p q hpq
state_before: case h
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₁ n₂ n₁₂ : ℤ
k : R
z₁ : Cochain F G n₁
z₂ : Cochain G K n₂
h : n₁ + n₂ = n₁₂
p q : ℤ
hpq : p + n₁₂ = q
⊢ ((k • z₁).comp z₂ h).v p q hpq = (k • z₁.comp z₂ h).v p q hpq
state_after: no goals
tactic: simp only [comp_v _ _ h p _ q rfl (by omega), smul_v, Linear.smul_comp]
Theorem: Equiv.boolProdNatEquivNat_symm_apply
File: Mathlib/Logic/Equiv/Nat.lean

Proof steps:
state_before: α : Type u_1
x✝ : Bool × ℕ
b : Bool
n : ℕ
⊢ (uncurry bit (b, n)).boddDiv2 = (b, n)
state_after: no goals
tactic: simp only [bodd_bit, div2_bit, uncurry_apply_pair, boddDiv2_eq]
state_before: α : Type u_1
n : ℕ
⊢ uncurry bit n.boddDiv2 = n
state_after: no goals
tactic: simp only [bit_decomp, boddDiv2_eq, uncurry_apply_pair]
Theorem: RelHomClass.acc
File: Mathlib/Order/RelIso/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
u : δ → δ → Prop
F : Type u_5
inst✝¹ : FunLike F α β
inst✝ : RelHomClass F r s
f : F
a : α
⊢ Acc s (f a) → Acc r a
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
u : δ → δ → Prop
F : Type u_5
inst✝¹ : FunLike F α β
inst✝ : RelHomClass F r s
f : F
a : α
b : β
h : f a = b
⊢ Acc s b → Acc r a
tactic: generalize h : f a = b
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
u : δ → δ → Prop
F : Type u_5
inst✝¹ : FunLike F α β
inst✝ : RelHomClass F r s
f : F
a : α
b : β
h : f a = b
⊢ Acc s b → Acc r a
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
u : δ → δ → Prop
F : Type u_5
inst✝¹ : FunLike F α β
inst✝ : RelHomClass F r s
f : F
a : α
b : β
h : f a = b
ac : Acc s b
⊢ Acc r a
tactic: intro ac
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
u : δ → δ → Prop
F : Type u_5
inst✝¹ : FunLike F α β
inst✝ : RelHomClass F r s
f : F
a : α
b : β
h : f a = b
ac : Acc s b
⊢ Acc r a
state_after: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
u : δ → δ → Prop
F : Type u_5
inst✝¹ : FunLike F α β
inst✝ : RelHomClass F r s
f : F
b x✝ : β
H : ∀ (y : β), s y x✝ → Acc s y
IH : ∀ (y : β), s y x✝ → ∀ (a : α), f a = y → Acc r a
a : α
h : f a = x✝
⊢ Acc r a
tactic: induction' ac with _ H IH generalizing a
state_before: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
u : δ → δ → Prop
F : Type u_5
inst✝¹ : FunLike F α β
inst✝ : RelHomClass F r s
f : F
b x✝ : β
H : ∀ (y : β), s y x✝ → Acc s y
IH : ∀ (y : β), s y x✝ → ∀ (a : α), f a = y → Acc r a
a : α
h : f a = x✝
⊢ Acc r a
state_after: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
u : δ → δ → Prop
F : Type u_5
inst✝¹ : FunLike F α β
inst✝ : RelHomClass F r s
f : F
b : β
a : α
H : ∀ (y : β), s y (f a) → Acc s y
IH : ∀ (y : β), s y (f a) → ∀ (a : α), f a = y → Acc r a
⊢ Acc r a
tactic: subst h
state_before: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
u : δ → δ → Prop
F : Type u_5
inst✝¹ : FunLike F α β
inst✝ : RelHomClass F r s
f : F
b : β
a : α
H : ∀ (y : β), s y (f a) → Acc s y
IH : ∀ (y : β), s y (f a) → ∀ (a : α), f a = y → Acc r a
⊢ Acc r a
state_after: no goals
tactic: exact ⟨_, fun a' h => IH (f a') (map_rel f h) _ rfl⟩