ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: AffineMap.span_eq_top_of_surjective
File: Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean

Proof steps:
state_before: k : Type u_1
V₁ : Type u_2
P₁ : Type u_3
V₂ : Type u_4
P₂ : Type u_5
V₃ : Type u_6
P₃ : Type u_7
inst✝⁹ : Ring k
inst✝⁸ : AddCommGroup V₁
inst✝⁷ : Module k V₁
inst✝⁶ : AffineSpace V₁ P₁
inst✝⁵ : AddCommGroup V₂
inst✝⁴ : Module k V₂
inst✝³ : AffineSpace V₂ P₂
inst✝² : AddCommGroup V₃
inst✝¹ : Module k V₃
inst✝ : AffineSpace V₃ P₃
f : P₁ →ᵃ[k] P₂
s : Set P₁
hf : Function.Surjective ⇑f
h : affineSpan k s = ⊤
⊢ affineSpan k (⇑f '' s) = ⊤
state_after: no goals
tactic: rw [← AffineSubspace.map_span, h, map_top_of_surjective f hf]
Theorem: Cardinal.iInf_eq_zero_iff
File: Mathlib/SetTheory/Cardinal/Basic.lean

Proof steps:
state_before: α β : Type u
ι : Sort u_1
f : ι → Cardinal.{u_2}
⊢ ⨅ i, f i = 0 ↔ IsEmpty ι ∨ ∃ i, f i = 0
state_after: no goals
tactic: simp [iInf, sInf_eq_zero_iff]
Theorem: Finset.card_Ioc_finset
File: Mathlib/Data/Finset/Interval.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
s t : Finset α
h : s ⊆ t
⊢ (Ioc s t).card = 2 ^ (t.card - s.card) - 1
state_after: no goals
tactic: rw [card_Ioc_eq_card_Icc_sub_one, card_Icc_finset h]
Theorem: RatFunc.ofFractionRing_sub
File: Mathlib/FieldTheory/RatFunc/Basic.lean

Proof steps:
state_before: K : Type u
inst✝ : CommRing K
p q : FractionRing K[X]
⊢ { toFractionRing := p - q } = { toFractionRing := p } - { toFractionRing := q }
state_after: no goals
tactic: simp only [Sub.sub, HSub.hSub, RatFunc.sub]
Theorem: Real.logb_lt_iff_lt_rpow
File: Mathlib/Analysis/SpecialFunctions/Log/Base.lean

