ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Finset.nonMemberSubfamily_nonMemberSubfamily
File: Mathlib/Combinatorics/SetFamily/Compression/Down.lean

Proof steps:
state_before: α : Type u_1
inst✝ : DecidableEq α
𝒜 ℬ : Finset (Finset α)
s : Finset α
a : α
⊢ nonMemberSubfamily a (nonMemberSubfamily a 𝒜) = nonMemberSubfamily a 𝒜
state_after: case a
α : Type u_1
inst✝ : DecidableEq α
𝒜 ℬ : Finset (Finset α)
s : Finset α
a : α
a✝ : Finset α
⊢ a✝ ∈ nonMemberSubfamily a (nonMemberSubfamily a 𝒜) ↔ a✝ ∈ nonMemberSubfamily a 𝒜
tactic: ext
state_before: case a
α : Type u_1
inst✝ : DecidableEq α
𝒜 ℬ : Finset (Finset α)
s : Finset α
a : α
a✝ : Finset α
⊢ a✝ ∈ nonMemberSubfamily a (nonMemberSubfamily a 𝒜) ↔ a✝ ∈ nonMemberSubfamily a 𝒜
state_after: no goals
tactic: simp
Theorem: Rat.sub_def
File: .lake/packages/batteries/Batteries/Data/Rat/Lemmas.lean

Proof steps:
state_before: a b : Rat
⊢ a - b = normalize (a.num * ↑b.den - b.num * ↑a.den) (a.den * b.den) ⋯
state_after: a b : Rat
⊢ a.sub b = normalize (a.num * ↑b.den - b.num * ↑a.den) (a.den * b.den) ⋯
tactic: show Rat.sub .. = _
state_before: a b : Rat
⊢ a.sub b = normalize (a.num * ↑b.den - b.num * ↑a.den) (a.den * b.den) ⋯
state_after: a b : Rat
⊢ (let g := a.den.gcd b.den;
    if hg : g = 1 then
      let_fun den_nz := ⋯;
      let_fun reduced := ⋯;
      { num := a.num * ↑b.den - b.num * ↑a.den, den := a.den * b.den, den_nz := den_nz, reduced := reduced }
    else
      let den := a.den / g * b.den;
      let num := a.num * ↑(b.den / g) - b.num * ↑(a.den / g);
      let g1 := num.natAbs.gcd g;
      let_fun den_nz := ⋯;
      let_fun e := ⋯;
      maybeNormalize num den g1 ⋯ ⋯) =
    normalize (a.num * ↑b.den - b.num * ↑a.den) (a.den * b.den) ⋯
tactic: delta Rat.sub
state_before: a b : Rat
⊢ (let g := a.den.gcd b.den;
    if hg : g = 1 then
      let_fun den_nz := ⋯;
      let_fun reduced := ⋯;
      { num := a.num * ↑b.den - b.num * ↑a.den, den := a.den * b.den, den_nz := den_nz, reduced := reduced }
    else
      let den := a.den / g * b.den;
      let num := a.num * ↑(b.den / g) - b.num * ↑(a.den / g);
      let g1 := num.natAbs.gcd g;
      let_fun den_nz := ⋯;
      let_fun e := ⋯;
      maybeNormalize num den g1 ⋯ ⋯) =
    normalize (a.num * ↑b.den - b.num * ↑a.den) (a.den * b.den) ⋯
state_after: a b : Rat
⊢ (if hg : a.den.gcd b.den = 1 then
      { num := a.num * ↑b.den - b.num * ↑a.den, den := a.den * b.den, den_nz := ⋯, reduced := ⋯ }
    else
      maybeNormalize (a.num * ↑(b.den / a.den.gcd b.den) - b.num * ↑(a.den / a.den.gcd b.den))
        (a.den / a.den.gcd b.den * b.den)
        ((a.num * ↑(b.den / a.den.gcd b.den) - b.num * ↑(a.den / a.den.gcd b.den)).natAbs.gcd (a.den.gcd b.den)) ⋯ ⋯) =
    normalize (a.num * ↑b.den - b.num * ↑a.den) (a.den * b.den) ⋯
tactic: dsimp only
state_before: a b : Rat
⊢ (if hg : a.den.gcd b.den = 1 then
      { num := a.num * ↑b.den - b.num * ↑a.den, den := a.den * b.den, den_nz := ⋯, reduced := ⋯ }
    else
      maybeNormalize (a.num * ↑(b.den / a.den.gcd b.den) - b.num * ↑(a.den / a.den.gcd b.den))
        (a.den / a.den.gcd b.den * b.den)
        ((a.num * ↑(b.den / a.den.gcd b.den) - b.num * ↑(a.den / a.den.gcd b.den)).natAbs.gcd (a.den.gcd b.den)) ⋯ ⋯) =
    normalize (a.num * ↑b.den - b.num * ↑a.den) (a.den * b.den) ⋯
