ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Ordinal.Cardinal.mk_iUnion_Ordinal_le_of_le
File: Mathlib/SetTheory/Cardinal/Ordinal.lean

Proof steps:
state_before: β : Type u_1
o : Ordinal.{u_1}
c : Cardinal.{u_1}
ho : o.card ≤ c
hc : ℵ₀ ≤ c
A : Ordinal.{u_1} → Set β
hA : ∀ j < o, #↑(A j) ≤ c
⊢ #↑(⋃ j, ⋃ (_ : j < o), A j) ≤ c
state_after: β : Type u_1
o : Ordinal.{u_1}
c : Cardinal.{u_1}
ho : o.card ≤ c
hc : ℵ₀ ≤ c
A : Ordinal.{u_1} → Set β
hA : ∀ j < o, #↑(A j) ≤ c
⊢ #↑(sSup (range ((fun x => A ↑x) ∘ ⇑o.enumIsoOut.symm))) ≤ c
tactic: simp_rw [← mem_Iio, biUnion_eq_iUnion, iUnion, iSup, ← o.enumIsoOut.symm.surjective.range_comp]
state_before: β : Type u_1
o : Ordinal.{u_1}
c : Cardinal.{u_1}
ho : o.card ≤ c
hc : ℵ₀ ≤ c
A : Ordinal.{u_1} → Set β
hA : ∀ j < o, #↑(A j) ≤ c
⊢ #↑(sSup (range ((fun x => A ↑x) ∘ ⇑o.enumIsoOut.symm))) ≤ c
state_after: β : Type u_1
o : Ordinal.{u_1}
c : Cardinal.{u_1}
ho : o.card ≤ c
hc : ℵ₀ ≤ c
A : Ordinal.{u_1} → Set β
hA : ∀ j < o, #↑(A j) ≤ c
⊢ #(Quotient.out o).α * ⨆ i, #↑(((fun x => A ↑x) ∘ ⇑o.enumIsoOut.symm) i) ≤ c * c
tactic: apply ((mk_iUnion_le _).trans _).trans_eq (mul_eq_self hc)
state_before: β : Type u_1
o : Ordinal.{u_1}
c : Cardinal.{u_1}
ho : o.card ≤ c
hc : ℵ₀ ≤ c
A : Ordinal.{u_1} → Set β
hA : ∀ j < o, #↑(A j) ≤ c
⊢ #(Quotient.out o).α * ⨆ i, #↑(((fun x => A ↑x) ∘ ⇑o.enumIsoOut.symm) i) ≤ c * c
state_after: β : Type u_1
o : Ordinal.{u_1}
c : Cardinal.{u_1}
ho : o.card ≤ c
hc : ℵ₀ ≤ c
A : Ordinal.{u_1} → Set β
hA : ∀ j < o, #↑(A j) ≤ c
⊢ o.card * ⨆ i, #↑(((fun x => A ↑x) ∘ ⇑o.enumIsoOut.symm) i) ≤ c * c
tactic: rw [mk_ordinal_out]
Theorem: Finset.trop_inf
File: Mathlib/Algebra/Tropical/BigOperators.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
inst✝¹ : LinearOrder R
inst✝ : OrderTop R
s : Finset S
f : S → R
⊢ trop (s.inf f) = ∑ i ∈ s, trop (f i)
state_after: case h.e'_3
R : Type u_1
S : Type u_2
inst✝¹ : LinearOrder R
inst✝ : OrderTop R
s : Finset S
f : S → R
⊢ ∑ i ∈ s, trop (f i) = (Multiset.map trop (Multiset.map f s.val)).sum
tactic: convert Multiset.trop_inf (s.val.map f)
state_before: case h.e'_3
R : Type u_1
S : Type u_2
inst✝¹ : LinearOrder R
inst✝ : OrderTop R
s : Finset S
f : S → R
⊢ ∑ i ∈ s, trop (f i) = (Multiset.map trop (Multiset.map f s.val)).sum
state_after: case h.e'_3
R : Type u_1
S : Type u_2
inst✝¹ : LinearOrder R
inst✝ : OrderTop R
s : Finset S
f : S → R
⊢ ∑ i ∈ s, trop (f i) = (Multiset.map (fun i => trop (f i)) s.val).sum
tactic: simp only [Multiset.map_map, Function.comp_apply]
state_before: case h.e'_3
R : Type u_1
S : Type u_2
inst✝¹ : LinearOrder R
inst✝ : OrderTop R
s : Finset S
f : S → R
⊢ ∑ i ∈ s, trop (f i) = (Multiset.map (fun i => trop (f i)) s.val).sum
state_after: no goals
tactic: rfl
Theorem: Filter.HasBasis.cauchySeq_iff
File: Mathlib/Topology/UniformSpace/Cauchy.lean