Proof steps:
state_before: b x y : ℝ
hb : 1 < b
hx : 0 < x
⊢ logb b x < y ↔ x < b ^ y
state_after: no goals
tactic: rw [← rpow_lt_rpow_left_iff hb, rpow_logb (b_pos hb) (b_ne_one' hb) hx]
Theorem: Nat.findGreatest_mono_left
File: Mathlib/Data/Nat/Find.lean

Proof steps:
state_before: a b c d m n✝¹ k : ℕ
p q P Q : ℕ → Prop
inst✝¹ : DecidablePred P
n✝ : ℕ
inst✝ : DecidablePred Q
hPQ : ∀ (n : ℕ), P n → Q n
n : ℕ
⊢ findGreatest P n ≤ findGreatest Q n
state_after: case zero
a b c d m n✝ k : ℕ
p q P Q : ℕ → Prop
inst✝¹ : DecidablePred P
n : ℕ
inst✝ : DecidablePred Q
hPQ : ∀ (n : ℕ), P n → Q n
⊢ findGreatest P 0 ≤ findGreatest Q 0

case succ
a b c d m n✝¹ k : ℕ
p q P Q : ℕ → Prop
inst✝¹ : DecidablePred P
n✝ : ℕ
inst✝ : DecidablePred Q
hPQ : ∀ (n : ℕ), P n → Q n
n : ℕ
hn : findGreatest P n ≤ findGreatest Q n
⊢ findGreatest P (n + 1) ≤ findGreatest Q (n + 1)
tactic: induction' n with n hn
state_before: case succ
a b c d m n✝¹ k : ℕ
p q P Q : ℕ → Prop
inst✝¹ : DecidablePred P
n✝ : ℕ
inst✝ : DecidablePred Q
hPQ : ∀ (n : ℕ), P n → Q n
n : ℕ
hn : findGreatest P n ≤ findGreatest Q n
⊢ findGreatest P (n + 1) ≤ findGreatest Q (n + 1)
state_after: case pos
a b c d m n✝¹ k : ℕ
p q P Q : ℕ → Prop
inst✝¹ : DecidablePred P
n✝ : ℕ
inst✝ : DecidablePred Q
hPQ : ∀ (n : ℕ), P n → Q n
n : ℕ
hn : findGreatest P n ≤ findGreatest Q n
h : P (n + 1)
⊢ findGreatest P (n + 1) ≤ findGreatest Q (n + 1)

case neg
a b c d m n✝¹ k : ℕ
p q P Q : ℕ → Prop
inst✝¹ : DecidablePred P
n✝ : ℕ
inst✝ : DecidablePred Q
hPQ : ∀ (n : ℕ), P n → Q n
n : ℕ
hn : findGreatest P n ≤ findGreatest Q n
h : ¬P (n + 1)
⊢ findGreatest P (n + 1) ≤ findGreatest Q (n + 1)
tactic: by_cases h : P (n + 1)
Theorem: Polynomial.rootMultiplicity_add
File: Mathlib/Algebra/Polynomial/RingDivision.lean

Proof steps:
state_before: R : Type u
S : Type v
T : Type w
a✝ b : R
n : ℕ
inst✝ : CommRing R
p q : R[X]
a : R
hzero : p + q ≠ 0
⊢ min (rootMultiplicity a p) (rootMultiplicity a q) ≤ rootMultiplicity a (p + q)
state_after: R : Type u
S : Type v
T : Type w
a✝ b : R
n : ℕ
inst✝ : CommRing R
p q : R[X]
a : R
hzero : p + q ≠ 0
⊢ (X - C a) ^ min (rootMultiplicity a p) (rootMultiplicity a q) ∣ p + q
tactic: rw [le_rootMultiplicity_iff hzero]
state_before: R : Type u
S : Type v
T : Type w
a✝ b : R
n : ℕ
inst✝ : CommRing R
p q : R[X]
a : R
hzero : p + q ≠ 0
⊢ (X - C a) ^ min (rootMultiplicity a p) (rootMultiplicity a q) ∣ p + q
state_after: no goals
tactic: exact min_pow_dvd_add (pow_rootMultiplicity_dvd p a) (pow_rootMultiplicity_dvd q a)
Theorem: MeasureTheory.Filtration.filtrationOfSet_eq_natural
File: Mathlib/Probability/Process/Filtration.lean

Proof steps:
state_before: Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝⁵ : TopologicalSpace β
inst✝⁴ : MetrizableSpace β
mβ : MeasurableSpace β
inst✝³ : BorelSpace β
inst✝² : Preorder ι
inst✝¹ : MulZeroOneClass β
inst✝ : Nontrivial β
s : ι → Set Ω
hsm : ∀ (i : ι), MeasurableSet (s i)
⊢ filtrationOfSet hsm = natural (fun i => (s i).indicator fun x => 1) ⋯
state_after: Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝⁵ : TopologicalSpace β
inst✝⁴ : MetrizableSpace β
mβ : MeasurableSpace β
inst✝³ : BorelSpace β
inst✝² : Preorder ι
inst✝¹ : MulZeroOneClass β
inst✝ : Nontrivial β
s : ι → Set Ω
hsm : ∀ (i : ι), MeasurableSet (s i)
⊢ (fun i => MeasurableSpace.generateFrom {t | ∃ j ≤ i, s j = t}) = fun i =>
    MeasurableSpace.generateFrom {s_1 | ∃ n, MeasurableSet s_1}
tactic: simp only [filtrationOfSet, natural, measurableSpace_iSup_eq, exists_prop, mk.injEq]
state_before: Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝⁵ : TopologicalSpace β
inst✝⁴ : MetrizableSpace β
mβ : MeasurableSpace β
inst✝³ : BorelSpace β
inst✝² : Preorder ι
inst✝¹ : MulZeroOneClass β
inst✝ : Nontrivial β
s : ι → Set Ω
hsm : ∀ (i : ι), MeasurableSet (s i)
⊢ (fun i => MeasurableSpace.generateFrom {t | ∃ j ≤ i, s j = t}) = fun i =>
    MeasurableSpace.generateFrom {s_1 | ∃ n, MeasurableSet s_1}
state_after: case h
Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝⁵ : TopologicalSpace β
inst✝⁴ : MetrizableSpace β
mβ : MeasurableSpace β
inst✝³ : BorelSpace β
inst✝² : Preorder ι
inst✝¹ : MulZeroOneClass β
inst✝ : Nontrivial β
s : ι → Set Ω
hsm : ∀ (i : ι), MeasurableSet (s i)
i : ι
⊢ MeasurableSpace.generateFrom {t | ∃ j ≤ i, s j = t} = MeasurableSpace.generateFrom {s_1 | ∃ n, MeasurableSet s_1}
tactic: ext1 i
state_before: case h
Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝⁵ : TopologicalSpace β
inst✝⁴ : MetrizableSpace β
mβ : MeasurableSpace β
inst✝³ : BorelSpace β
inst✝² : Preorder ι
inst✝¹ : MulZeroOneClass β
inst✝ : Nontrivial β
s : ι → Set Ω
hsm : ∀ (i : ι), MeasurableSet (s i)
i : ι
⊢ MeasurableSpace.generateFrom {t | ∃ j ≤ i, s j = t} = MeasurableSpace.generateFrom {s_1 | ∃ n, MeasurableSet s_1}
state_after: case h.refine_1
Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝⁵ : TopologicalSpace β
inst✝⁴ : MetrizableSpace β
mβ : MeasurableSpace β
inst✝³ : BorelSpace β
inst✝² : Preorder ι
inst✝¹ : MulZeroOneClass β
inst✝ : Nontrivial β
s : ι → Set Ω
hsm : ∀ (i : ι), MeasurableSet (s i)
i : ι
⊢ ∀ t ∈ {t | ∃ j ≤ i, s j = t}, MeasurableSet t

case h.refine_2
Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝⁵ : TopologicalSpace β
inst✝⁴ : MetrizableSpace β
mβ : MeasurableSpace β
inst✝³ : BorelSpace β
inst✝² : Preorder ι
inst✝¹ : MulZeroOneClass β
inst✝ : Nontrivial β
s : ι → Set Ω
hsm : ∀ (i : ι), MeasurableSet (s i)
i : ι
⊢ ∀ t ∈ {s_1 | ∃ n, MeasurableSet s_1}, MeasurableSet t
tactic: refine le_antisymm (generateFrom_le ?_) (generateFrom_le ?_)
Theorem: HasCompactSupport.continuous_convolution_left
File: Mathlib/Analysis/Convolution.lean

Proof steps:
state_before: 𝕜 : Type u𝕜
G : Type uG
E : Type uE
E' : Type uE'
E'' : Type uE''
F : Type uF
F' : Type uF'
F'' : Type uF''
P : Type uP
inst✝¹⁶ : NormedAddCommGroup E
inst✝¹⁵ : NormedAddCommGroup E'
inst✝¹⁴ : NormedAddCommGroup E''
inst✝¹³ : NormedAddCommGroup F
f f' : G → E
g g' : G → E'
x x' : G
y y' : E
inst✝¹² : NontriviallyNormedField 𝕜
inst✝¹¹ : NormedSpace 𝕜 E
inst✝¹⁰ : NormedSpace 𝕜 E'
inst✝⁹ : NormedSpace 𝕜 E''
inst✝⁸ : NormedSpace 𝕜 F
L : E →L[𝕜] E' →L[𝕜] F
inst✝⁷ : MeasurableSpace G
μ ν : Measure G
inst✝⁶ : NormedSpace ℝ F
inst✝⁵ : AddCommGroup G
inst✝⁴ : μ.IsAddLeftInvariant
inst✝³ : μ.IsNegInvariant
inst✝² : TopologicalSpace G
inst✝¹ : TopologicalAddGroup G
inst✝ : BorelSpace G
hcf : HasCompactSupport f
hf : Continuous f
hg : LocallyIntegrable g μ
⊢ Continuous (f ⋆[L, μ] g)
state_after: 𝕜 : Type u𝕜
G : Type uG
E : Type uE
E' : Type uE'
E'' : Type uE''
F : Type uF
F' : Type uF'
F'' : Type uF''
P : Type uP
inst✝¹⁶ : NormedAddCommGroup E
inst✝¹⁵ : NormedAddCommGroup E'
inst✝¹⁴ : NormedAddCommGroup E''
inst✝¹³ : NormedAddCommGroup F
f f' : G → E
g g' : G → E'
x x' : G
y y' : E
inst✝¹² : NontriviallyNormedField 𝕜
inst✝¹¹ : NormedSpace 𝕜 E
inst✝¹⁰ : NormedSpace 𝕜 E'
inst✝⁹ : NormedSpace 𝕜 E''
inst✝⁸ : NormedSpace 𝕜 F
L : E →L[𝕜] E' →L[𝕜] F
inst✝⁷ : MeasurableSpace G
μ ν : Measure G
inst✝⁶ : NormedSpace ℝ F
inst✝⁵ : AddCommGroup G
inst✝⁴ : μ.IsAddLeftInvariant
inst✝³ : μ.IsNegInvariant
inst✝² : TopologicalSpace G
inst✝¹ : TopologicalAddGroup G
inst✝ : BorelSpace G
hcf : HasCompactSupport f
hf : Continuous f
hg : LocallyIntegrable g μ
⊢ Continuous (g ⋆[L.flip, μ] f)
tactic: rw [← convolution_flip]
state_before: 𝕜 : Type u𝕜
G : Type uG
E : Type uE
E' : Type uE'
E'' : Type uE''
F : Type uF
F' : Type uF'
F'' : Type uF''
P : Type uP
inst✝¹⁶ : NormedAddCommGroup E
inst✝¹⁵ : NormedAddCommGroup E'
inst✝¹⁴ : NormedAddCommGroup E''
inst✝¹³ : NormedAddCommGroup F
f f' : G → E
g g' : G → E'
x x' : G
y y' : E
inst✝¹² : NontriviallyNormedField 𝕜
inst✝¹¹ : NormedSpace 𝕜 E
inst✝¹⁰ : NormedSpace 𝕜 E'
inst✝⁹ : NormedSpace 𝕜 E''
inst✝⁸ : NormedSpace 𝕜 F
L : E →L[𝕜] E' →L[𝕜] F
inst✝⁷ : MeasurableSpace G
μ ν : Measure G
inst✝⁶ : NormedSpace ℝ F
inst✝⁵ : AddCommGroup G
inst✝⁴ : μ.IsAddLeftInvariant
inst✝³ : μ.IsNegInvariant
inst✝² : TopologicalSpace G
inst✝¹ : TopologicalAddGroup G
inst✝ : BorelSpace G
hcf : HasCompactSupport f
hf : Continuous f
hg : LocallyIntegrable g μ
⊢ Continuous (g ⋆[L.flip, μ] f)
state_after: no goals
tactic: exact hcf.continuous_convolution_right L.flip hg hf
Theorem: CategoryTheory.strongEpi_comp
File: Mathlib/CategoryTheory/Limits/Shapes/StrongEpi.lean

Proof steps:
state_before: C : Type u
inst✝² : Category.{v, u} C
P Q R : C
f : P ⟶ Q
g : Q ⟶ R
inst✝¹ : StrongEpi f
inst✝ : StrongEpi g
⊢ ∀ ⦃X Y : C⦄ (z : X ⟶ Y) [inst : Mono z], HasLiftingProperty (f ≫ g) z
state_after: C : Type u
inst✝³ : Category.{v, u} C
P Q R : C
f : P ⟶ Q
g : Q ⟶ R
inst✝² : StrongEpi f
inst✝¹ : StrongEpi g
X✝ Y✝ : C
z✝ : X✝ ⟶ Y✝
inst✝ : Mono z✝
⊢ HasLiftingProperty (f ≫ g) z✝
tactic: intros
state_before: C : Type u
inst✝³ : Category.{v, u} C
P Q R : C
f : P ⟶ Q
g : Q ⟶ R
inst✝² : StrongEpi f
inst✝¹ : StrongEpi g
X✝ Y✝ : C
z✝ : X✝ ⟶ Y✝
inst✝ : Mono z✝
⊢ HasLiftingProperty (f ≫ g) z✝
state_after: no goals
tactic: infer_instance
Theorem: CategoryTheory.Subobject.le_of_comm
File: Mathlib/CategoryTheory/Subobject/Basic.lean

Proof steps:
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
X✝ Y✝ Z : C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
B : C
X Y : Subobject B
f : underlying.obj X ⟶ underlying.obj Y
w : f ≫ Y.arrow = X.arrow
⊢ X ≤ Y
state_after: no goals
tactic: convert mk_le_mk_of_comm _ w <;> simp
Theorem: IsSMulRegular.one
File: Mathlib/Algebra/Regular/SMul.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
M : Type u_3
a✝ b✝ : R
s : S
inst✝¹ : Monoid R
inst✝ : MulAction R M
a b : M
ab : (fun x => 1 • x) a = (fun x => 1 • x) b
⊢ a = b
state_after: R : Type u_1
S : Type u_2
M : Type u_3
a✝ b✝ : R
s : S
inst✝¹ : Monoid R
inst✝ : MulAction R M
a b : M
ab : 1 • a = 1 • b
⊢ a = b
tactic: dsimp only [Function.comp_def] at ab
state_before: R : Type u_1
S : Type u_2
M : Type u_3
a✝ b✝ : R
s : S
inst✝¹ : Monoid R
inst✝ : MulAction R M
a b : M
ab : 1 • a = 1 • b
⊢ a = b
state_after: R : Type u_1
S : Type u_2
M : Type u_3
a✝ b✝ : R
s : S
inst✝¹ : Monoid R
inst✝ : MulAction R M
a b : M
ab : a = b
⊢ a = b
tactic: rw [one_smul, one_smul] at ab
state_before: R : Type u_1
S : Type u_2
M : Type u_3
a✝ b✝ : R
s : S
inst✝¹ : Monoid R
inst✝ : MulAction R M
a b : M
ab : a = b
⊢ a = b
state_after: no goals
tactic: assumption
Theorem: Submodule.isTorsion'_powers_iff
File: Mathlib/Algebra/Module/Torsion.lean

Proof steps:
state_before: R : Type u_1
M : Type u_2
inst✝² : Monoid R
inst✝¹ : AddCommMonoid M
inst✝ : DistribMulAction R M
p : R
⊢ IsTorsion' M ↥(Submonoid.powers p) ↔ ∀ (x : M), ∃ n, p ^ n • x = 0
state_after: case mp
R : Type u_1
M : Type u_2
inst✝² : Monoid R
inst✝¹ : AddCommMonoid M
inst✝ : DistribMulAction R M
p : R
⊢ IsTorsion' M ↥(Submonoid.powers p) → ∀ (x : M), ∃ n, p ^ n • x = 0

case mpr
R : Type u_1
M : Type u_2
inst✝² : Monoid R
inst✝¹ : AddCommMonoid M
inst✝ : DistribMulAction R M
p : R
⊢ (∀ (x : M), ∃ n, p ^ n • x = 0) → IsTorsion' M ↥(Submonoid.powers p)
tactic: constructor
Theorem: Nat.card_multiples
File: Mathlib/Data/Nat/Factorization/Basic.lean

Proof steps:
state_before: a b m n✝ p✝ n p : ℕ
⊢ (Finset.filter (fun e => p ∣ e + 1) (Finset.range n)).card = n / p
state_after: case zero
a b m n p✝ p : ℕ
⊢ (Finset.filter (fun e => p ∣ e + 1) (Finset.range 0)).card = 0 / p

case succ
a b m n✝ p✝ p n : ℕ
hn : (Finset.filter (fun e => p ∣ e + 1) (Finset.range n)).card = n / p
⊢ (Finset.filter (fun e => p ∣ e + 1) (Finset.range (n + 1))).card = (n + 1) / p
tactic: induction' n with n hn
state_before: case succ
a b m n✝ p✝ p n : ℕ
hn : (Finset.filter (fun e => p ∣ e + 1) (Finset.range n)).card = n / p
⊢ (Finset.filter (fun e => p ∣ e + 1) (Finset.range (n + 1))).card = (n + 1) / p
state_after: no goals
tactic: simp [Nat.succ_div, add_ite, add_zero, Finset.range_succ, filter_insert, apply_ite card,
    card_insert_of_not_mem, hn]
Theorem: FractionalIdeal.spanSingleton_eq_zero_iff
File: Mathlib/RingTheory/FractionalIdeal/Operations.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
R₁ : Type u_3
inst✝³ : CommRing R₁
K : Type u_4
inst✝² : Field K
inst✝¹ : Algebra R₁ K
inst✝ : IsFractionRing R₁ K
y : P
h : spanSingleton S y = 0
⊢ span R {y} = ⊥
state_after: no goals
tactic: simpa using congr_arg Subtype.val h
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
R₁ : Type u_3
inst✝³ : CommRing R₁
K : Type u_4
inst✝² : Field K
inst✝¹ : Algebra R₁ K
inst✝ : IsFractionRing R₁ K
y : P
h : y = 0
⊢ spanSingleton S y = 0
state_after: no goals
tactic: simp [h]
Theorem: Polynomial.toLaurent_C
File: Mathlib/Algebra/Polynomial/Laurent.lean

Proof steps:
state_before: R : Type u_1
inst✝ : Semiring R
r : R
⊢ toLaurent (Polynomial.C r) = C r
state_after: case h.e'_3
R : Type u_1
inst✝ : Semiring R
r : R
⊢ C r = C r * T ↑0
tactic: convert Polynomial.toLaurent_C_mul_T 0 r
state_before: case h.e'_3
R : Type u_1
inst✝ : Semiring R
r : R
⊢ C r = C r * T ↑0
state_after: no goals
tactic: simp only [Int.ofNat_zero, T_zero, mul_one]
Theorem: PadicSeq.norm_const
File: Mathlib/NumberTheory/Padics/PadicNumbers.lean

Proof steps:
state_before: p : ℕ
hp : Fact (Nat.Prime p)
q : ℚ
hq : q = 0
⊢ norm (const (padicNorm p) q) = padicNorm p q
state_after: p : ℕ
hp : Fact (Nat.Prime p)
q : ℚ
hq : q = 0
this : const (padicNorm p) q ≈ 0
⊢ norm (const (padicNorm p) q) = padicNorm p q
tactic: have : const (padicNorm p) q ≈ 0 := by simpa [hq] using Setoid.refl (const (padicNorm p) 0)
state_before: p : ℕ
hp : Fact (Nat.Prime p)
q : ℚ
hq : q = 0
this : const (padicNorm p) q ≈ 0
⊢ norm (const (padicNorm p) q) = padicNorm p q
state_after: p : ℕ
hp : Fact (Nat.Prime p)
this : const (padicNorm p) 0 ≈ 0
⊢ norm (const (padicNorm p) 0) = padicNorm p 0
tactic: subst hq
state_before: p : ℕ
hp : Fact (Nat.Prime p)
this : const (padicNorm p) 0 ≈ 0
⊢ norm (const (padicNorm p) 0) = padicNorm p 0
state_after: no goals
tactic: simp [norm, this]
state_before: p : ℕ
hp : Fact (Nat.Prime p)
q : ℚ
hq : ¬q = 0
⊢ norm (const (padicNorm p) q) = padicNorm p q
state_after: p : ℕ
hp : Fact (Nat.Prime p)
q : ℚ
hq : ¬q = 0
this : ¬const (padicNorm p) q ≈ 0
⊢ norm (const (padicNorm p) q) = padicNorm p q
tactic: have : ¬const (padicNorm p) q ≈ 0 := not_equiv_zero_const_of_nonzero hq
state_before: p : ℕ
hp : Fact (Nat.Prime p)
q : ℚ
hq : ¬q = 0
this : ¬const (padicNorm p) q ≈ 0
⊢ norm (const (padicNorm p) q) = padicNorm p q
state_after: no goals
tactic: simp [norm, this]
Theorem: Mon_.one_braiding
File: Mathlib/CategoryTheory/Monoidal/Mon_.lean

Proof steps:
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
X Y : Mon_ C
⊢ (X ⊗ Y).one ≫ (β_ X.X Y.X).hom = (Y ⊗ X).one
state_after: C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
X Y : Mon_ C
⊢ (ρ_ (𝟙_ C)).hom ≫ (λ_ (𝟙_ C)).inv ≫ (Y.one ⊗ X.one) = Y.one ⊗ X.one
tactic: simp only [monMonoidalStruct_tensorObj_X, tensor_one, Category.assoc,
    BraidedCategory.braiding_naturality, braiding_tensorUnit_right, Iso.cancel_iso_inv_left]
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
X Y : Mon_ C
⊢ (ρ_ (𝟙_ C)).hom ≫ (λ_ (𝟙_ C)).inv ≫ (Y.one ⊗ X.one) = Y.one ⊗ X.one
state_after: no goals
tactic: coherence
Theorem: PartialEquiv.IsImage.symm_apply_mem_iff
File: Mathlib/Logic/Equiv/PartialEquiv.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
e : PartialEquiv α β
e' : PartialEquiv β γ
s : Set α
t : Set β
x✝ : α
y : β
h : e.IsImage s t
x : α
hx : x ∈ e.source
⊢ ↑e.symm (↑e x) ∈ s ↔ ↑e x ∈ t
state_after: no goals
tactic: rw [e.left_inv hx, h hx]
Theorem: Polynomial.degree_mul'
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
h : p.leadingCoeff * q.leadingCoeff ≠ 0
⊢ p ≠ 0
state_after: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p✝ p q : R[X]
ι : Type u_1
h : p.leadingCoeff * q.leadingCoeff ≠ 0
⊢ p = 0 → p.leadingCoeff * q.leadingCoeff = 0
tactic: refine mt ?_ h
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
h : p.leadingCoeff * q.leadingCoeff ≠ 0
⊢ p = 0 → p.leadingCoeff * q.leadingCoeff = 0
state_after: no goals
tactic: exact fun hp => by rw [hp, leadingCoeff_zero, zero_mul]
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
h : p.leadingCoeff * q.leadingCoeff ≠ 0
hp : p ≠ 0
⊢ q ≠ 0
state_after: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p✝ p q : R[X]
ι : Type u_1
h : p.leadingCoeff * q.leadingCoeff ≠ 0
hp : p ≠ 0
⊢ q = 0 → p.leadingCoeff * q.leadingCoeff = 0
tactic: refine mt ?_ h
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
h : p.leadingCoeff * q.leadingCoeff ≠ 0
hp : p ≠ 0
⊢ q = 0 → p.leadingCoeff * q.leadingCoeff = 0
state_after: no goals
tactic: exact fun hq => by rw [hq, leadingCoeff_zero, mul_zero]
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
h : p.leadingCoeff * q.leadingCoeff ≠ 0
hp : p ≠ 0
hq : q ≠ 0
⊢ p.degree + q.degree ≤ (p * q).degree
state_after: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p✝ p q : R[X]
ι : Type u_1
h : p.leadingCoeff * q.leadingCoeff ≠ 0
hp : p ≠ 0
hq : q ≠ 0
⊢ ↑p.natDegree + ↑q.natDegree ≤ (p * q).degree
tactic: rw [degree_eq_natDegree hp, degree_eq_natDegree hq]
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
h : p.leadingCoeff * q.leadingCoeff ≠ 0
hp : p ≠ 0
hq : q ≠ 0
⊢ ↑p.natDegree + ↑q.natDegree ≤ (p * q).degree
state_after: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p✝ p q : R[X]
ι : Type u_1
h : p.leadingCoeff * q.leadingCoeff ≠ 0
hp : p ≠ 0
hq : q ≠ 0
⊢ (p * q).coeff (p.natDegree + q.natDegree) ≠ 0
tactic: refine le_degree_of_ne_zero (n := natDegree p + natDegree q) ?_
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
h : p.leadingCoeff * q.leadingCoeff ≠ 0
hp : p ≠ 0
hq : q ≠ 0
⊢ (p * q).coeff (p.natDegree + q.natDegree) ≠ 0
state_after: no goals
tactic: rwa [coeff_mul_degree_add_degree]
Theorem: IsLocalizedModule.ringHom_ext
File: Mathlib/Algebra/Module/LocalizedModule.lean

Proof steps:
state_before: R : Type u_1
inst✝¹² : CommSemiring R
S : Submonoid R
M : Type u_2
M' : Type u_3
M'' : Type u_4
inst✝¹¹ : AddCommMonoid M
inst✝¹⁰ : AddCommMonoid M'
inst✝⁹ : AddCommMonoid M''
A : Type u_5
inst✝⁸ : CommSemiring A
inst✝⁷ : Algebra R A
inst✝⁶ : Module A M'
inst✝⁵ : IsLocalization S A
inst✝⁴ : Module R M
inst✝³ : Module R M'
inst✝² : Module R M''
inst✝¹ : IsScalarTower R A M'
f : M →ₗ[R] M'
g : M →ₗ[R] M''
inst✝ : IsLocalizedModule S f
map_unit : ∀ (x : ↥S), IsUnit ((algebraMap R (Module.End R M'')) ↑x)
j k : M' →ₗ[R] M''
h : j ∘ₗ f = k ∘ₗ f
⊢ j = k
state_after: case hl
R : Type u_1
inst✝¹² : CommSemiring R
S : Submonoid R
M : Type u_2
M' : Type u_3
M'' : Type u_4
inst✝¹¹ : AddCommMonoid M
inst✝¹⁰ : AddCommMonoid M'
inst✝⁹ : AddCommMonoid M''
A : Type u_5
inst✝⁸ : CommSemiring A
inst✝⁷ : Algebra R A
inst✝⁶ : Module A M'
inst✝⁵ : IsLocalization S A
inst✝⁴ : Module R M
inst✝³ : Module R M'
inst✝² : Module R M''
inst✝¹ : IsScalarTower R A M'
f : M →ₗ[R] M'
g : M →ₗ[R] M''
inst✝ : IsLocalizedModule S f
map_unit : ∀ (x : ↥S), IsUnit ((algebraMap R (Module.End R M'')) ↑x)
j k : M' →ₗ[R] M''
h : j ∘ₗ f = k ∘ₗ f
⊢ k ∘ₗ f = k ∘ₗ f
tactic: rw [← lift_unique S f (k.comp f) map_unit j h, lift_unique]
state_before: case hl
R : Type u_1
inst✝¹² : CommSemiring R
S : Submonoid R
M : Type u_2
M' : Type u_3
M'' : Type u_4
inst✝¹¹ : AddCommMonoid M
inst✝¹⁰ : AddCommMonoid M'
inst✝⁹ : AddCommMonoid M''
A : Type u_5
inst✝⁸ : CommSemiring A
inst✝⁷ : Algebra R A
inst✝⁶ : Module A M'
inst✝⁵ : IsLocalization S A
inst✝⁴ : Module R M
inst✝³ : Module R M'
inst✝² : Module R M''
inst✝¹ : IsScalarTower R A M'
f : M →ₗ[R] M'
g : M →ₗ[R] M''
inst✝ : IsLocalizedModule S f
map_unit : ∀ (x : ↥S), IsUnit ((algebraMap R (Module.End R M'')) ↑x)
j k : M' →ₗ[R] M''
h : j ∘ₗ f = k ∘ₗ f
⊢ k ∘ₗ f = k ∘ₗ f
state_after: no goals
tactic: rfl
Theorem: inf_himp_le
File: Mathlib/Order/Heyting/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : GeneralizedHeytingAlgebra α
a b c d : α
⊢ a ⊓ (a ⇨ b) ≤ b
state_after: no goals
tactic: rw [inf_comm, ← le_himp_iff]
Theorem: Nat.coprime_add_self_right
File: Mathlib/Data/Nat/GCD/Basic.lean

Proof steps:
state_before: m n : ℕ
⊢ m.Coprime (n + m) ↔ m.Coprime n
state_after: no goals
tactic: rw [Coprime, Coprime, gcd_add_self_right]
Theorem: IsBezout.gcd_dvd_left
File: Mathlib/RingTheory/PrincipalIdealDomain.lean

Proof steps:
state_before: R : Type u
M : Type v
inst✝¹ : CommRing R
x y z : R
inst✝ : IsPrincipal (Ideal.span {x, y})
⊢ x ∈ {x, y}
state_after: no goals
tactic: simp
Theorem: ENNReal.mul_iSup
File: Mathlib/Topology/Instances/ENNReal.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
ι : Sort u_4
f : ι → ℝ≥0∞
a : ℝ≥0∞
⊢ a * iSup f = ⨆ i, a * f i
state_after: case pos
α : Type u_1
β : Type u_2
γ : Type u_3
a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
ι : Sort u_4
f : ι → ℝ≥0∞
a : ℝ≥0∞
hf : ∀ (i : ι), f i = 0
⊢ a * iSup f = ⨆ i, a * f i

case neg
α : Type u_1
β : Type u_2
γ : Type u_3
a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
ι : Sort u_4
f : ι → ℝ≥0∞
a : ℝ≥0∞
hf : ¬∀ (i : ι), f i = 0
⊢ a * iSup f = ⨆ i, a * f i
tactic: by_cases hf : ∀ i, f i = 0
Theorem: Nat.iSup_lt_succ'
File: Mathlib/Data/Nat/Lattice.lean

Proof steps:
state_before: α : Type u_1
inst✝ : CompleteLattice α
u : ℕ → α
n : ℕ
⊢ ⨆ k, ⨆ (_ : k < n + 1), u k = u 0 ⊔ ⨆ k, ⨆ (_ : k < n), u (k + 1)
state_after: α : Type u_1
inst✝ : CompleteLattice α
u : ℕ → α
n : ℕ
⊢ (⨆ (_ : 0 < n + 1), u 0) ⊔ ⨆ i, ⨆ (_ : i + 1 < n + 1), u (i + 1) = u 0 ⊔ ⨆ k, ⨆ (_ : k < n), u (k + 1)
tactic: rw [← sup_iSup_nat_succ]
state_before: α : Type u_1
inst✝ : CompleteLattice α
u : ℕ → α
n : ℕ
⊢ (⨆ (_ : 0 < n + 1), u 0) ⊔ ⨆ i, ⨆ (_ : i + 1 < n + 1), u (i + 1) = u 0 ⊔ ⨆ k, ⨆ (_ : k < n), u (k + 1)
state_after: no goals
tactic: simp
Theorem: ENNReal.inv_le_iff_inv_le
File: Mathlib/Data/ENNReal/Inv.lean

Proof steps:
state_before: a b c d : ℝ≥0∞
r p q : ℝ≥0
⊢ a⁻¹ ≤ b ↔ b⁻¹ ≤ a
state_after: no goals
tactic: simpa only [inv_inv] using @ENNReal.inv_le_inv a b⁻¹