state_after: case isTrue
a b : Rat
h✝ : a.den.gcd b.den = 1
⊢ { num := a.num * ↑b.den - b.num * ↑a.den, den := a.den * b.den, den_nz := ⋯, reduced := ⋯ } =
    normalize (a.num * ↑b.den - b.num * ↑a.den) (a.den * b.den) ⋯

case isFalse
a b : Rat
h✝ : ¬a.den.gcd b.den = 1
⊢ maybeNormalize (a.num * ↑(b.den / a.den.gcd b.den) - b.num * ↑(a.den / a.den.gcd b.den))
      (a.den / a.den.gcd b.den * b.den)
      ((a.num * ↑(b.den / a.den.gcd b.den) - b.num * ↑(a.den / a.den.gcd b.den)).natAbs.gcd (a.den.gcd b.den)) ⋯ ⋯ =
    normalize (a.num * ↑b.den - b.num * ↑a.den) (a.den * b.den) ⋯
tactic: split
Theorem: Even.neg_pow
File: Mathlib/Algebra/Ring/Parity.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
R : Type u_4
inst✝¹ : Monoid α
inst✝ : HasDistribNeg α
n : ℕ
a : α
⊢ Even n → ∀ (a : α), (-a) ^ n = a ^ n
state_after: case intro
F : Type u_1
α : Type u_2
β : Type u_3
R : Type u_4
inst✝¹ : Monoid α
inst✝ : HasDistribNeg α
a✝ : α
c : ℕ
a : α
⊢ (-a) ^ (c + c) = a ^ (c + c)
tactic: rintro ⟨c, rfl⟩ a
state_before: case intro
F : Type u_1
α : Type u_2
β : Type u_3
R : Type u_4
inst✝¹ : Monoid α
inst✝ : HasDistribNeg α
a✝ : α
c : ℕ
a : α
⊢ (-a) ^ (c + c) = a ^ (c + c)
state_after: no goals
tactic: simp_rw [← two_mul, pow_mul, neg_sq]
Theorem: IsRelPrime.mul_right
File: Mathlib/Algebra/Divisibility/Units.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : CommMonoid α
x y z : α
inst✝ : DecompositionMonoid α
H1 : IsRelPrime x y
H2 : IsRelPrime x z
⊢ IsRelPrime x (y * z)
state_after: α : Type u_1
inst✝¹ : CommMonoid α
x y z : α
inst✝ : DecompositionMonoid α
H1 : IsRelPrime y x
H2 : IsRelPrime z x
⊢ IsRelPrime (y * z) x
tactic: rw [isRelPrime_comm] at H1 H2 ⊢
state_before: α : Type u_1
inst✝¹ : CommMonoid α
x y z : α
inst✝ : DecompositionMonoid α
H1 : IsRelPrime y x
H2 : IsRelPrime z x
⊢ IsRelPrime (y * z) x
state_after: no goals
tactic: exact H1.mul_left H2
Theorem: preNormEDS_one
File: Mathlib/NumberTheory/EllipticDivisibilitySequence.lean