Proof steps:
state_before: α : Type u
β : Type v
uniformSpace : UniformSpace α
γ : Sort u_1
inst✝¹ : Nonempty β
inst✝ : SemilatticeSup β
u : β → α
p : γ → Prop
s : γ → Set (α × α)
h : (𝓤 α).HasBasis p s
⊢ CauchySeq u ↔ ∀ (i : γ), p i → ∃ N, ∀ (m : β), N ≤ m → ∀ (n : β), N ≤ n → (u m, u n) ∈ s i
state_after: α : Type u
β : Type v
uniformSpace : UniformSpace α
γ : Sort u_1
inst✝¹ : Nonempty β
inst✝ : SemilatticeSup β
u : β → α
p : γ → Prop
s : γ → Set (α × α)
h : (𝓤 α).HasBasis p s
⊢ Tendsto (Prod.map u u) (atTop ×ˢ atTop) (𝓤 α) ↔
    ∀ (i : γ), p i → ∃ N, ∀ (m : β), N ≤ m → ∀ (n : β), N ≤ n → (u m, u n) ∈ s i
tactic: rw [cauchySeq_iff_tendsto, ← prod_atTop_atTop_eq]
state_before: α : Type u
β : Type v
uniformSpace : UniformSpace α
γ : Sort u_1
inst✝¹ : Nonempty β
inst✝ : SemilatticeSup β
u : β → α
p : γ → Prop
s : γ → Set (α × α)
h : (𝓤 α).HasBasis p s
⊢ Tendsto (Prod.map u u) (atTop ×ˢ atTop) (𝓤 α) ↔
    ∀ (i : γ), p i → ∃ N, ∀ (m : β), N ≤ m → ∀ (n : β), N ≤ n → (u m, u n) ∈ s i
state_after: α : Type u
β : Type v
uniformSpace : UniformSpace α
γ : Sort u_1
inst✝¹ : Nonempty β
inst✝ : SemilatticeSup β
u : β → α
p : γ → Prop
s : γ → Set (α × α)
h : (𝓤 α).HasBasis p s
⊢ (∀ (ib : γ), p ib → ∃ ia, True ∧ ∀ x ∈ Ici ia ×ˢ Ici ia, Prod.map u u x ∈ s ib) ↔
    ∀ (i : γ), p i → ∃ N, ∀ (m : β), N ≤ m → ∀ (n : β), N ≤ n → (u m, u n) ∈ s i
tactic: refine (atTop_basis.prod_self.tendsto_iff h).trans ?_
state_before: α : Type u
β : Type v
uniformSpace : UniformSpace α
γ : Sort u_1
inst✝¹ : Nonempty β
inst✝ : SemilatticeSup β
u : β → α
p : γ → Prop
s : γ → Set (α × α)
h : (𝓤 α).HasBasis p s
⊢ (∀ (ib : γ), p ib → ∃ ia, True ∧ ∀ x ∈ Ici ia ×ˢ Ici ia, Prod.map u u x ∈ s ib) ↔
    ∀ (i : γ), p i → ∃ N, ∀ (m : β), N ≤ m → ∀ (n : β), N ≤ n → (u m, u n) ∈ s i
state_after: no goals
tactic: simp only [exists_prop, true_and_iff, MapsTo, preimage, subset_def, Prod.forall, mem_prod_eq,
    mem_setOf_eq, mem_Ici, and_imp, Prod.map, @forall_swap (_ ≤ _) β]
