ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Finset.eraseNone_image_some
File: Mathlib/Data/Finset/Option.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : DecidableEq (Option α)
s : Finset α
⊢ eraseNone (image some s) = s
state_after: no goals
tactic: simpa only [map_eq_image] using eraseNone_map_some s
Theorem: ContinuousLinearMap.opNNNorm_le_of_unit_nnnorm
File: Mathlib/Analysis/NormedSpace/OperatorNorm/NNNorm.lean

Proof steps:
state_before: 𝕜 : Type u_1
𝕜₂ : Type u_2
𝕜₃ : Type u_3
E : Type u_4
Eₗ : Type u_5
F : Type u_6
Fₗ : Type u_7
G : Type u_8
Gₗ : Type u_9
𝓕 : Type u_10
inst✝²⁰ : SeminormedAddCommGroup E
inst✝¹⁹ : SeminormedAddCommGroup Eₗ
inst✝¹⁸ : SeminormedAddCommGroup F
inst✝¹⁷ : SeminormedAddCommGroup Fₗ
inst✝¹⁶ : SeminormedAddCommGroup G
inst✝¹⁵ : SeminormedAddCommGroup Gₗ
inst✝¹⁴ : NontriviallyNormedField 𝕜
inst✝¹³ : NontriviallyNormedField 𝕜₂
inst✝¹² : NontriviallyNormedField 𝕜₃
inst✝¹¹ : NormedSpace 𝕜 E
inst✝¹⁰ : NormedSpace 𝕜 Eₗ
inst✝⁹ : NormedSpace 𝕜₂ F
inst✝⁸ : NormedSpace 𝕜 Fₗ
inst✝⁷ : NormedSpace 𝕜₃ G
inst✝⁶ : NormedSpace 𝕜 Gₗ
σ₁₂ : 𝕜 →+* 𝕜₂
σ₂₃ : 𝕜₂ →+* 𝕜₃
σ₁₃ : 𝕜 →+* 𝕜₃
inst✝⁵ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
inst✝⁴ : FunLike 𝓕 E F
inst✝³ : RingHomIsometric σ₁₂
inst✝² : RingHomIsometric σ₂₃
f✝ g : E →SL[σ₁₂] F
h : F →SL[σ₂₃] G
x✝ : E
inst✝¹ : NormedSpace ℝ E
inst✝ : NormedSpace ℝ F
f : E →L[ℝ] F
C : ℝ≥0
hf : ∀ (x : E), ‖x‖₊ = 1 → ‖f x‖₊ ≤ C
x : E
hx : ‖x‖ = 1
⊢ ‖x‖₊ = 1
state_after: no goals
tactic: rwa [← NNReal.coe_eq_one]
Theorem: PerfectField.separable_iff_squarefree
File: Mathlib/FieldTheory/Perfect.lean

Proof steps:
state_before: K : Type u_1
inst✝¹ : Field K
inst✝ : PerfectField K
g : K[X]
sqf : Squarefree g
⊢ ∀ (z : K[X]), Irreducible z → z ∣ g → ¬z ∣ derivative g
state_after: case intro
K : Type u_1
inst✝¹ : Field K
inst✝ : PerfectField K
p : K[X]
h : Irreducible p
q : K[X]
sqf : Squarefree (p * q)
dvd : p ∣ derivative (p * q)
⊢ False
tactic: rintro p (h : Irreducible p) ⟨q, rfl⟩ (dvd : p ∣ derivative (p * q))
state_before: case intro
K : Type u_1
inst✝¹ : Field K
inst✝ : PerfectField K
p : K[X]
h : Irreducible p
q : K[X]
sqf : Squarefree (p * q)
dvd : p ∣ derivative (p * q)
⊢ False
state_after: case intro
K : Type u_1
inst✝¹ : Field K
inst✝ : PerfectField K
p : K[X]
h : Irreducible p
q : K[X]
sqf : Squarefree (p * q)
dvd : p ∣ q
⊢ False
tactic: replace dvd : p ∣ q := by
    rw [derivative_mul, dvd_add_left (dvd_mul_right p _)] at dvd
    exact (separable_of_irreducible h).dvd_of_dvd_mul_left dvd
state_before: case intro
K : Type u_1
inst✝¹ : Field K
inst✝ : PerfectField K
p : K[X]
h : Irreducible p
q : K[X]
sqf : Squarefree (p * q)
dvd : p ∣ q
⊢ False
state_after: no goals
tactic: exact (h.1 : ¬ IsUnit p) (sqf _ <| mul_dvd_mul_left _ dvd)
Theorem: minpoly.ne_one
File: Mathlib/FieldTheory/Minpoly/Basic.lean