Proof steps:
state_before: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
W : ℤ → R
f : R →+* S
b c d : R
⊢ preNormEDS b c d 1 = 1
state_after: no goals
tactic: erw [preNormEDS_ofNat, preNormEDS'_one]
Theorem: CategoryTheory.Limits.MulticospanIndex.multiforkEquivPiFork_functor
File: Mathlib/CategoryTheory/Limits/Shapes/Multiequalizer.lean

Proof steps:
state_before: C : Type u
inst✝² : Category.{v, u} C
I : MulticospanIndex C
inst✝¹ : HasProduct I.left
inst✝ : HasProduct I.right
K : Multifork I
⊢ ∀ (j : WalkingMulticospan I.fstTo I.sndTo),
    ((𝟭 (Multifork I)).obj K).π.app j =
      (Iso.refl ((𝟭 (Multifork I)).obj K).pt).hom ≫ ((I.toPiForkFunctor ⋙ I.ofPiForkFunctor).obj K).π.app j
state_after: no goals
tactic: rintro (_ | _) <;> simp [← Fork.app_one_eq_ι_comp_left]
Theorem: tendsto_comp_coe_Ioo_atBot
File: Mathlib/Topology/Order/DenselyOrdered.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderTopology α
inst✝ : DenselyOrdered α
a b : α
s : Set α
l : Filter β
f : α → β
h : a < b
⊢ Tendsto (fun x => f ↑x) atBot l ↔ Tendsto f (𝓝[>] a) l
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderTopology α
inst✝ : DenselyOrdered α
a b : α
s : Set α
l : Filter β
f : α → β
h : a < b
⊢ Tendsto (fun x => f ↑x) atBot l ↔ Tendsto (f ∘ Subtype.val) atBot l
tactic: rw [← map_coe_Ioo_atBot h, tendsto_map'_iff]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderTopology α
inst✝ : DenselyOrdered α
a b : α
s : Set α
l : Filter β
f : α → β
h : a < b
⊢ Tendsto (fun x => f ↑x) atBot l ↔ Tendsto (f ∘ Subtype.val) atBot l
state_after: no goals
tactic: rfl
Theorem: inv_eq_one_divp
File: Mathlib/Algebra/Group/Units.lean

Proof steps:
state_before: α : Type u
inst✝ : Monoid α
a b c : α
u : αˣ
⊢ ↑u⁻¹ = 1 /ₚ u
state_after: no goals
tactic: rw [one_divp]
Theorem: MeasureTheory.eLpNorm'_zero
File: Mathlib/MeasureTheory/Function/LpSeminorm/Basic.lean

Proof steps:
state_before: α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
hp0_lt : 0 < q
⊢ eLpNorm' 0 q μ = 0
state_after: no goals
tactic: simp [eLpNorm', hp0_lt]
Theorem: Nat.coprime_two_left
File: Mathlib/Data/Nat/Prime/Basic.lean

Proof steps:
state_before: n : ℕ
⊢ Coprime 2 n ↔ Odd n
state_after: no goals
tactic: rw [prime_two.coprime_iff_not_dvd, odd_iff_not_even, even_iff_two_dvd]
Theorem: LinearMap.eventually_isCompl_ker_pow_range_pow
File: Mathlib/RingTheory/Artinian.lean

Proof steps:
state_before: R : Type u_1
M : Type u_2
inst✝⁴ : Ring R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : IsArtinian R M
inst✝ : IsNoetherian R M
f : M →ₗ[R] M
⊢ ∀ᶠ (n : ℕ) in atTop, IsCompl (ker (f ^ n)) (range (f ^ n))
state_after: case h
R : Type u_1
M : Type u_2
inst✝⁴ : Ring R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : IsArtinian R M
inst✝ : IsNoetherian R M
f : M →ₗ[R] M
n : ℕ
hn : Disjoint (ker (f ^ n)) (range (f ^ n)) ∧ Codisjoint (ker (f ^ n)) (range (f ^ n))
⊢ IsCompl (ker (f ^ n)) (range (f ^ n))
tactic: filter_upwards [f.eventually_disjoint_ker_pow_range_pow.and
    f.eventually_codisjoint_ker_pow_range_pow] with n hn
state_before: case h
R : Type u_1
M : Type u_2
inst✝⁴ : Ring R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : IsArtinian R M
inst✝ : IsNoetherian R M
f : M →ₗ[R] M
n : ℕ
hn : Disjoint (ker (f ^ n)) (range (f ^ n)) ∧ Codisjoint (ker (f ^ n)) (range (f ^ n))
⊢ IsCompl (ker (f ^ n)) (range (f ^ n))
state_after: no goals
tactic: simpa only [isCompl_iff]
Theorem: AlgebraicGeometry.LocallyRingedSpace.preimage_basicOpen
File: Mathlib/Geometry/RingedSpace/LocallyRingedSpace.lean

Proof steps:
state_before: X✝ X Y : LocallyRingedSpace
f : X ⟶ Y
U : Opens ↑Y.toTopCat
s : ↑(Y.presheaf.obj (op U))
⊢ (Opens.map f.val.base).obj (Y.toRingedSpace.basicOpen s) = X.toRingedSpace.basicOpen ((f.val.c.app (op U)) s)
state_after: case h.h
X✝ X Y : LocallyRingedSpace
f : X ⟶ Y
U : Opens ↑Y.toTopCat
s : ↑(Y.presheaf.obj (op U))
x : ↑↑X.toPresheafedSpace
⊢ x ∈ ↑((Opens.map f.val.base).obj (Y.toRingedSpace.basicOpen s)) ↔
    x ∈ ↑(X.toRingedSpace.basicOpen ((f.val.c.app (op U)) s))
tactic: ext x
state_before: case h.h
X✝ X Y : LocallyRingedSpace
f : X ⟶ Y
U : Opens ↑Y.toTopCat
s : ↑(Y.presheaf.obj (op U))
x : ↑↑X.toPresheafedSpace
⊢ x ∈ ↑((Opens.map f.val.base).obj (Y.toRingedSpace.basicOpen s)) ↔
    x ∈ ↑(X.toRingedSpace.basicOpen ((f.val.c.app (op U)) s))
state_after: case h.h.mp
X✝ X Y : LocallyRingedSpace
f : X ⟶ Y
U : Opens ↑Y.toTopCat
s : ↑(Y.presheaf.obj (op U))
x : ↑↑X.toPresheafedSpace
⊢ x ∈ ↑((Opens.map f.val.base).obj (Y.toRingedSpace.basicOpen s)) →
    x ∈ ↑(X.toRingedSpace.basicOpen ((f.val.c.app (op U)) s))

case h.h.mpr
X✝ X Y : LocallyRingedSpace
f : X ⟶ Y
U : Opens ↑Y.toTopCat
s : ↑(Y.presheaf.obj (op U))
x : ↑↑X.toPresheafedSpace
⊢ x ∈ ↑(X.toRingedSpace.basicOpen ((f.val.c.app (op U)) s)) →
    x ∈ ↑((Opens.map f.val.base).obj (Y.toRingedSpace.basicOpen s))
tactic: constructor
Theorem: Pell.IsFundamental.exists_of_not_isSquare
File: Mathlib/NumberTheory/Pell.lean

Proof steps:
state_before: d : ℤ
h₀ : 0 < d
hd : ¬IsSquare d
⊢ ∃ a, IsFundamental a
state_after: case intro.intro
d : ℤ
h₀ : 0 < d
hd : ¬IsSquare d
a : Solution₁ d
ha₁ : 1 < a.x
ha₂ : 0 < a.y
⊢ ∃ a, IsFundamental a
tactic: obtain ⟨a, ha₁, ha₂⟩ := exists_pos_of_not_isSquare h₀ hd
state_before: case intro.intro
d : ℤ
h₀ : 0 < d
hd : ¬IsSquare d
a : Solution₁ d
ha₁ : 1 < a.x
ha₂ : 0 < a.y
⊢ ∃ a, IsFundamental a
state_after: case intro.intro
d : ℤ
h₀ : 0 < d
hd : ¬IsSquare d
a : Solution₁ d
ha₁ : 1 < a.x
ha₂ : 0 < a.y
P : ∃ x', 1 < x' ∧ ∃ y', 0 < y' ∧ ↑x' ^ 2 - d * y' ^ 2 = 1
⊢ ∃ a, IsFundamental a
tactic: have P : ∃ x' : ℕ, 1 < x' ∧ ∃ y' : ℤ, 0 < y' ∧ (x' : ℤ) ^ 2 - d * y' ^ 2 = 1 := by
    have hax := a.prop
    lift a.x to ℕ using by positivity with ax
    norm_cast at ha₁
    exact ⟨ax, ha₁, a.y, ha₂, hax⟩
state_before: case intro.intro
d : ℤ
h₀ : 0 < d
hd : ¬IsSquare d
a : Solution₁ d
ha₁ : 1 < a.x
ha₂ : 0 < a.y
P : ∃ x', 1 < x' ∧ ∃ y', 0 < y' ∧ ↑x' ^ 2 - d * y' ^ 2 = 1
⊢ ∃ a, IsFundamental a
state_after: no goals
tactic: classical
  -- to avoid having to show that the predicate is decidable
  let x₁ := Nat.find P
  obtain ⟨hx, y₁, hy₀, hy₁⟩ := Nat.find_spec P
  refine ⟨mk x₁ y₁ hy₁, by rw [x_mk]; exact mod_cast hx, hy₀, fun {b} hb => ?_⟩
  rw [x_mk]
  have hb' := (Int.toNat_of_nonneg <| zero_le_one.trans hb.le).symm
  have hb'' := hb
  rw [hb'] at hb ⊢
  norm_cast at hb ⊢
  refine Nat.find_min' P ⟨hb, |b.y|, abs_pos.mpr <| y_ne_zero_of_one_lt_x hb'', ?_⟩
  rw [← hb', sq_abs]
  exact b.prop
Theorem: ProbabilityTheory.iCondIndep_iff_iCondIndepSets
File: Mathlib/Probability/Independence/Conditional.lean

Proof steps:
state_before: Ω : Type u_1
ι : Type u_2
m' mΩ : MeasurableSpace Ω
inst✝² : StandardBorelSpace Ω
inst✝¹ : Nonempty Ω
hm' : m' ≤ mΩ
m : ι → MeasurableSpace Ω
μ : Measure Ω
inst✝ : IsFiniteMeasure μ
⊢ iCondIndep m' hm' m μ ↔ iCondIndepSets m' hm' (fun x => {s | MeasurableSet s}) μ
state_after: no goals
tactic: simp only [iCondIndep, iCondIndepSets, Kernel.iIndep]
Theorem: CategoryTheory.Functor.mapTriangleRotateIso_inv_app_hom₃
File: Mathlib/CategoryTheory/Triangulated/Functor.lean

Proof steps:
state_before: C : Type u_1
D : Type u_2
E : Type u_3
inst✝¹⁰ : Category.{?u.192876, u_1} C
inst✝⁹ : Category.{?u.192880, u_2} D
inst✝⁸ : Category.{?u.192884, u_3} E
inst✝⁷ : HasShift C ℤ
inst✝⁶ : HasShift D ℤ
inst✝⁵ : HasShift E ℤ
F : C ⥤ D
inst✝⁴ : F.CommShift ℤ
G : D ⥤ E
inst✝³ : G.CommShift ℤ
inst✝² : Preadditive C
inst✝¹ : Preadditive D
inst✝ : F.Additive
T : Triangle C
⊢ ((F.mapTriangle ⋙ rotate D).obj T).mor₁ ≫ (Iso.refl ((F.mapTriangle ⋙ rotate D).obj T).obj₂).hom =
    (Iso.refl ((F.mapTriangle ⋙ rotate D).obj T).obj₁).hom ≫ ((rotate C ⋙ F.mapTriangle).obj T).mor₁
state_after: no goals
tactic: aesop_cat
state_before: C : Type u_1
D : Type u_2
E : Type u_3
inst✝¹⁰ : Category.{?u.192876, u_1} C
inst✝⁹ : Category.{?u.192880, u_2} D
inst✝⁸ : Category.{?u.192884, u_3} E
inst✝⁷ : HasShift C ℤ
inst✝⁶ : HasShift D ℤ
inst✝⁵ : HasShift E ℤ
F : C ⥤ D
inst✝⁴ : F.CommShift ℤ
G : D ⥤ E
inst✝³ : G.CommShift ℤ
inst✝² : Preadditive C
inst✝¹ : Preadditive D
inst✝ : F.Additive
T : Triangle C
⊢ ((F.mapTriangle ⋙ rotate D).obj T).mor₂ ≫ ((F.commShiftIso 1).symm.app T.obj₁).hom =
    (Iso.refl ((F.mapTriangle ⋙ rotate D).obj T).obj₂).hom ≫ ((rotate C ⋙ F.mapTriangle).obj T).mor₂
state_after: no goals
tactic: aesop_cat
state_before: C : Type u_1
D : Type u_2
E : Type u_3
inst✝¹⁰ : Category.{?u.192876, u_1} C
inst✝⁹ : Category.{?u.192880, u_2} D
inst✝⁸ : Category.{?u.192884, u_3} E
inst✝⁷ : HasShift C ℤ
inst✝⁶ : HasShift D ℤ
inst✝⁵ : HasShift E ℤ
F : C ⥤ D
inst✝⁴ : F.CommShift ℤ
G : D ⥤ E
inst✝³ : G.CommShift ℤ
inst✝² : Preadditive C
inst✝¹ : Preadditive D
inst✝ : F.Additive
T : Triangle C
⊢ ((F.mapTriangle ⋙ rotate D).obj T).mor₃ ≫
      (shiftFunctor D 1).map (Iso.refl ((F.mapTriangle ⋙ rotate D).obj T).obj₁).hom =
    ((F.commShiftIso 1).symm.app T.obj₁).hom ≫ ((rotate C ⋙ F.mapTriangle).obj T).mor₃
state_after: no goals
tactic: aesop_cat
state_before: C : Type u_1
D : Type u_2
E : Type u_3
inst✝¹⁰ : Category.{?u.192876, u_1} C
inst✝⁹ : Category.{?u.192880, u_2} D
inst✝⁸ : Category.{?u.192884, u_3} E
inst✝⁷ : HasShift C ℤ
inst✝⁶ : HasShift D ℤ
inst✝⁵ : HasShift E ℤ
F : C ⥤ D
inst✝⁴ : F.CommShift ℤ
G : D ⥤ E
inst✝³ : G.CommShift ℤ
inst✝² : Preadditive C
inst✝¹ : Preadditive D
inst✝ : F.Additive
⊢ ∀ {X Y : Triangle C} (f : X ⟶ Y),
    (F.mapTriangle ⋙ rotate D).map f ≫
        ((fun T =>
              ((F.mapTriangle ⋙ rotate D).obj T).isoMk ((rotate C ⋙ F.mapTriangle).obj T)
                (Iso.refl ((F.mapTriangle ⋙ rotate D).obj T).obj₁) (Iso.refl ((F.mapTriangle ⋙ rotate D).obj T).obj₂)
                ((F.commShiftIso 1).symm.app T.obj₁) ⋯ ⋯ ⋯)
            Y).hom =
      ((fun T =>
              ((F.mapTriangle ⋙ rotate D).obj T).isoMk ((rotate C ⋙ F.mapTriangle).obj T)
                (Iso.refl ((F.mapTriangle ⋙ rotate D).obj T).obj₁) (Iso.refl ((F.mapTriangle ⋙ rotate D).obj T).obj₂)
                ((F.commShiftIso 1).symm.app T.obj₁) ⋯ ⋯ ⋯)
            X).hom ≫
        (rotate C ⋙ F.mapTriangle).map f
state_after: no goals
tactic: aesop_cat
Theorem: MeasureTheory.L1.SimpleFunc.norm_Integral_le_one
File: Mathlib/MeasureTheory/Integral/Bochner.lean

Proof steps:
state_before: α : Type u_1
E : Type u_2
F : Type u_3
𝕜 : Type u_4
inst✝¹⁰ : NormedAddCommGroup E
inst✝⁹ : NormedAddCommGroup F
m : MeasurableSpace α
μ : Measure α
inst✝⁸ : NormedField 𝕜
inst✝⁷ : NormedSpace 𝕜 E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : SMulCommClass ℝ 𝕜 E
F' : Type u_5
inst✝⁴ : NormedAddCommGroup F'
inst✝³ : NormedSpace ℝ F'
E' : Type u_6
inst✝² : NormedAddCommGroup E'
inst✝¹ : NormedSpace ℝ E'
inst✝ : NormedSpace 𝕜 E'
f : ↥(simpleFunc E 1 μ)
⊢ ‖{ toFun := integral, map_add' := ⋯, map_smul' := ⋯ } f‖ ≤ 1 * ‖f‖
state_after: α : Type u_1
E : Type u_2
F : Type u_3
𝕜 : Type u_4
inst✝¹⁰ : NormedAddCommGroup E
inst✝⁹ : NormedAddCommGroup F
m : MeasurableSpace α
μ : Measure α
inst✝⁸ : NormedField 𝕜
inst✝⁷ : NormedSpace 𝕜 E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : SMulCommClass ℝ 𝕜 E
F' : Type u_5
inst✝⁴ : NormedAddCommGroup F'
inst✝³ : NormedSpace ℝ F'
E' : Type u_6
inst✝² : NormedAddCommGroup E'
inst✝¹ : NormedSpace ℝ E'
inst✝ : NormedSpace 𝕜 E'
f : ↥(simpleFunc E 1 μ)
⊢ ‖{ toFun := integral, map_add' := ⋯, map_smul' := ⋯ } f‖ ≤ ‖f‖
tactic: rw [one_mul]
state_before: α : Type u_1
E : Type u_2
F : Type u_3
𝕜 : Type u_4
inst✝¹⁰ : NormedAddCommGroup E
inst✝⁹ : NormedAddCommGroup F
m : MeasurableSpace α
μ : Measure α
inst✝⁸ : NormedField 𝕜
inst✝⁷ : NormedSpace 𝕜 E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : SMulCommClass ℝ 𝕜 E
F' : Type u_5
inst✝⁴ : NormedAddCommGroup F'
inst✝³ : NormedSpace ℝ F'
E' : Type u_6
inst✝² : NormedAddCommGroup E'
inst✝¹ : NormedSpace ℝ E'
inst✝ : NormedSpace 𝕜 E'
f : ↥(simpleFunc E 1 μ)
⊢ ‖{ toFun := integral, map_add' := ⋯, map_smul' := ⋯ } f‖ ≤ ‖f‖
state_after: no goals
tactic: exact norm_integral_le_norm f
Theorem: summable_riemannZetaSummand
File: Mathlib/NumberTheory/EulerProduct/DirichletLSeries.lean

Proof steps:
state_before: s : ℂ
hs : 1 < s.re
⊢ Summable fun n => ‖(riemannZetaSummandHom ⋯) n‖
state_after: s : ℂ
hs : 1 < s.re
⊢ Summable fun n => ‖↑n ^ (-s)‖
tactic: simp only [riemannZetaSummandHom, MonoidWithZeroHom.coe_mk, ZeroHom.coe_mk]
state_before: s : ℂ
hs : 1 < s.re
⊢ Summable fun n => ‖↑n ^ (-s)‖
state_after: case h.e'_5.h
s : ℂ
hs : 1 < s.re
n : ℕ
⊢ ‖↑n ^ (-s)‖ = (↑n ^ s.re)⁻¹
tactic: convert Real.summable_nat_rpow_inv.mpr hs with n
state_before: case h.e'_5.h
s : ℂ
hs : 1 < s.re
n : ℕ
⊢ ‖↑n ^ (-s)‖ = (↑n ^ s.re)⁻¹
state_after: no goals
tactic: rw [← ofReal_natCast, Complex.norm_eq_abs,
    abs_cpow_eq_rpow_re_of_nonneg (Nat.cast_nonneg n) <| re_neg_ne_zero_of_one_lt_re hs,
    neg_re, Real.rpow_neg <| Nat.cast_nonneg n]
Theorem: FormalMultilinearSeries.norm_apply_eq_norm_coef
File: Mathlib/Analysis/Calculus/FormalMultilinearSeries.lean

Proof steps:
state_before: 𝕜 : Type u
𝕜' : Type u'
E : Type v
F : Type w
G : Type x
inst✝² : NontriviallyNormedField 𝕜
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
s : E
p : FormalMultilinearSeries 𝕜 𝕜 E
f : 𝕜 → E
n : ℕ
z z₀ : 𝕜
y : Fin n → 𝕜
⊢ ‖p n‖ = ‖p.coeff n‖
state_after: no goals
tactic: rw [← mkPiRing_coeff_eq p, ContinuousMultilinearMap.norm_mkPiRing]
Theorem: Pi.continuous_uncurry
File: Mathlib/Control/LawfulFix.lean

Proof steps:
state_before: α : Type u_1
β : α → Type u_2
γ : (a : α) → β a → Type u_3
inst✝ : (x : α) → (y : β x) → OmegaCompletePartialOrder (γ x y)
c : Chain ((a : α) → (b : β a) → γ a b)
⊢ (monotoneUncurry α β γ) (ωSup c) = ωSup (c.map (monotoneUncurry α β γ))
state_after: case h.mk
α : Type u_1
β : α → Type u_2
γ : (a : α) → β a → Type u_3
inst✝ : (x : α) → (y : β x) → OmegaCompletePartialOrder (γ x y)
c : Chain ((a : α) → (b : β a) → γ a b)
x : α
y : β x
⊢ (monotoneUncurry α β γ) (ωSup c) ⟨x, y⟩ = ωSup (c.map (monotoneUncurry α β γ)) ⟨x, y⟩
tactic: ext ⟨x, y⟩
state_before: case h.mk
α : Type u_1
β : α → Type u_2
γ : (a : α) → β a → Type u_3
inst✝ : (x : α) → (y : β x) → OmegaCompletePartialOrder (γ x y)
c : Chain ((a : α) → (b : β a) → γ a b)
x : α
y : β x
⊢ (monotoneUncurry α β γ) (ωSup c) ⟨x, y⟩ = ωSup (c.map (monotoneUncurry α β γ)) ⟨x, y⟩
state_after: case h.mk
α : Type u_1
β : α → Type u_2
γ : (a : α) → β a → Type u_3
inst✝ : (x : α) → (y : β x) → OmegaCompletePartialOrder (γ x y)
c : Chain ((a : α) → (b : β a) → γ a b)
x : α
y : β x
⊢ ωSup ((c.map (evalOrderHom x)).map (evalOrderHom y)) =
    ωSup ((c.map (monotoneUncurry α β γ)).map (evalOrderHom ⟨x, y⟩))
tactic: dsimp [uncurry, ωSup]
state_before: case h.mk
α : Type u_1
β : α → Type u_2
γ : (a : α) → β a → Type u_3
inst✝ : (x : α) → (y : β x) → OmegaCompletePartialOrder (γ x y)
c : Chain ((a : α) → (b : β a) → γ a b)
x : α
y : β x
⊢ ωSup ((c.map (evalOrderHom x)).map (evalOrderHom y)) =
    ωSup ((c.map (monotoneUncurry α β γ)).map (evalOrderHom ⟨x, y⟩))
state_after: case h.mk
α : Type u_1
β : α → Type u_2
γ : (a : α) → β a → Type u_3
inst✝ : (x : α) → (y : β x) → OmegaCompletePartialOrder (γ x y)
c : Chain ((a : α) → (b : β a) → γ a b)
x : α
y : β x
⊢ ωSup (c.map ((evalOrderHom y).comp (evalOrderHom x))) =
    ωSup (c.map ((evalOrderHom ⟨x, y⟩).comp (monotoneUncurry α β γ)))
tactic: rw [map_comp, map_comp]
state_before: case h.mk
α : Type u_1
β : α → Type u_2
γ : (a : α) → β a → Type u_3
inst✝ : (x : α) → (y : β x) → OmegaCompletePartialOrder (γ x y)
c : Chain ((a : α) → (b : β a) → γ a b)
x : α
y : β x
⊢ ωSup (c.map ((evalOrderHom y).comp (evalOrderHom x))) =
    ωSup (c.map ((evalOrderHom ⟨x, y⟩).comp (monotoneUncurry α β γ)))
state_after: no goals
tactic: rfl
Theorem: inv_le_div_iff_le_mul'
File: Mathlib/Algebra/Order/Group/Unbundled/Basic.lean

Proof steps:
state_before: α : Type u
inst✝² : CommGroup α
inst✝¹ : LE α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b c d : α
⊢ a⁻¹ ≤ b / c ↔ c ≤ a * b
state_after: no goals
tactic: rw [inv_le_div_iff_le_mul, mul_comm]
Theorem: round_intCast
File: Mathlib/Algebra/Order/Floor.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
n : ℤ
⊢ round ↑n = n
state_after: no goals
tactic: simp [round]
Theorem: SimpleGraph.Subgraph.neighborSet_iInf
File: Mathlib/Combinatorics/SimpleGraph/Subgraph.lean

Proof steps:
state_before: ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G₁ G₂ : G.Subgraph
a b : V
f : ι → G.Subgraph
v : V
⊢ (⨅ i, f i).neighborSet v = (⋂ i, (f i).neighborSet v) ∩ G.neighborSet v
state_after: no goals
tactic: simp [iInf]
Theorem: Real.ceil_logb_natCast
File: Mathlib/Analysis/SpecialFunctions/Log/Base.lean

Proof steps:
state_before: b✝ x y : ℝ
b : ℕ
r : ℝ
hb : 1 < b
hr : 0 ≤ r
⊢ ⌈logb (↑b) r⌉ = Int.clog b r
state_after: case inl
b✝ x y : ℝ
b : ℕ
hb : 1 < b
hr : 0 ≤ 0
⊢ ⌈logb (↑b) 0⌉ = Int.clog b 0

case inr
b✝ x y : ℝ
b : ℕ
r : ℝ
hb : 1 < b
hr✝ : 0 ≤ r
hr : 0 < r
⊢ ⌈logb (↑b) r⌉ = Int.clog b r
tactic: obtain rfl | hr := hr.eq_or_lt
state_before: case inr
b✝ x y : ℝ
b : ℕ
r : ℝ
hb : 1 < b
hr✝ : 0 ≤ r
hr : 0 < r
⊢ ⌈logb (↑b) r⌉ = Int.clog b r
state_after: case inr
b✝ x y : ℝ
b : ℕ
r : ℝ
hb : 1 < b
hr✝ : 0 ≤ r
hr : 0 < r
hb1' : 1 < ↑b
⊢ ⌈logb (↑b) r⌉ = Int.clog b r
tactic: have hb1' : 1 < (b : ℝ) := Nat.one_lt_cast.mpr hb
state_before: case inr
b✝ x y : ℝ
b : ℕ
r : ℝ
hb : 1 < b
hr✝ : 0 ≤ r
hr : 0 < r
hb1' : 1 < ↑b
⊢ ⌈logb (↑b) r⌉ = Int.clog b r
state_after: case inr.a
b✝ x y : ℝ
b : ℕ
r : ℝ
hb : 1 < b
hr✝ : 0 ≤ r
hr : 0 < r
hb1' : 1 < ↑b
⊢ ⌈logb (↑b) r⌉ ≤ Int.clog b r

case inr.a
b✝ x y : ℝ
b : ℕ
r : ℝ
hb : 1 < b
hr✝ : 0 ≤ r
hr : 0 < r
hb1' : 1 < ↑b
⊢ Int.clog b r ≤ ⌈logb (↑b) r⌉
tactic: apply le_antisymm
Theorem: Ordinal.bsup_eq_blsub_or_succ_bsup_eq_blsub
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal.{u}
f : (a : Ordinal.{u}) → a < o → Ordinal.{max u v}
⊢ o.bsup f = o.blsub f ∨ succ (o.bsup f) = o.blsub f
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal.{u}
f : (a : Ordinal.{u}) → a < o → Ordinal.{max u v}
⊢ sup (o.familyOfBFamily f) = lsub (o.familyOfBFamily f) ∨ succ (sup (o.familyOfBFamily f)) = lsub (o.familyOfBFamily f)
tactic: rw [← sup_eq_bsup, ← lsub_eq_blsub]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal.{u}
f : (a : Ordinal.{u}) → a < o → Ordinal.{max u v}
⊢ sup (o.familyOfBFamily f) = lsub (o.familyOfBFamily f) ∨ succ (sup (o.familyOfBFamily f)) = lsub (o.familyOfBFamily f)
state_after: no goals
tactic: exact sup_eq_lsub_or_sup_succ_eq_lsub _
Theorem: Part.eq_none_iff
File: Mathlib/Data/Part.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
o : Part α
h : ∀ (a : α), a ∉ o
⊢ ∀ (a : α), a ∈ o ↔ a ∈ none
state_after: no goals
tactic: simpa