Theorem: iteratedFDeriv_add_apply
File: Mathlib/Analysis/Calculus/ContDiff/Basic.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f✝ f₁ : E → F
g✝ : F → G
x x₀ : E
c : F
b : E × F → G
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
i✝ i : ℕ
f g : E → F
hf : ContDiff 𝕜 (↑i) f
hg : ContDiff 𝕜 (↑i) g
⊢ iteratedFDeriv 𝕜 i (f + g) x = iteratedFDeriv 𝕜 i f x + iteratedFDeriv 𝕜 i g x
state_after: 𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f✝ f₁ : E → F
g✝ : F → G
x x₀ : E
c : F
b : E × F → G
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
i✝ i : ℕ
f g : E → F
hf : ContDiffOn 𝕜 (↑i) f univ
hg : ContDiffOn 𝕜 (↑i) g univ
⊢ iteratedFDerivWithin 𝕜 i (f + g) univ x = iteratedFDerivWithin 𝕜 i f univ x + iteratedFDerivWithin 𝕜 i g univ x
tactic: simp_rw [← contDiffOn_univ, ← iteratedFDerivWithin_univ] at hf hg ⊢
state_before: 𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f✝ f₁ : E → F
g✝ : F → G
x x₀ : E
c : F
b : E × F → G
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
i✝ i : ℕ
f g : E → F
hf : ContDiffOn 𝕜 (↑i) f univ
hg : ContDiffOn 𝕜 (↑i) g univ
⊢ iteratedFDerivWithin 𝕜 i (f + g) univ x = iteratedFDerivWithin 𝕜 i f univ x + iteratedFDerivWithin 𝕜 i g univ x
state_after: no goals
tactic: exact iteratedFDerivWithin_add_apply hf hg uniqueDiffOn_univ (Set.mem_univ _)
Theorem: equicontinuousOn_finite
File: Mathlib/Topology/UniformSpace/Equicontinuity.lean

Proof steps:
state_before: ι : Type u_1
κ : Type u_2
X : Type u_3
X' : Type u_4
Y : Type u_5
Z : Type u_6
α : Type u_7
α' : Type u_8
β : Type u_9
β' : Type u_10
γ : Type u_11
𝓕 : Type u_12
tX : TopologicalSpace X
tY : TopologicalSpace Y
tZ : TopologicalSpace Z
uα : UniformSpace α
uβ : UniformSpace β
uγ : UniformSpace γ
inst✝ : Finite ι
F : ι → X → α
S : Set X
⊢ EquicontinuousOn F S ↔ ∀ (i : ι), ContinuousOn (F i) S
state_after: no goals
tactic: simp only [EquicontinuousOn, equicontinuousWithinAt_finite, ContinuousOn, @forall_swap ι]
Theorem: Int.lt_zpow_succ_log_self
File: Mathlib/Data/Int/Log.lean

Proof steps:
state_before: R : Type u_1
inst✝¹ : LinearOrderedSemifield R
inst✝ : FloorSemiring R
b : ℕ
hb : 1 < b
r : R
⊢ r < ↑b ^ (log b r + 1)
state_after: case inl
R : Type u_1
inst✝¹ : LinearOrderedSemifield R
inst✝ : FloorSemiring R
b : ℕ
hb : 1 < b
r : R
hr : r ≤ 0
⊢ r < ↑b ^ (log b r + 1)

case inr
R : Type u_1
inst✝¹ : LinearOrderedSemifield R
inst✝ : FloorSemiring R
b : ℕ
hb : 1 < b
r : R
hr : 0 < r
⊢ r < ↑b ^ (log b r + 1)
tactic: rcases le_or_lt r 0 with hr | hr
state_before: case inr
R : Type u_1
inst✝¹ : LinearOrderedSemifield R
inst✝ : FloorSemiring R
b : ℕ
hb : 1 < b
r : R
hr : 0 < r
⊢ r < ↑b ^ (log b r + 1)
state_after: case inr.inl
R : Type u_1
inst✝¹ : LinearOrderedSemifield R
inst✝ : FloorSemiring R
b : ℕ
hb : 1 < b
r : R
hr : 0 < r
hr1 : 1 ≤ r
⊢ r < ↑b ^ (log b r + 1)

case inr.inr
R : Type u_1
inst✝¹ : LinearOrderedSemifield R
inst✝ : FloorSemiring R
b : ℕ
hb : 1 < b
r : R
hr : 0 < r
hr1 : r < 1
⊢ r < ↑b ^ (log b r + 1)
tactic: rcases le_or_lt 1 r with hr1 | hr1
Theorem: MvPolynomial.mem_restrictTotalDegree
File: Mathlib/RingTheory/MvPolynomial/Basic.lean