Proof steps:
state_before: A : Type u_1
B : Type u_2
B' : Type u_3
inst✝⁵ : CommRing A
inst✝⁴ : Ring B
inst✝³ : Ring B'
inst✝² : Algebra A B
inst✝¹ : Algebra A B'
x : B
inst✝ : Nontrivial B
⊢ minpoly A x ≠ 1
state_after: A : Type u_1
B : Type u_2
B' : Type u_3
inst✝⁵ : CommRing A
inst✝⁴ : Ring B
inst✝³ : Ring B'
inst✝² : Algebra A B
inst✝¹ : Algebra A B'
x : B
inst✝ : Nontrivial B
h : minpoly A x = 1
⊢ False
tactic: intro h
state_before: A : Type u_1
B : Type u_2
B' : Type u_3
inst✝⁵ : CommRing A
inst✝⁴ : Ring B
inst✝³ : Ring B'
inst✝² : Algebra A B
inst✝¹ : Algebra A B'
x : B
inst✝ : Nontrivial B
h : minpoly A x = 1
⊢ False
state_after: A : Type u_1
B : Type u_2
B' : Type u_3
inst✝⁵ : CommRing A
inst✝⁴ : Ring B
inst✝³ : Ring B'
inst✝² : Algebra A B
inst✝¹ : Algebra A B'
x : B
inst✝ : Nontrivial B
h : minpoly A x = 1
⊢ 1 = 0
tactic: refine (one_ne_zero : (1 : B) ≠ 0) ?_
state_before: A : Type u_1
B : Type u_2
B' : Type u_3
inst✝⁵ : CommRing A
inst✝⁴ : Ring B
inst✝³ : Ring B'
inst✝² : Algebra A B
inst✝¹ : Algebra A B'
x : B
inst✝ : Nontrivial B
h : minpoly A x = 1
⊢ 1 = 0
state_after: no goals
tactic: simpa using congr_arg (Polynomial.aeval x) h
Theorem: CategoryTheory.Functor.isEquivalence_of_comp_left
File: Mathlib/CategoryTheory/Equivalence.lean

Proof steps:
state_before: C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
E : Type u_1
inst✝² : Category.{u_2, u_1} E
F : C ⥤ D
G : D ⥤ E
inst✝¹ : F.IsEquivalence
inst✝ : (F ⋙ G).IsEquivalence
⊢ G.IsEquivalence
state_after: C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
E : Type u_1
inst✝² : Category.{u_2, u_1} E
F : C ⥤ D
G : D ⥤ E
inst✝¹ : F.IsEquivalence
inst✝ : (F ⋙ G).IsEquivalence
⊢ ((F.asEquivalence.inverse ⋙ F.asEquivalence.functor) ⋙ G).IsEquivalence
tactic: rw [isEquivalence_iff_of_iso (G.leftUnitor.symm ≪≫
    isoWhiskerRight F.asEquivalence.counitIso.symm G)]
state_before: C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
E : Type u_1
inst✝² : Category.{u_2, u_1} E
F : C ⥤ D
G : D ⥤ E
inst✝¹ : F.IsEquivalence
inst✝ : (F ⋙ G).IsEquivalence
⊢ ((F.asEquivalence.inverse ⋙ F.asEquivalence.functor) ⋙ G).IsEquivalence
state_after: no goals
tactic: exact (F.asEquivalence.symm.trans (F ⋙ G).asEquivalence).isEquivalence_functor
Theorem: ENNReal.tsum_iSup_eq
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∞
f✝ g : α✝ → ℝ≥0∞
α : Type u_4
a : α
f : α → ℝ≥0∞
x✝ : α
h : x✝ ≠ a
⊢ ⨆ (_ : a = x✝), f x✝ = 0
state_after: no goals
tactic: simp [h.symm]
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∞
f✝ g : α✝ → ℝ≥0∞
α : Type u_4
a : α
f : α → ℝ≥0∞
⊢ ⨆ (_ : a = a), f a = f a
state_after: no goals
tactic: simp
Theorem: SubfieldClass.qsmul_mem
File: Mathlib/Algebra/Field/Subfield.lean