Proof steps:
state_before: σ : Type u
R : Type v
inst✝ : CommSemiring R
p✝ m : ℕ
p : MvPolynomial σ R
⊢ p ∈ restrictTotalDegree σ R m ↔ p.totalDegree ≤ m
state_after: σ : Type u
R : Type v
inst✝ : CommSemiring R
p✝ m : ℕ
p : MvPolynomial σ R
⊢ p ∈ restrictTotalDegree σ R m ↔ ∀ b ∈ p.support, (b.sum fun x e => e) ≤ m
tactic: rw [totalDegree, Finset.sup_le_iff]
state_before: σ : Type u
R : Type v
inst✝ : CommSemiring R
p✝ m : ℕ
p : MvPolynomial σ R
⊢ p ∈ restrictTotalDegree σ R m ↔ ∀ b ∈ p.support, (b.sum fun x e => e) ≤ m
state_after: no goals
tactic: rfl
Theorem: MulChar.IsQuadratic.gaussSum_frob
File: Mathlib/NumberTheory/GaussSum.lean

Proof steps:
state_before: R : Type u
inst✝² : CommRing R
inst✝¹ : Fintype R
R' : Type v
inst✝ : CommRing R'
p : ℕ
fp : Fact (Nat.Prime p)
hch : CharP R' p
hp : IsUnit ↑p
χ : MulChar R R'
hχ : χ.IsQuadratic
ψ : AddChar R R'
⊢ gaussSum χ ψ ^ p = χ ↑p * gaussSum χ ψ
state_after: no goals
tactic: rw [_root_.gaussSum_frob, pow_mulShift, hχ.pow_char p, ← gaussSum_mulShift χ ψ hp.unit,
    ← mul_assoc, hp.unit_spec, ← pow_two, ← pow_apply' _ two_ne_zero, hχ.sq_eq_one, ← hp.unit_spec,
    one_apply_coe, one_mul]