Proof steps:
state_before: K : Type u
L : Type v
M : Type w
inst✝³ : DivisionRing K
inst✝² : DivisionRing L
inst✝¹ : DivisionRing M
S : Type u_1
inst✝ : SetLike S K
h : SubfieldClass S K
x : K
s : S
q : ℚ
hx : x ∈ s
⊢ q • x ∈ s
state_after: no goals
tactic: simpa only [Rat.smul_def] using mul_mem (ratCast_mem _ _) hx
Theorem: Equiv.Perm.subtypeCongr.right_apply
File: Mathlib/Logic/Equiv/Basic.lean

Proof steps:
state_before: ε : Type u_1
p : ε → Prop
inst✝ : DecidablePred p
ep ep' : Perm { a // p a }
en en' : Perm { a // ¬p a }
a : ε
h : ¬p a
⊢ (ep.subtypeCongr en) a = ↑(en ⟨a, h⟩)
state_after: no goals
tactic: simp [Perm.subtypeCongr.apply, h]
Theorem: Rat.MulRingNorm.eq_on_nat_iff_eq_on_Int
File: Mathlib/NumberTheory/Ostrowski.lean

Proof steps:
state_before: f g : MulRingNorm ℚ
⊢ (∀ (n : ℕ), f ↑n = g ↑n) ↔ ∀ (n : ℤ), f ↑n = g ↑n
state_after: f g : MulRingNorm ℚ
h : ∀ (n : ℕ), f ↑n = g ↑n
z : ℤ
⊢ f ↑z = g ↑z
tactic: refine ⟨fun h z ↦ ?_, fun a n ↦ a n⟩
state_before: f g : MulRingNorm ℚ
h : ∀ (n : ℕ), f ↑n = g ↑n
z : ℤ
⊢ f ↑z = g ↑z
state_after: no goals
tactic: obtain ⟨n , rfl | rfl⟩ := eq_nat_or_neg z <;>
  simp only [Int.cast_neg, Int.cast_natCast, map_neg_eq_map, h n]
Theorem: ModuleCat.isZero_of_subsingleton
File: Mathlib/Algebra/Category/ModuleCat/Basic.lean

Proof steps:
state_before: R : Type u
inst✝¹ : Ring R
M : ModuleCat R
inst✝ : Subsingleton ↑M
X : ModuleCat R
f : M ⟶ X
⊢ f = default
state_after: case h
R : Type u
inst✝¹ : Ring R
M : ModuleCat R
inst✝ : Subsingleton ↑M
X : ModuleCat R
f : M ⟶ X
x : ↑M
⊢ f x = default x
tactic: ext x
state_before: case h
R : Type u
inst✝¹ : Ring R
M : ModuleCat R
inst✝ : Subsingleton ↑M
X : ModuleCat R
f : M ⟶ X
x : ↑M
⊢ f x = default x
state_after: case h
R : Type u
inst✝¹ : Ring R
M : ModuleCat R
inst✝ : Subsingleton ↑M
X : ModuleCat R
f : M ⟶ X
x : ↑M
⊢ f 0 = default 0
tactic: rw [Subsingleton.elim x (0 : M)]
state_before: case h
R : Type u
inst✝¹ : Ring R
M : ModuleCat R
inst✝ : Subsingleton ↑M
X : ModuleCat R
f : M ⟶ X
x : ↑M
⊢ f 0 = default 0
state_after: case h
R : Type u
inst✝¹ : Ring R
M : ModuleCat R
inst✝ : Subsingleton ↑M
X : ModuleCat R
f : M ⟶ X
x : ↑M
⊢ f 0 = 0 0
tactic: dsimp
state_before: case h
R : Type u
inst✝¹ : Ring R
M : ModuleCat R
inst✝ : Subsingleton ↑M
X : ModuleCat R
f : M ⟶ X
x : ↑M
⊢ f 0 = 0 0
state_after: no goals
tactic: simp
state_before: R : Type u
inst✝¹ : Ring R
M : ModuleCat R
inst✝ : Subsingleton ↑M
X : ModuleCat R
f : X ⟶ M
⊢ f = default
state_after: case h
R : Type u
inst✝¹ : Ring R
M : ModuleCat R
inst✝ : Subsingleton ↑M
X : ModuleCat R
f : X ⟶ M
x : ↑X
⊢ f x = default x
tactic: ext x
state_before: case h
R : Type u
inst✝¹ : Ring R
M : ModuleCat R
inst✝ : Subsingleton ↑M
X : ModuleCat R
f : X ⟶ M
x : ↑X
⊢ f x = default x
state_after: no goals
tactic: subsingleton
Theorem: Filter.eventually_nhdsSet_prod_iff
File: Mathlib/Topology/Constructions.lean