Theorem: Associates.FactorSet.prod_eq_zero_iff
File: Mathlib/RingTheory/UniqueFactorizationDomain.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : Nontrivial α
p : FactorSet α
⊢ p.prod = 0 ↔ p = ⊤
state_after: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : Nontrivial α
p : WithTop (Multiset { a // Irreducible a })
⊢ prod p = 0 ↔ p = ⊤
tactic: unfold FactorSet at p
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : Nontrivial α
p : WithTop (Multiset { a // Irreducible a })
⊢ prod p = 0 ↔ p = ⊤
state_after: case top
α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : Nontrivial α
⊢ prod ⊤ = 0 ↔ ⊤ = ⊤

case coe
α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : Nontrivial α
a✝ : Multiset { a // Irreducible a }
⊢ prod ↑a✝ = 0 ↔ ↑a✝ = ⊤
tactic: induction p
Theorem: IsUnit.div_eq_iff
File: Mathlib/Algebra/Group/Units.lean

Proof steps:
state_before: α : Type u
M : Type u_1
N : Type u_2
inst✝ : DivisionMonoid α
a b c : α
h : IsUnit b
⊢ a / b = c ↔ a = c * b
state_after: no goals
tactic: rw [div_eq_mul_inv, h.mul_inv_eq_iff_eq_mul]
Theorem: Rat.zero_of_num_zero
File: Mathlib/Data/Rat/Defs.lean

Proof steps:
state_before: q✝ a b c q : ℚ
hq : q.num = 0
⊢ q = 0
state_after: no goals
tactic: simpa [hq] using q.num_divInt_den.symm
Theorem: Set.enumerate_eq_none_of_sel
File: Mathlib/Data/Set/Enumerate.lean

Proof steps:
state_before: α : Type u_1
sel : Set α → Option α
s : Set α
h : sel s = none
⊢ enumerate sel s 0 = none
state_after: no goals
tactic: simp [h, enumerate]
state_before: α : Type u_1
sel : Set α → Option α
s : Set α
h : sel s = none
n : ℕ
⊢ enumerate sel s (n + 1) = none
state_after: no goals
tactic: simp [h, enumerate]
Theorem: Equiv.Perm.isCycle_of_prime_order''
File: Mathlib/GroupTheory/Perm/Cycle/Type.lean

Proof steps:
state_before: α : Type u_1
inst✝ : Fintype α
σ : Perm α
h1 : Nat.Prime (Fintype.card α)
h2 : orderOf σ = Fintype.card α
⊢ Fintype.card α < 2 * orderOf σ
state_after: α : Type u_1
inst✝ : Fintype α
σ : Perm α
h1 : Nat.Prime (Fintype.card α)
h2 : orderOf σ = Fintype.card α
⊢ 1 < 2
tactic: rw [← one_mul (Fintype.card α), ← h2, mul_lt_mul_right (orderOf_pos σ)]
state_before: α : Type u_1
inst✝ : Fintype α
σ : Perm α
h1 : Nat.Prime (Fintype.card α)
h2 : orderOf σ = Fintype.card α
⊢ 1 < 2
state_after: no goals
tactic: exact one_lt_two
Theorem: CategoryTheory.ConcreteCategory.surjective_eq_epimorphisms
File: Mathlib/CategoryTheory/ConcreteCategory/EpiMono.lean

Proof steps:
state_before: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : ConcreteCategory C
inst✝ : (forget C).PreservesEpimorphisms
⊢ MorphismProperty.surjective C = epimorphisms C
state_after: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : ConcreteCategory C
inst✝ : (forget C).PreservesEpimorphisms
⊢ (forget C).PreservesEpimorphisms
tactic: rw [surjective_eq_epimorphisms_iff]
state_before: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : ConcreteCategory C
inst✝ : (forget C).PreservesEpimorphisms
⊢ (forget C).PreservesEpimorphisms
state_after: no goals
tactic: infer_instance
Theorem: ContinuousMap.equivFnOfDiscrete_apply
File: Mathlib/Topology/ContinuousFunction/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁴ : TopologicalSpace α
inst✝³ : TopologicalSpace β
inst✝² : TopologicalSpace γ
inst✝¹ : TopologicalSpace δ
f g : C(α, β)
inst✝ : DiscreteTopology α
x✝ : C(α, β)
⊢ (fun f => { toFun := f, continuous_toFun := ⋯ }) ((fun f => ⇑f) x✝) = x✝
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁴ : TopologicalSpace α
inst✝³ : TopologicalSpace β
inst✝² : TopologicalSpace γ
inst✝¹ : TopologicalSpace δ
f g : C(α, β)
inst✝ : DiscreteTopology α
x✝ : C(α, β)
a✝ : α
⊢ ((fun f => { toFun := f, continuous_toFun := ⋯ }) ((fun f => ⇑f) x✝)) a✝ = x✝ a✝
tactic: ext
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁴ : TopologicalSpace α
inst✝³ : TopologicalSpace β
inst✝² : TopologicalSpace γ
inst✝¹ : TopologicalSpace δ
f g : C(α, β)
inst✝ : DiscreteTopology α
x✝ : C(α, β)
a✝ : α
⊢ ((fun f => { toFun := f, continuous_toFun := ⋯ }) ((fun f => ⇑f) x✝)) a✝ = x✝ a✝
state_after: no goals
tactic: rfl
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁴ : TopologicalSpace α
inst✝³ : TopologicalSpace β
inst✝² : TopologicalSpace γ
inst✝¹ : TopologicalSpace δ
f g : C(α, β)
inst✝ : DiscreteTopology α
x✝ : α → β
⊢ (fun f => ⇑f) ((fun f => { toFun := f, continuous_toFun := ⋯ }) x✝) = x✝
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁴ : TopologicalSpace α
inst✝³ : TopologicalSpace β
inst✝² : TopologicalSpace γ
inst✝¹ : TopologicalSpace δ
f g : C(α, β)
inst✝ : DiscreteTopology α
x✝¹ : α → β
x✝ : α
⊢ (fun f => ⇑f) ((fun f => { toFun := f, continuous_toFun := ⋯ }) x✝¹) x✝ = x✝¹ x✝
tactic: ext
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁴ : TopologicalSpace α
inst✝³ : TopologicalSpace β
inst✝² : TopologicalSpace γ
inst✝¹ : TopologicalSpace δ
f g : C(α, β)
inst✝ : DiscreteTopology α
x✝¹ : α → β
x✝ : α
⊢ (fun f => ⇑f) ((fun f => { toFun := f, continuous_toFun := ⋯ }) x✝¹) x✝ = x✝¹ x✝
state_after: no goals
tactic: rfl
Theorem: Real.toNNReal_le_toNNReal_iff'
File: Mathlib/Data/NNReal/Basic.lean

Proof steps:
state_before: r p : ℝ
⊢ r.toNNReal ≤ p.toNNReal ↔ r ≤ p ∨ r ≤ 0
state_after: no goals
tactic: simp_rw [← not_lt, toNNReal_lt_toNNReal_iff', not_and_or]
Theorem: NNRat.divNat_mul_divNat
File: Mathlib/Data/NNRat/Defs.lean

Proof steps:
state_before: p q : ℚ≥0
n₁✝ n₂✝ d₁✝ d₂✝ d n₁ n₂ d₁ d₂ : ℕ
hd₁ : d₁ ≠ 0
hd₂ : d₂ ≠ 0
⊢ divNat n₁ d₁ * divNat n₂ d₂ = divNat (n₁ * n₂) (d₁ * d₂)
state_after: case a
p q : ℚ≥0
n₁✝ n₂✝ d₁✝ d₂✝ d n₁ n₂ d₁ d₂ : ℕ
hd₁ : d₁ ≠ 0
hd₂ : d₂ ≠ 0
⊢ ↑(divNat n₁ d₁ * divNat n₂ d₂) = ↑(divNat (n₁ * n₂) (d₁ * d₂))
tactic: ext
state_before: case a
p q : ℚ≥0
n₁✝ n₂✝ d₁✝ d₂✝ d n₁ n₂ d₁ d₂ : ℕ
hd₁ : d₁ ≠ 0
hd₂ : d₂ ≠ 0
⊢ ↑(divNat n₁ d₁ * divNat n₂ d₂) = ↑(divNat (n₁ * n₂) (d₁ * d₂))
state_after: case a
p q : ℚ≥0
n₁✝ n₂✝ d₁✝ d₂✝ d n₁ n₂ d₁ d₂ : ℕ
hd₁ : d₁ ≠ 0
hd₂ : d₂ ≠ 0
⊢ Rat.divInt ↑n₁ ↑d₁ * Rat.divInt ↑n₂ ↑d₂ = Rat.divInt (↑n₁ * ↑n₂) (↑d₁ * ↑d₂)
tactic: push_cast
state_before: case a
p q : ℚ≥0
n₁✝ n₂✝ d₁✝ d₂✝ d n₁ n₂ d₁ d₂ : ℕ
hd₁ : d₁ ≠ 0
hd₂ : d₂ ≠ 0
⊢ Rat.divInt ↑n₁ ↑d₁ * Rat.divInt ↑n₂ ↑d₂ = Rat.divInt (↑n₁ * ↑n₂) (↑d₁ * ↑d₂)
state_after: no goals
tactic: exact Rat.divInt_mul_divInt _ _ (mod_cast hd₁) (mod_cast hd₂)
Theorem: Matrix.nonsing_inv_nonsing_inv
File: Mathlib/LinearAlgebra/Matrix/NonsingularInverse.lean

Proof steps:
state_before: l : Type u_1
m : Type u
n : Type u'
α : Type v
inst✝² : Fintype n
inst✝¹ : DecidableEq n
inst✝ : CommRing α
A B : Matrix n n α
h : IsUnit A.det
⊢ A⁻¹⁻¹ = 1 * A⁻¹⁻¹
state_after: no goals
tactic: rw [Matrix.one_mul]
state_before: l : Type u_1
m : Type u
n : Type u'
α : Type v
inst✝² : Fintype n
inst✝¹ : DecidableEq n
inst✝ : CommRing α
A B : Matrix n n α
h : IsUnit A.det
⊢ 1 * A⁻¹⁻¹ = A * A⁻¹ * A⁻¹⁻¹
state_after: no goals
tactic: rw [A.mul_nonsing_inv h]
state_before: l : Type u_1
m : Type u
n : Type u'
α : Type v
inst✝² : Fintype n
inst✝¹ : DecidableEq n
inst✝ : CommRing α
A B : Matrix n n α
h : IsUnit A.det
⊢ A * A⁻¹ * A⁻¹⁻¹ = A
state_after: no goals
tactic: rw [Matrix.mul_assoc, A⁻¹.mul_nonsing_inv (A.isUnit_nonsing_inv_det h), Matrix.mul_one]
Theorem: ZMod.charpoly_pow_card
File: Mathlib/LinearAlgebra/Matrix/Charpoly/FiniteField.lean

Proof steps:
state_before: n : Type u_1
inst✝² : DecidableEq n
inst✝¹ : Fintype n
p : ℕ
inst✝ : Fact (Nat.Prime p)
M : Matrix n n (ZMod p)
⊢ (M ^ p).charpoly = M.charpoly
state_after: n : Type u_1
inst✝² : DecidableEq n
inst✝¹ : Fintype n
p : ℕ
inst✝ : Fact (Nat.Prime p)
M : Matrix n n (ZMod p)
h : (M ^ Fintype.card (ZMod p)).charpoly = M.charpoly
⊢ (M ^ p).charpoly = M.charpoly
tactic: have h := FiniteField.Matrix.charpoly_pow_card M
state_before: n : Type u_1
inst✝² : DecidableEq n
inst✝¹ : Fintype n
p : ℕ
inst✝ : Fact (Nat.Prime p)
M : Matrix n n (ZMod p)
h : (M ^ Fintype.card (ZMod p)).charpoly = M.charpoly
⊢ (M ^ p).charpoly = M.charpoly
state_after: no goals
tactic: rwa [ZMod.card] at h
Theorem: BoxIntegral.Box.disjoint_splitLower_splitUpper
File: Mathlib/Analysis/BoxIntegral/Partition/Split.lean

Proof steps:
state_before: ι : Type u_1
M : Type u_2
n : ℕ
I✝ : Box ι
i✝ : ι
x✝ : ℝ
y : ι → ℝ
I : Box ι
i : ι
x : ℝ
⊢ Disjoint (I.splitLower i x) (I.splitUpper i x)
state_after: ι : Type u_1
M : Type u_2
n : ℕ
I✝ : Box ι
i✝ : ι
x✝ : ℝ
y : ι → ℝ
I : Box ι
i : ι
x : ℝ
⊢ Disjoint (↑I ∩ {y | y i ≤ x}) (↑I ∩ {y | x < y i})
tactic: rw [← disjoint_withBotCoe, coe_splitLower, coe_splitUpper]
state_before: ι : Type u_1
M : Type u_2
n : ℕ
I✝ : Box ι
i✝ : ι
x✝ : ℝ
y : ι → ℝ
I : Box ι
i : ι
x : ℝ
⊢ Disjoint (↑I ∩ {y | y i ≤ x}) (↑I ∩ {y | x < y i})
state_after: ι : Type u_1
M : Type u_2
n : ℕ
I✝ : Box ι
i✝ : ι
x✝ : ℝ
y : ι → ℝ
I : Box ι
i : ι
x : ℝ
⊢ Disjoint {y | y i ≤ x} {y | x < y i}
tactic: refine (Disjoint.inf_left' _ ?_).inf_right' _
state_before: ι : Type u_1
M : Type u_2
n : ℕ
I✝ : Box ι
i✝ : ι
x✝ : ℝ
y : ι → ℝ
I : Box ι
i : ι
x : ℝ
⊢ Disjoint {y | y i ≤ x} {y | x < y i}
state_after: ι : Type u_1
M : Type u_2
n : ℕ
I✝ : Box ι
i✝ : ι
x✝ : ℝ
y : ι → ℝ
I : Box ι
i : ι
x : ℝ
⊢ ∀ ⦃a : ι → ℝ⦄, a ∈ {y | y i ≤ x} → a ∉ {y | x < y i}
tactic: rw [Set.disjoint_left]
state_before: ι : Type u_1
M : Type u_2
n : ℕ
I✝ : Box ι
i✝ : ι
x✝ : ℝ
y : ι → ℝ
I : Box ι
i : ι
x : ℝ
⊢ ∀ ⦃a : ι → ℝ⦄, a ∈ {y | y i ≤ x} → a ∉ {y | x < y i}
state_after: no goals
tactic: exact fun y (hle : y i ≤ x) hlt => not_lt_of_le hle hlt
Theorem: circleIntegral.norm_integral_lt_of_norm_le_const_of_lt
File: Mathlib/MeasureTheory/Integral/CircleIntegral.lean

Proof steps:
state_before: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ → E
c : ℂ
R C : ℝ
hR : 0 < R
hc : ContinuousOn f (sphere c R)
hf : ∀ z ∈ sphere c R, ‖f z‖ ≤ C
hlt : ∃ z ∈ sphere c R, ‖f z‖ < C
⊢ ‖∮ (z : ℂ) in C(c, R), f z‖ < 2 * π * R * C
state_after: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ → E
c : ℂ
R C : ℝ
hR : 0 < R
hc : ContinuousOn f (sphere c R)
hf : ∀ z ∈ sphere c R, ‖f z‖ ≤ C
hlt : ∃ z ∈ circleMap c R '' Ioc 0 (2 * π), ‖f z‖ < C
⊢ ‖∮ (z : ℂ) in C(c, R), f z‖ < 2 * π * R * C
tactic: rw [← _root_.abs_of_pos hR, ← image_circleMap_Ioc] at hlt
state_before: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ → E
c : ℂ
R C : ℝ
hR : 0 < R
hc : ContinuousOn f (sphere c R)
hf : ∀ z ∈ sphere c R, ‖f z‖ ≤ C
hlt : ∃ z ∈ circleMap c R '' Ioc 0 (2 * π), ‖f z‖ < C
⊢ ‖∮ (z : ℂ) in C(c, R), f z‖ < 2 * π * R * C
state_after: case intro.intro.intro.intro
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ → E
c : ℂ
R C : ℝ
hR : 0 < R
hc : ContinuousOn f (sphere c R)
hf : ∀ z ∈ sphere c R, ‖f z‖ ≤ C
θ₀ : ℝ
hmem : θ₀ ∈ Ioc 0 (2 * π)
hlt : ‖f (circleMap c R θ₀)‖ < C
⊢ ‖∮ (z : ℂ) in C(c, R), f z‖ < 2 * π * R * C
tactic: rcases hlt with ⟨_, ⟨θ₀, hmem, rfl⟩, hlt⟩
Theorem: AlgebraicTopology.DoldKan.P_add_Q
File: Mathlib/AlgebraicTopology/DoldKan/Projections.lean

Proof steps:
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Preadditive C
X : SimplicialObject C
q : ℕ
⊢ P q + Q q = 𝟙 K[X]
state_after: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Preadditive C
X : SimplicialObject C
q : ℕ
⊢ P q + (𝟙 K[X] - P q) = 𝟙 K[X]
tactic: rw [Q]
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Preadditive C
X : SimplicialObject C
q : ℕ
⊢ P q + (𝟙 K[X] - P q) = 𝟙 K[X]
state_after: no goals
tactic: abel
Theorem: Set.preimage_eq_empty
File: Mathlib/Data/Set/Image.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
f : α → β
s✝ t : Set α
s : Set β
h : Disjoint s (range f)
⊢ f ⁻¹' s = ∅
state_after: no goals
tactic: simpa using h.preimage f
Theorem: List.modifyNthTR_go_eq
File: .lake/packages/batteries/Batteries/Data/List/Basic.lean

Proof steps:
state_before: α✝ : Type u_1
f : α✝ → α✝
acc : Array α✝
n : Nat
⊢ modifyNthTR.go f [] n acc = acc.data ++ modifyNth f n []
state_after: no goals
tactic: cases n <;> simp [modifyNthTR.go, modifyNth]
state_before: α✝ : Type u_1
f : α✝ → α✝
acc : Array α✝
a : α✝
l : List α✝
⊢ modifyNthTR.go f (a :: l) 0 acc = acc.data ++ modifyNth f 0 (a :: l)
state_after: no goals
tactic: simp [modifyNthTR.go, modifyNth]
state_before: α✝ : Type u_1
f : α✝ → α✝
acc : Array α✝
a : α✝
l : List α✝
n : Nat
⊢ modifyNthTR.go f (a :: l) (n + 1) acc = acc.data ++ modifyNth f (n + 1) (a :: l)
state_after: no goals
tactic: simp [modifyNthTR.go, modifyNth, modifyNthTR_go_eq l]
Theorem: Units.neg_divp
File: Mathlib/Algebra/Ring/Units.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
R : Type x
inst✝¹ : Monoid α
inst✝ : HasDistribNeg α
a✝ b a : α
u : αˣ
⊢ -(a /ₚ u) = -a /ₚ u
state_after: no goals
tactic: simp only [divp, neg_mul]
Theorem: CategoryTheory.Limits.hasZeroObject_of_hasInitial_object
File: Mathlib/CategoryTheory/Limits/Shapes/ZeroMorphisms.lean

Proof steps:
state_before: C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasZeroMorphisms C
inst✝ : HasInitial C
⊢ HasZeroObject C
state_after: C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasZeroMorphisms C
inst✝ : HasInitial C
X : C
f : X ⟶ ⊥_ C
⊢ f = default
tactic: refine ⟨⟨⊥_ C, fun X => ⟨⟨⟨0⟩, by aesop_cat⟩⟩, fun X => ⟨⟨⟨0⟩, fun f => ?_⟩⟩⟩⟩
state_before: C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasZeroMorphisms C
inst✝ : HasInitial C
X : C
f : X ⟶ ⊥_ C
⊢ f = default
state_after: no goals
tactic: calc
    f = f ≫ 𝟙 _ := (Category.comp_id _).symm
    _ = f ≫ 0 := by congr!; subsingleton
    _ = 0 := HasZeroMorphisms.comp_zero _ _
Theorem: toIcoMod_inj
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 : ℤ
c : α
⊢ toIcoMod hp c a = toIcoMod hp c b ↔ a ≡ b [PMOD p]
state_after: no goals
tactic: simp_rw [toIcoMod_eq_toIcoMod, modEq_iff_eq_add_zsmul, sub_eq_iff_eq_add']