Proof steps:
state_before: X✝ : Type u
Y✝ : Type v
Z : Type u_1
W : Type u_2
ε : Type u_3
ζ : Type u_4
X : Type u_5
Y : Type u_6
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
f : Filter X
s : Set X
t : Set Y
x : X
p : X × Y → Prop
⊢ (∀ᶠ (q : X × Y) in 𝓝ˢ (s ×ˢ t), p q) ↔
    ∀ x ∈ s,
      ∀ y ∈ t,
        ∃ px,
          (∀ᶠ (x' : X) in 𝓝 x, px x') ∧ ∃ py, (∀ᶠ (y' : Y) in 𝓝 y, py y') ∧ ∀ {x : X}, px x → ∀ {y : Y}, py y → p (x, y)
state_after: no goals
tactic: simp_rw [eventually_nhdsSet_iff_forall, forall_prod_set, nhds_prod_eq, eventually_prod_iff]
Theorem: Finset.neg_smul_finset
File: Mathlib/Data/Finset/Pointwise.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝³ : Ring α
inst✝² : AddCommGroup β
inst✝¹ : Module α β
inst✝ : DecidableEq β
s : Finset α
t : Finset β
a : α
⊢ -a • t = -(a • t)
state_after: no goals
tactic: simp only [← image_smul, ← image_neg, image_image, neg_smul, Function.comp]
Theorem: MeasureTheory.Measure.setIntegral_condKernel_univ_left
File: Mathlib/Probability/Kernel/Disintegration/Integral.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
Ω : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
inst✝⁵ : MeasurableSpace Ω
inst✝⁴ : StandardBorelSpace Ω
inst✝³ : Nonempty Ω
ρ : Measure (β × Ω)
inst✝² : IsFiniteMeasure ρ
E : Type u_4
f : β × Ω → E
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
t : Set Ω
ht : MeasurableSet t
hf : IntegrableOn f (Set.univ ×ˢ t) ρ
⊢ ∫ (b : β), ∫ (ω : Ω) in t, f (b, ω) ∂ρ.condKernel b ∂ρ.fst = ∫ (x : β × Ω) in Set.univ ×ˢ t, f x ∂ρ
state_after: α : Type u_1
β : Type u_2
Ω : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
inst✝⁵ : MeasurableSpace Ω
inst✝⁴ : StandardBorelSpace Ω
inst✝³ : Nonempty Ω
ρ : Measure (β × Ω)
inst✝² : IsFiniteMeasure ρ
E : Type u_4
f : β × Ω → E
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
t : Set Ω
ht : MeasurableSet t
hf : IntegrableOn f (Set.univ ×ˢ t) ρ
⊢ ∫ (b : β), ∫ (ω : Ω) in t, f (b, ω) ∂ρ.condKernel b ∂ρ.fst =
    ∫ (b : β) in Set.univ, ∫ (ω : Ω) in t, f (b, ω) ∂ρ.condKernel b ∂ρ.fst
tactic: rw [← setIntegral_condKernel MeasurableSet.univ ht hf]
state_before: α : Type u_1
β : Type u_2
Ω : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
inst✝⁵ : MeasurableSpace Ω
inst✝⁴ : StandardBorelSpace Ω
inst✝³ : Nonempty Ω
ρ : Measure (β × Ω)
inst✝² : IsFiniteMeasure ρ
E : Type u_4
f : β × Ω → E
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
t : Set Ω
ht : MeasurableSet t
hf : IntegrableOn f (Set.univ ×ˢ t) ρ
⊢ ∫ (b : β), ∫ (ω : Ω) in t, f (b, ω) ∂ρ.condKernel b ∂ρ.fst =
    ∫ (b : β) in Set.univ, ∫ (ω : Ω) in t, f (b, ω) ∂ρ.condKernel b ∂ρ.fst
state_after: no goals
tactic: simp_rw [Measure.restrict_univ]
Theorem: LinearMap.isSkewAdjoint_iff_neg_self_adjoint
File: Mathlib/LinearAlgebra/SesquilinearForm.lean

Proof steps:
state_before: R : Type u_1
R₁ : Type u_2
R₂ : Type u_3
R₃ : Type u_4
M : Type u_5
M₁ : Type u_6
M₂ : Type u_7
M₃ : Type u_8
Mₗ₁ : Type u_9
Mₗ₁' : Type u_10
Mₗ₂ : Type u_11
Mₗ₂' : Type u_12
K : Type u_13
K₁ : Type u_14
K₂ : Type u_15
V : Type u_16
V₁ : Type u_17
V₂ : Type u_18
n : Type u_19
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
inst✝³ : AddCommGroup M₁
inst✝² : Module R M₁
inst✝¹ : AddCommGroup M₂
inst✝ : Module R M₂
B F : M →ₗ[R] M →ₗ[R] M₂
f : Module.End R M
⊢ (∀ (x y : M), (B (f x)) y = (B x) ((-f) y)) ↔ ∀ (x y : M), (B (f x)) y = ((-B) x) (f y)
state_after: no goals
tactic: simp
Theorem: CategoryTheory.strongEpi_of_strongEpi
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 ≫ g)
X Y : C
z : X ⟶ Y
x✝ : Mono z
⊢ HasLiftingProperty g z
state_after: case sq_hasLift
C : Type u
inst✝¹ : Category.{v, u} C
P Q R : C
f : P ⟶ Q
g : Q ⟶ R
inst✝ : StrongEpi (f ≫ g)
X Y : C
z : X ⟶ Y
x✝ : Mono z
⊢ ∀ {f : Q ⟶ X} {g_1 : R ⟶ Y} (sq : CommSq f g z g_1), sq.HasLift
tactic: constructor
state_before: case sq_hasLift
C : Type u
inst✝¹ : Category.{v, u} C
P Q R : C
f : P ⟶ Q
g : Q ⟶ R
inst✝ : StrongEpi (f ≫ g)
X Y : C
z : X ⟶ Y
x✝ : Mono z
⊢ ∀ {f : Q ⟶ X} {g_1 : R ⟶ Y} (sq : CommSq f g z g_1), sq.HasLift
state_after: case sq_hasLift
C : Type u
inst✝¹ : Category.{v, u} C
P Q R : C
f : P ⟶ Q
g : Q ⟶ R
inst✝ : StrongEpi (f ≫ g)
X Y : C
z : X ⟶ Y
x✝ : Mono z
u : Q ⟶ X
v : R ⟶ Y
sq : CommSq u g z v
⊢ sq.HasLift
tactic: intro u v sq
state_before: case sq_hasLift
C : Type u
inst✝¹ : Category.{v, u} C
P Q R : C
f : P ⟶ Q
g : Q ⟶ R
inst✝ : StrongEpi (f ≫ g)
X Y : C
z : X ⟶ Y
x✝ : Mono z
u : Q ⟶ X
v : R ⟶ Y
sq : CommSq u g z v
⊢ sq.HasLift
state_after: case sq_hasLift
C : Type u
inst✝¹ : Category.{v, u} C
P Q R : C
f : P ⟶ Q
g : Q ⟶ R
inst✝ : StrongEpi (f ≫ g)
X Y : C
z : X ⟶ Y
x✝ : Mono z
u : Q ⟶ X
v : R ⟶ Y
sq : CommSq u g z v
h₀ : (f ≫ u) ≫ z = (f ≫ g) ≫ v
⊢ sq.HasLift
tactic: have h₀ : (f ≫ u) ≫ z = (f ≫ g) ≫ v := by simp only [Category.assoc, sq.w]
state_before: case sq_hasLift
C : Type u
inst✝¹ : Category.{v, u} C
P Q R : C
f : P ⟶ Q
g : Q ⟶ R
inst✝ : StrongEpi (f ≫ g)
X Y : C
z : X ⟶ Y
x✝ : Mono z
u : Q ⟶ X
v : R ⟶ Y
sq : CommSq u g z v
h₀ : (f ≫ u) ≫ z = (f ≫ g) ≫ v
⊢ sq.HasLift
state_after: no goals
tactic: exact
        CommSq.HasLift.mk'
          ⟨(CommSq.mk h₀).lift, by
            simp only [← cancel_mono z, Category.assoc, CommSq.fac_right, sq.w], by simp⟩
Theorem: Substring.ValidFor.atEnd
File: .lake/packages/batteries/Batteries/Data/String/Lemmas.lean

Proof steps:
state_before: l m r : List Char
p : Nat
⊢ { str := { data := l ++ m ++ r }, startPos := { byteIdx := utf8Len l },
            stopPos := { byteIdx := utf8Len l + utf8Len m } }.atEnd
        { byteIdx := p } =
      true ↔
    p = utf8Len m
state_after: no goals
tactic: simp [Substring.atEnd, Pos.ext_iff, Nat.add_left_cancel_iff]
Theorem: LinearMap.dualMap_injective_iff
File: Mathlib/LinearAlgebra/Dual.lean

Proof steps:
state_before: K : Type uK
inst✝⁴ : Field K
V₁ : Type uV₁
V₂ : Type uV₂
inst✝³ : AddCommGroup V₁
inst✝² : Module K V₁
inst✝¹ : AddCommGroup V₂
inst✝ : Module K V₂
f : V₁ →ₗ[K] V₂
⊢ Function.Injective ⇑f.dualMap ↔ Function.Surjective ⇑f
state_after: K : Type uK
inst✝⁴ : Field K
V₁ : Type uV₁
V₂ : Type uV₂
inst✝³ : AddCommGroup V₁
inst✝² : Module K V₁
inst✝¹ : AddCommGroup V₂
inst✝ : Module K V₂
f : V₁ →ₗ[K] V₂
not_surj : ¬Function.Surjective ⇑f
inj : Function.Injective ⇑f.dualMap
⊢ False
tactic: refine ⟨Function.mtr fun not_surj inj ↦ ?_, dualMap_injective_of_surjective⟩
state_before: K : Type uK
inst✝⁴ : Field K
V₁ : Type uV₁
V₂ : Type uV₂
inst✝³ : AddCommGroup V₁
inst✝² : Module K V₁
inst✝¹ : AddCommGroup V₂
inst✝ : Module K V₂
f : V₁ →ₗ[K] V₂
not_surj : ¬Function.Surjective ⇑f
inj : Function.Injective ⇑f.dualMap
⊢ False
state_after: K : Type uK
inst✝⁴ : Field K
V₁ : Type uV₁
V₂ : Type uV₂
inst✝³ : AddCommGroup V₁
inst✝² : Module K V₁
inst✝¹ : AddCommGroup V₂
inst✝ : Module K V₂
f : V₁ →ₗ[K] V₂
not_surj : range f < ⊤
inj : Function.Injective ⇑f.dualMap
⊢ False
tactic: rw [← range_eq_top, ← Ne, ← lt_top_iff_ne_top] at not_surj
state_before: K : Type uK
inst✝⁴ : Field K
V₁ : Type uV₁
V₂ : Type uV₂
inst✝³ : AddCommGroup V₁
inst✝² : Module K V₁
inst✝¹ : AddCommGroup V₂
inst✝ : Module K V₂
f : V₁ →ₗ[K] V₂
not_surj : range f < ⊤
inj : Function.Injective ⇑f.dualMap
⊢ False
state_after: case intro.intro
K : Type uK
inst✝⁴ : Field K
V₁ : Type uV₁
V₂ : Type uV₂
inst✝³ : AddCommGroup V₁
inst✝² : Module K V₁
inst✝¹ : AddCommGroup V₂
inst✝ : Module K V₂
f : V₁ →ₗ[K] V₂
not_surj : range f < ⊤
inj : Function.Injective ⇑f.dualMap
φ : V₂ →ₗ[K] K
φ0 : φ ≠ 0
range_le_ker : range f ≤ ker φ
⊢ False
tactic: obtain ⟨φ, φ0, range_le_ker⟩ := (range f).exists_le_ker_of_lt_top not_surj
state_before: case intro.intro
K : Type uK
inst✝⁴ : Field K
V₁ : Type uV₁
V₂ : Type uV₂
inst✝³ : AddCommGroup V₁
inst✝² : Module K V₁
inst✝¹ : AddCommGroup V₂
inst✝ : Module K V₂
f : V₁ →ₗ[K] V₂
not_surj : range f < ⊤
inj : Function.Injective ⇑f.dualMap
φ : V₂ →ₗ[K] K
φ0 : φ ≠ 0
range_le_ker : range f ≤ ker φ
⊢ False
state_after: no goals
tactic: exact φ0 (inj <| ext fun x ↦ range_le_ker ⟨x, rfl⟩)
Theorem: ZMod.val_sub
File: Mathlib/Data/ZMod/Basic.lean

Proof steps:
state_before: m n✝ n : ℕ
inst✝ : NeZero n
a b : ZMod n
h : b.val ≤ a.val
⊢ (a - b).val = a.val - b.val
state_after: case pos
m n✝ n : ℕ
inst✝ : NeZero n
a b : ZMod n
h : b.val ≤ a.val
hb : b = 0
⊢ (a - b).val = a.val - b.val

case neg
m n✝ n : ℕ
inst✝ : NeZero n
a b : ZMod n
h : b.val ≤ a.val
hb : ¬b = 0
⊢ (a - b).val = a.val - b.val
tactic: by_cases hb : b = 0
Theorem: CategoryTheory.Localization.exists_rightFraction
File: Mathlib/CategoryTheory/Localization/CalculusOfFractions.lean

Proof steps:
state_before: C : Type u_1
D : Type u_2
inst✝³ : Category.{u_4, u_1} C
inst✝² : Category.{u_3, u_2} D
L : C ⥤ D
W : MorphismProperty C
inst✝¹ : L.IsLocalization W
inst✝ : W.HasRightCalculusOfFractions
X Y : C
f : L.obj X ⟶ L.obj Y
⊢ ∃ φ, f = φ.map L ⋯
state_after: case intro
C : Type u_1
D : Type u_2
inst✝³ : Category.{u_4, u_1} C
inst✝² : Category.{u_3, u_2} D
L : C ⥤ D
W : MorphismProperty C
inst✝¹ : L.IsLocalization W
inst✝ : W.HasRightCalculusOfFractions
X Y : C
f : L.obj X ⟶ L.obj Y
φ : W.op.LeftFraction (Opposite.op Y) (Opposite.op X)
eq : f.op = φ.map L.op ⋯
⊢ ∃ φ, f = φ.map L ⋯
tactic: obtain ⟨φ, eq⟩ := Localization.exists_leftFraction L.op W.op f.op
state_before: case intro
C : Type u_1
D : Type u_2
inst✝³ : Category.{u_4, u_1} C
inst✝² : Category.{u_3, u_2} D
L : C ⥤ D
W : MorphismProperty C
inst✝¹ : L.IsLocalization W
inst✝ : W.HasRightCalculusOfFractions
X Y : C
f : L.obj X ⟶ L.obj Y
φ : W.op.LeftFraction (Opposite.op Y) (Opposite.op X)
eq : f.op = φ.map L.op ⋯
⊢ ∃ φ, f = φ.map L ⋯
state_after: case intro
C : Type u_1
D : Type u_2
inst✝³ : Category.{u_4, u_1} C
inst✝² : Category.{u_3, u_2} D
L : C ⥤ D
W : MorphismProperty C
inst✝¹ : L.IsLocalization W
inst✝ : W.HasRightCalculusOfFractions
X Y : C
f : L.obj X ⟶ L.obj Y
φ : W.op.LeftFraction (Opposite.op Y) (Opposite.op X)
eq : f.op = φ.map L.op ⋯
⊢ f.op = (φ.unop.map L ⋯).op
tactic: refine ⟨φ.unop, Quiver.Hom.op_inj ?_⟩
state_before: case intro
C : Type u_1
D : Type u_2
inst✝³ : Category.{u_4, u_1} C
inst✝² : Category.{u_3, u_2} D
L : C ⥤ D
W : MorphismProperty C
inst✝¹ : L.IsLocalization W
inst✝ : W.HasRightCalculusOfFractions
X Y : C
f : L.obj X ⟶ L.obj Y
φ : W.op.LeftFraction (Opposite.op Y) (Opposite.op X)
eq : f.op = φ.map L.op ⋯
⊢ f.op = (φ.unop.map L ⋯).op
state_after: case intro
C : Type u_1
D : Type u_2
inst✝³ : Category.{u_4, u_1} C
inst✝² : Category.{u_3, u_2} D
L : C ⥤ D
W : MorphismProperty C
inst✝¹ : L.IsLocalization W
inst✝ : W.HasRightCalculusOfFractions
X Y : C
f : L.obj X ⟶ L.obj Y
φ : W.op.LeftFraction (Opposite.op Y) (Opposite.op X)
eq : f.op = φ.map L.op ⋯
⊢ φ.map L.op ⋯ = φ.unop.op.map L.op ⋯
tactic: rw [eq, MorphismProperty.RightFraction.op_map]
state_before: case intro
C : Type u_1
D : Type u_2
inst✝³ : Category.{u_4, u_1} C
inst✝² : Category.{u_3, u_2} D
L : C ⥤ D
W : MorphismProperty C
inst✝¹ : L.IsLocalization W
inst✝ : W.HasRightCalculusOfFractions
X Y : C
f : L.obj X ⟶ L.obj Y
φ : W.op.LeftFraction (Opposite.op Y) (Opposite.op X)
eq : f.op = φ.map L.op ⋯
⊢ φ.map L.op ⋯ = φ.unop.op.map L.op ⋯
state_after: no goals
tactic: rfl
Theorem: _private.Mathlib.Combinatorics.Additive.Corner.Roth.0.Corners.farFromTriangleFree_graph
File: Mathlib/Combinatorics/Additive/Corner/Roth.lean

Proof steps:
state_before: G : Type u_1
inst✝² : AddCommGroup G
inst✝¹ : Fintype G
A B : Finset (G × G)
a b c d x y : G
n : ℕ
ε : ℝ
inst✝ : DecidableEq G
hε : ε * ↑(Fintype.card G) ^ 2 ≤ ↑A.card
⊢ (graph (Corners.triangleIndices A)).FarFromTriangleFree (ε / 9)
state_after: G : Type u_1
inst✝² : AddCommGroup G
inst✝¹ : Fintype G
A B : Finset (G × G)
a b c d x y : G
n : ℕ
ε : ℝ
inst✝ : DecidableEq G
hε : ε * ↑(Fintype.card G) ^ 2 ≤ ↑A.card
⊢ ε / 9 * ↑((Fintype.card G + Fintype.card G + Fintype.card G) ^ 2) ≤ ↑(Corners.triangleIndices A).card
tactic: refine farFromTriangleFree _ ?_
state_before: G : Type u_1
inst✝² : AddCommGroup G
inst✝¹ : Fintype G
A B : Finset (G × G)
a b c d x y : G
n : ℕ
ε : ℝ
inst✝ : DecidableEq G
hε : ε * ↑(Fintype.card G) ^ 2 ≤ ↑A.card
⊢ ε / 9 * ↑((Fintype.card G + Fintype.card G + Fintype.card G) ^ 2) ≤ ↑(Corners.triangleIndices A).card
state_after: G : Type u_1
inst✝² : AddCommGroup G
inst✝¹ : Fintype G
A B : Finset (G × G)
a b c d x y : G
n : ℕ
ε : ℝ
inst✝ : DecidableEq G
hε : ε * ↑(Fintype.card G) ^ 2 ≤ ↑A.card
⊢ ε * ((↑(Fintype.card G) + ↑(Fintype.card G) + ↑(Fintype.card G)) ^ 2 / 9) ≤ ↑A.card
tactic: simp_rw [card_triangleIndices, mul_comm_div, Nat.cast_pow, Nat.cast_add]
state_before: G : Type u_1
inst✝² : AddCommGroup G
inst✝¹ : Fintype G
A B : Finset (G × G)
a b c d x y : G
n : ℕ
ε : ℝ
inst✝ : DecidableEq G
hε : ε * ↑(Fintype.card G) ^ 2 ≤ ↑A.card
⊢ ε * ((↑(Fintype.card G) + ↑(Fintype.card G) + ↑(Fintype.card G)) ^ 2 / 9) ≤ ↑A.card
state_after: G : Type u_1
inst✝² : AddCommGroup G
inst✝¹ : Fintype G
A B : Finset (G × G)
a b c d x y : G
n : ℕ
ε : ℝ
inst✝ : DecidableEq G
hε : ε * ↑(Fintype.card G) ^ 2 ≤ ↑A.card
⊢ ε * ↑(Fintype.card G) ^ 2 ≤ ↑A.card
tactic: ring_nf
state_before: G : Type u_1
inst✝² : AddCommGroup G
inst✝¹ : Fintype G
A B : Finset (G × G)
a b c d x y : G
n : ℕ
ε : ℝ
inst✝ : DecidableEq G
hε : ε * ↑(Fintype.card G) ^ 2 ≤ ↑A.card
⊢ ε * ↑(Fintype.card G) ^ 2 ≤ ↑A.card
state_after: no goals
tactic: simpa only [mul_comm] using hε
Theorem: CategoryTheory.Limits.imageSubobject_mono
File: Mathlib/CategoryTheory/Subobject/Limits.lean

Proof steps:
state_before: C : Type u
inst✝² : Category.{v, u} C
X Y Z : C
f✝ : X ⟶ Y
inst✝¹ : HasImage f✝
f : X ⟶ Y
inst✝ : Mono f
⊢ (imageSubobjectIso f ≪≫ imageMonoIsoSource f ≪≫ (underlyingIso f).symm).hom ≫ (Subobject.mk f).arrow =
    (imageSubobject f).arrow
state_after: no goals
tactic: simp