ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Polynomial.not_isUnit_of_natDegree_pos_of_isReduced
File: Mathlib/RingTheory/Polynomial/Nilpotent.lean

Proof steps:
state_before: R : Type u_1
r : R
inst✝¹ : CommRing R
P : R[X]
inst✝ : IsReduced R
p : R[X]
hpl : 0 < p.natDegree
⊢ ¬IsUnit p
state_after: R : Type u_1
r : R
inst✝¹ : CommRing R
P : R[X]
inst✝ : IsReduced R
p : R[X]
hpl : 0 < p.natDegree
⊢ IsUnit (p.coeff 0) → ∃ x, ¬x = 0 ∧ ¬p.coeff x = 0
tactic: simp only [ne_eq, isNilpotent_iff_eq_zero, not_and, not_forall, exists_prop,
    Polynomial.isUnit_iff_coeff_isUnit_isNilpotent]
state_before: R : Type u_1
r : R
inst✝¹ : CommRing R
P : R[X]
inst✝ : IsReduced R
p : R[X]
hpl : 0 < p.natDegree
⊢ IsUnit (p.coeff 0) → ∃ x, ¬x = 0 ∧ ¬p.coeff x = 0
state_after: R : Type u_1
r : R
inst✝¹ : CommRing R
P : R[X]
inst✝ : IsReduced R
p : R[X]
hpl : 0 < p.natDegree
a✝ : IsUnit (p.coeff 0)
⊢ ∃ x, ¬x = 0 ∧ ¬p.coeff x = 0
tactic: intro _
state_before: R : Type u_1
r : R
inst✝¹ : CommRing R
P : R[X]
inst✝ : IsReduced R
p : R[X]
hpl : 0 < p.natDegree
a✝ : IsUnit (p.coeff 0)
⊢ ∃ x, ¬x = 0 ∧ ¬p.coeff x = 0
state_after: R : Type u_1
r : R
inst✝¹ : CommRing R
P : R[X]
inst✝ : IsReduced R
p : R[X]
hpl : 0 < p.natDegree
a✝ : IsUnit (p.coeff 0)
⊢ ¬p.coeff p.natDegree = 0
tactic: refine ⟨p.natDegree, hpl.ne', ?_⟩
state_before: R : Type u_1
r : R
inst✝¹ : CommRing R
P : R[X]
inst✝ : IsReduced R
p : R[X]
hpl : 0 < p.natDegree
a✝ : IsUnit (p.coeff 0)
⊢ ¬p.coeff p.natDegree = 0
state_after: R : Type u_1
r : R
inst✝¹ : CommRing R
P : R[X]
inst✝ : IsReduced R
p : R[X]
a✝ : IsUnit (p.coeff 0)
hpl : p.coeff p.natDegree = 0
⊢ p.natDegree ≤ 0
tactic: contrapose! hpl
state_before: R : Type u_1
r : R
inst✝¹ : CommRing R
P : R[X]
inst✝ : IsReduced R
p : R[X]
a✝ : IsUnit (p.coeff 0)
hpl : p.coeff p.natDegree = 0
⊢ p.natDegree ≤ 0
state_after: R : Type u_1
r : R
inst✝¹ : CommRing R
P : R[X]
inst✝ : IsReduced R
p : R[X]
a✝ : IsUnit (p.coeff 0)
hpl : p = 0
⊢ p.natDegree ≤ 0
tactic: simp only [coeff_natDegree, leadingCoeff_eq_zero] at hpl
state_before: R : Type u_1
r : R
inst✝¹ : CommRing R
P : R[X]
inst✝ : IsReduced R
p : R[X]
a✝ : IsUnit (p.coeff 0)
hpl : p = 0
⊢ p.natDegree ≤ 0
state_after: no goals
tactic: simp [hpl]
Theorem: Finset.mem_pimage
File: Mathlib/Data/Finset/PImage.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝² : DecidableEq β
f g : α →. β
inst✝¹ : (x : α) → Decidable (f x).Dom
inst✝ : (x : α) → Decidable (g x).Dom
s t : Finset α
b : β
⊢ b ∈ pimage f s ↔ ∃ a ∈ s, b ∈ f a
state_after: no goals
tactic: simp [pimage]
Theorem: ENorm.map_neg
File: Mathlib/Analysis/NormedSpace/ENorm.lean

Proof steps:
state_before: 𝕜 : Type u_1
V : Type u_2
inst✝² : NormedField 𝕜
inst✝¹ : AddCommGroup V
inst✝ : Module 𝕜 V
e : ENorm 𝕜 V
x : V
⊢ ↑e (-x) = ↑‖-1‖₊ * ↑e x
state_after: no goals
tactic: rw [← map_smul, neg_one_smul]
state_before: 𝕜 : Type u_1
V : Type u_2
inst✝² : NormedField 𝕜
inst✝¹ : AddCommGroup V
inst✝ : Module 𝕜 V
e : ENorm 𝕜 V
x : V
⊢ ↑‖-1‖₊ * ↑e x = ↑e x
state_after: no goals
tactic: simp
Theorem: Function.Commute.iterate_pos_lt_iff_map_lt
File: Mathlib/Order/Iterate.lean

Proof steps:
state_before: α : Type u_1
inst✝ : LinearOrder α
f g : α → α
h : Commute f g
hf : Monotone f
hg : StrictMono g
x : α
n : ℕ
hn : 0 < n
⊢ f^[n] x < g^[n] x ↔ f x < g x
state_after: case inl
α : Type u_1
inst✝ : LinearOrder α
f g : α → α
h : Commute f g
hf : Monotone f
hg : StrictMono g
x : α
n : ℕ
hn : 0 < n
H : f x < g x
⊢ f^[n] x < g^[n] x ↔ f x < g x

case inr.inl
α : Type u_1
inst✝ : LinearOrder α
f g : α → α
h : Commute f g
hf : Monotone f
hg : StrictMono g
x : α
n : ℕ
hn : 0 < n
H : f x = g x
⊢ f^[n] x < g^[n] x ↔ f x < g x

case inr.inr
α : Type u_1
inst✝ : LinearOrder α
f g : α → α
h : Commute f g
hf : Monotone f
hg : StrictMono g
x : α
n : ℕ
hn : 0 < n
H : g x < f x
⊢ f^[n] x < g^[n] x ↔ f x < g x
tactic: rcases lt_trichotomy (f x) (g x) with (H | H | H)
Theorem: neg_neg_sub_neg
File: Mathlib/Algebra/Group/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : DivisionCommMonoid α
a b c d : α
⊢ (a⁻¹ / b⁻¹)⁻¹ = a / b
state_after: no goals
tactic: simp
Theorem: Real.sin_sub_sin
File: Mathlib/Data/Complex/Exponential.lean

Proof steps:
state_before: x y : ℝ
⊢ ↑(sin x - sin y) = ↑(2 * sin ((x - y) / 2) * cos ((x + y) / 2))
state_after: no goals
tactic: simp [sin_sub_sin]
Theorem: PiLp.norm_sq_eq_of_L2
File: Mathlib/Analysis/Normed/Lp/PiLp.lean

Proof steps:
state_before: p : ℝ≥0∞
𝕜 : Type u_1
ι : Type u_2
α : ι → Type u_3
β✝ : ι → Type u_4
inst✝² : Fact (1 ≤ p)
inst✝¹ : Fintype ι
β : ι → Type u_5
inst✝ : (i : ι) → SeminormedAddCommGroup (β i)
x : PiLp 2 β
⊢ ‖x‖ ^ 2 = ∑ i : ι, ‖x i‖ ^ 2
state_after: p : ℝ≥0∞
𝕜 : Type u_1
ι : Type u_2
α : ι → Type u_3
β✝ : ι → Type u_4
inst✝² : Fact (1 ≤ p)
inst✝¹ : Fintype ι
β : ι → Type u_5
inst✝ : (i : ι) → SeminormedAddCommGroup (β i)
x : PiLp 2 β
⊢ ‖x‖₊ ^ 2 = ∑ i : ι, ‖x i‖₊ ^ 2
tactic: suffices ‖x‖₊ ^ 2 = ∑ i : ι, ‖x i‖₊ ^ 2 by
    simpa only [NNReal.coe_sum] using congr_arg ((↑) : ℝ≥0 → ℝ) this
state_before: p : ℝ≥0∞
𝕜 : Type u_1
ι : Type u_2
α : ι → Type u_3
β✝ : ι → Type u_4
inst✝² : Fact (1 ≤ p)
inst✝¹ : Fintype ι
β : ι → Type u_5
inst✝ : (i : ι) → SeminormedAddCommGroup (β i)
x : PiLp 2 β
⊢ ‖x‖₊ ^ 2 = ∑ i : ι, ‖x i‖₊ ^ 2
state_after: no goals
tactic: rw [nnnorm_eq_of_L2, NNReal.sq_sqrt]
Theorem: Fin.partialSum_left_neg
File: Mathlib/Algebra/BigOperators/Fin.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝¹ : Monoid α
n : ℕ
G : Type u_3
inst✝ : Group G
f : Fin (n + 1) → G
x : Fin (n + 1)
⊢ (f 0 • partialProd fun i => (f ↑↑i)⁻¹ * f i.succ) 0 = f 0
state_after: no goals
tactic: simp
state_before: α : Type u_1
β : Type u_2
inst✝¹ : Monoid α
n : ℕ
G : Type u_3
inst✝ : Group G
f : Fin (n + 1) → G
x✝ : Fin (n + 1)
x : Fin n
hx : (f 0 • partialProd fun i => (f ↑↑i)⁻¹ * f i.succ) x.castSucc = f x.castSucc
⊢ (f 0 • partialProd fun i => (f ↑↑i)⁻¹ * f i.succ) x.succ = f x.succ
state_after: α : Type u_1
β : Type u_2
inst✝¹ : Monoid α
n : ℕ
G : Type u_3
inst✝ : Group G
f : Fin (n + 1) → G
x✝ : Fin (n + 1)
x : Fin n
hx : f 0 * partialProd (fun i => (f i.castSucc)⁻¹ * f i.succ) x.castSucc = f x.castSucc
⊢ f 0 * partialProd (fun i => (f i.castSucc)⁻¹ * f i.succ) x.succ = f x.succ
tactic: simp only [coe_eq_castSucc, Pi.smul_apply, smul_eq_mul] at hx ⊢
state_before: α : Type u_1
β : Type u_2
inst✝¹ : Monoid α
n : ℕ
G : Type u_3
inst✝ : Group G
f : Fin (n + 1) → G
x✝ : Fin (n + 1)
x : Fin n
hx : f 0 * partialProd (fun i => (f i.castSucc)⁻¹ * f i.succ) x.castSucc = f x.castSucc
⊢ f 0 * partialProd (fun i => (f i.castSucc)⁻¹ * f i.succ) x.succ = f x.succ
state_after: no goals
tactic: rw [partialProd_succ, ← mul_assoc, hx, mul_inv_cancel_left]
Theorem: AddSubmonoid.LocalizationMap.lift_add_left
File: Mathlib/GroupTheory/MonoidLocalization/Basic.lean

Proof steps:
state_before: M : Type u_1
inst✝² : CommMonoid M
S : Submonoid M
N : Type u_2
inst✝¹ : CommMonoid N
P : Type u_3
inst✝ : CommMonoid P
f : S.LocalizationMap N
g : M →* P
hg : ∀ (y : ↥S), IsUnit (g ↑y)
z : N
⊢ g ↑(f.sec z).2 * (f.lift hg) z = g (f.sec z).1
state_after: no goals
tactic: rw [mul_comm, lift_mul_right]
Theorem: monovary_inv
File: Mathlib/Algebra/Order/Monovary.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : OrderedCommGroup α
inst✝ : OrderedCommGroup β
s : Set ι
f f₁ f₂ : ι → α
g g₁ g₂ : ι → β
⊢ Monovary f⁻¹ g⁻¹ ↔ Monovary f g
state_after: no goals
tactic: simp
Theorem: tprod_congr_set_coe
File: Mathlib/Topology/Algebra/InfiniteSum/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : CommMonoid α
inst✝ : TopologicalSpace α
f✝ g : β → α
a a₁ a₂ : α
f : β → α
s t : Set β
h : s = t
⊢ ∏' (x : ↑s), f ↑x = ∏' (x : ↑t), f ↑x
state_after: no goals
tactic: rw [h]
Theorem: Ordinal.enumOrd_succ_le
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

Proof steps:
state_before: S : Set Ordinal.{u}
a b : Ordinal.{u}
hS : Unbounded (fun x x_1 => x < x_1) S
ha : a ∈ S
hb : enumOrd S b < a
⊢ enumOrd S (succ b) ≤ a
state_after: S : Set Ordinal.{u}
a b : Ordinal.{u}
hS : Unbounded (fun x x_1 => x < x_1) S
ha : a ∈ S
hb : enumOrd S b < a
⊢ sInf (S ∩ {b_1 | ∀ c < succ b, enumOrd S c < b_1}) ≤ a
tactic: rw [enumOrd_def]
state_before: S : Set Ordinal.{u}
a b : Ordinal.{u}
hS : Unbounded (fun x x_1 => x < x_1) S
ha : a ∈ S
hb : enumOrd S b < a
⊢ sInf (S ∩ {b_1 | ∀ c < succ b, enumOrd S c < b_1}) ≤ a
state_after: no goals
tactic: exact
    csInf_le' ⟨ha, fun c hc => ((enumOrd_strictMono hS).monotone (le_of_lt_succ hc)).trans_lt hb⟩
Theorem: eq_add_of_sub_eq'
File: Mathlib/Algebra/Group/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : CommGroup G
a b c d : G
h : a / b = c
⊢ a = b * c
state_after: no goals
tactic: simp [h.symm]
Theorem: ONote.fastGrowing_def
File: Mathlib/SetTheory/Ordinal/Notation.lean

Proof steps:
state_before: o : ONote
x : Option ONote ⊕ (ℕ → ONote)
e : o.fundamentalSequence = x
⊢ o.fastGrowing =
    match (motive := (x : Option ONote ⊕ (ℕ → ONote)) → o.FundamentalSequenceProp x → ℕ → ℕ) x, ⋯ with
    | Sum.inl none, x => Nat.succ
    | Sum.inl (some a), x => fun i => a.fastGrowing^[i] i
    | Sum.inr f, x => fun i => (f i).fastGrowing i
state_after: o : ONote
⊢ o.fastGrowing =
    match (motive := (x : Option ONote ⊕ (ℕ → ONote)) → o.FundamentalSequenceProp x → ℕ → ℕ) o.fundamentalSequence,
      ⋯ with
    | Sum.inl none, x => Nat.succ
    | Sum.inl (some a), x => fun i => a.fastGrowing^[i] i
    | Sum.inr f, x => fun i => (f i).fastGrowing i
tactic: subst x
state_before: o : ONote
⊢ o.fastGrowing =
    match (motive := (x : Option ONote ⊕ (ℕ → ONote)) → o.FundamentalSequenceProp x → ℕ → ℕ) o.fundamentalSequence,
      ⋯ with
    | Sum.inl none, x => Nat.succ
    | Sum.inl (some a), x => fun i => a.fastGrowing^[i] i
    | Sum.inr f, x => fun i => (f i).fastGrowing i
state_after: no goals
tactic: rw [fastGrowing]
Theorem: ProbabilityTheory.IndepFun.mgf_add
File: Mathlib/Probability/Moments.lean

Proof steps:
state_before: Ω : Type u_1
ι : Type u_2
m : MeasurableSpace Ω
X✝ : Ω → ℝ
p : ℕ
μ : Measure Ω
t : ℝ
X Y : Ω → ℝ
h_indep : IndepFun X Y μ
hX : AEStronglyMeasurable (fun ω => rexp (t * X ω)) μ
hY : AEStronglyMeasurable (fun ω => rexp (t * Y ω)) μ
⊢ mgf (X + Y) μ t = mgf X μ t * mgf Y μ t
state_after: Ω : Type u_1
ι : Type u_2
m : MeasurableSpace Ω
X✝ : Ω → ℝ
p : ℕ
μ : Measure Ω
t : ℝ
X Y : Ω → ℝ
h_indep : IndepFun X Y μ
hX : AEStronglyMeasurable (fun ω => rexp (t * X ω)) μ
hY : AEStronglyMeasurable (fun ω => rexp (t * Y ω)) μ
⊢ ∫ (x : Ω), rexp (t * X x) * rexp (t * Y x) ∂μ = (∫ (x : Ω), rexp (t * X x) ∂μ) * ∫ (x : Ω), rexp (t * Y x) ∂μ
tactic: simp_rw [mgf, Pi.add_apply, mul_add, exp_add]
state_before: Ω : Type u_1
ι : Type u_2
m : MeasurableSpace Ω
X✝ : Ω → ℝ
p : ℕ
μ : Measure Ω
t : ℝ
X Y : Ω → ℝ
h_indep : IndepFun X Y μ
hX : AEStronglyMeasurable (fun ω => rexp (t * X ω)) μ
hY : AEStronglyMeasurable (fun ω => rexp (t * Y ω)) μ
⊢ ∫ (x : Ω), rexp (t * X x) * rexp (t * Y x) ∂μ = (∫ (x : Ω), rexp (t * X x) ∂μ) * ∫ (x : Ω), rexp (t * Y x) ∂μ
state_after: no goals
tactic: exact (h_indep.exp_mul t t).integral_mul hX hY
Theorem: Finmap.ext
File: Mathlib/Data/Finmap.lean

Proof steps:
state_before: α : Type u
β : α → Type v
l₁ : Multiset (Sigma β)
h₁ : l₁.NodupKeys
l₂ : Multiset (Sigma β)
nodupKeys✝ : l₂.NodupKeys
H : { entries := l₁, nodupKeys := h₁ }.entries = { entries := l₂, nodupKeys := nodupKeys✝ }.entries
⊢ { entries := l₁, nodupKeys := h₁ } = { entries := l₂, nodupKeys := nodupKeys✝ }
state_after: no goals
tactic: congr
Theorem: TopologicalSpace.Opens.not_nonempty_iff_eq_bot
File: Mathlib/Topology/Sets/Opens.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : TopologicalSpace γ
U : Opens α
⊢ ¬(↑U).Nonempty ↔ U = ⊥
state_after: no goals
tactic: rw [← coe_inj, coe_bot, ← Set.not_nonempty_iff_eq_empty]
Theorem: ProbabilityTheory.iCondIndepSet_iff_iCondIndep
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Ω
s : ι → Set Ω
μ : Measure Ω
inst✝ : IsFiniteMeasure μ
⊢ iCondIndepSet m' hm' s μ ↔ iCondIndep m' hm' (fun i => generateFrom {s i}) μ
state_after: no goals
tactic: simp only [iCondIndepSet, iCondIndep, Kernel.iIndepSet]
Theorem: Finpartition.coe_energy
File: Mathlib/Combinatorics/SimpleGraph/Regularity/Energy.lean

Proof steps:
state_before: α : Type u_1
inst✝² : DecidableEq α
s : Finset α
P : Finpartition s
G : SimpleGraph α
inst✝¹ : DecidableRel G.Adj
𝕜 : Type u_2
inst✝ : LinearOrderedField 𝕜
⊢ ↑(P.energy G) = (∑ uv ∈ P.parts.offDiag, ↑(G.edgeDensity uv.1 uv.2) ^ 2) / ↑P.parts.card ^ 2
state_after: α : Type u_1
inst✝² : DecidableEq α
s : Finset α
P : Finpartition s
G : SimpleGraph α
inst✝¹ : DecidableRel G.Adj
𝕜 : Type u_2
inst✝ : LinearOrderedField 𝕜
⊢ ↑((∑ uv ∈ P.parts.offDiag, G.edgeDensity uv.1 uv.2 ^ 2) / ↑P.parts.card ^ 2) =
    (∑ uv ∈ P.parts.offDiag, ↑(G.edgeDensity uv.1 uv.2) ^ 2) / ↑P.parts.card ^ 2
tactic: rw [energy]
state_before: α : Type u_1
inst✝² : DecidableEq α
s : Finset α
P : Finpartition s
G : SimpleGraph α
inst✝¹ : DecidableRel G.Adj
𝕜 : Type u_2
inst✝ : LinearOrderedField 𝕜
⊢ ↑((∑ uv ∈ P.parts.offDiag, G.edgeDensity uv.1 uv.2 ^ 2) / ↑P.parts.card ^ 2) =
    (∑ uv ∈ P.parts.offDiag, ↑(G.edgeDensity uv.1 uv.2) ^ 2) / ↑P.parts.card ^ 2
state_after: no goals
tactic: norm_cast
Theorem: Set.nontrivial_coe_sort
File: Mathlib/Data/Set/Subsingleton.lean

Proof steps:
state_before: α : Type u
a : α
s✝ t s : Set α
⊢ Nontrivial ↑s ↔ s.Nontrivial
state_after: no goals
tactic: simp [← nontrivial_univ_iff, Set.Nontrivial]
Theorem: AlgebraicGeometry.Γ_map_morphismRestrict
File: Mathlib/AlgebraicGeometry/Restrict.lean

Proof steps:
state_before: C : Type u₁
inst✝ : Category.{v, u₁} C
X Y : Scheme
f : X ⟶ Y
U : Y.Opens
⊢ Scheme.Γ.map (f ∣_ U).op = Y.presheaf.map (eqToHom ⋯).op ≫ Scheme.Hom.app f U ≫ X.presheaf.map (eqToHom ⋯).op
state_after: C : Type u₁
inst✝ : Category.{v, u₁} C
X Y : Scheme
f : X ⟶ Y
U : Y.Opens
⊢ Scheme.Hom.app f (U.ι ''ᵁ ⊤) ≫ X.presheaf.map (eqToHom ⋯).op =
    Scheme.Hom.app f (⋯.functor.obj ⊤) ≫
      X.presheaf.map (((Opens.map f.val.base).map (eqToHom ⋯).op.unop).op ≫ (eqToHom ⋯).op)
tactic: rw [Scheme.Γ_map_op, morphismRestrict_app f U ⊤, f.naturality_assoc, ← X.presheaf.map_comp]
state_before: C : Type u₁
inst✝ : Category.{v, u₁} C
X Y : Scheme
f : X ⟶ Y
U : Y.Opens
⊢ Scheme.Hom.app f (U.ι ''ᵁ ⊤) ≫ X.presheaf.map (eqToHom ⋯).op =
    Scheme.Hom.app f (⋯.functor.obj ⊤) ≫
      X.presheaf.map (((Opens.map f.val.base).map (eqToHom ⋯).op.unop).op ≫ (eqToHom ⋯).op)
state_after: no goals
tactic: rfl
Theorem: Complementeds.coe_le_coe
File: Mathlib/Order/Disjoint.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : Lattice α
inst✝ : BoundedOrder α
a b : Complementeds α
⊢ ↑a ≤ ↑b ↔ a ≤ b
state_after: no goals
tactic: simp
Theorem: ConvexOn.le_right_of_left_le'
File: Mathlib/Analysis/Convex/Function.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
α : Type u_4
β : Type u_5
ι : Type u_6
inst✝⁶ : OrderedSemiring 𝕜
inst✝⁵ : AddCommMonoid E
inst✝⁴ : AddCommMonoid F
inst✝³ : LinearOrderedCancelAddCommMonoid β
inst✝² : SMul 𝕜 E
inst✝¹ : Module 𝕜 β
inst✝ : OrderedSMul 𝕜 β
s : Set E
f g : E → β
hf : ConvexOn 𝕜 s f
x y : E
a b : 𝕜
hx : x ∈ s
hy : y ∈ s
ha : 0 ≤ a
hb : 0 < b
hab : a + b = 1
hfx : f x ≤ f (a • x + b • y)
⊢ f (a • x + b • y) ≤ f y
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
α : Type u_4
β : Type u_5
ι : Type u_6
inst✝⁶ : OrderedSemiring 𝕜
inst✝⁵ : AddCommMonoid E
inst✝⁴ : AddCommMonoid F
inst✝³ : LinearOrderedCancelAddCommMonoid β
inst✝² : SMul 𝕜 E
inst✝¹ : Module 𝕜 β
inst✝ : OrderedSMul 𝕜 β
s : Set E
f g : E → β
hf : ConvexOn 𝕜 s f
x y : E
a b : 𝕜
hx : x ∈ s
hy : y ∈ s
ha : 0 ≤ a
hb : 0 < b
hab : b + a = 1
hfx : f x ≤ f (b • y + a • x)
⊢ f (b • y + a • x) ≤ f y
tactic: rw [add_comm] at hab hfx ⊢
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
α : Type u_4
β : Type u_5
ι : Type u_6
inst✝⁶ : OrderedSemiring 𝕜
inst✝⁵ : AddCommMonoid E
inst✝⁴ : AddCommMonoid F
inst✝³ : LinearOrderedCancelAddCommMonoid β
inst✝² : SMul 𝕜 E
inst✝¹ : Module 𝕜 β
inst✝ : OrderedSMul 𝕜 β
s : Set E
f g : E → β
hf : ConvexOn 𝕜 s f
x y : E
a b : 𝕜
hx : x ∈ s
hy : y ∈ s
ha : 0 ≤ a
hb : 0 < b
hab : b + a = 1
hfx : f x ≤ f (b • y + a • x)
⊢ f (b • y + a • x) ≤ f y
state_after: no goals
tactic: exact hf.le_left_of_right_le' hy hx hb ha hab hfx
Theorem: LieModule.iSup_ucs_le_weightSpace_zero
File: Mathlib/Algebra/Lie/Weights/Basic.lean

Proof steps:
state_before: K : Type u_1
R : Type u_2
L : Type u_3
M : Type u_4
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
inst✝⁴ : LieAlgebra.IsNilpotent R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
⊢ ⨆ k, LieSubmodule.ucs k ⊥ ≤ weightSpace M 0
state_after: no goals
tactic: simpa using LieSubmodule.ucs_le_of_normalizer_eq_self (weightSpace_zero_normalizer_eq_self R L M)
Theorem: Polynomial.rootSet_mapsTo
File: Mathlib/Algebra/Polynomial/Roots.lean

Proof steps:
state_before: R : Type u
S✝ : Type v
T : Type w
a b : R
n : ℕ
inst✝⁹ : CommRing R
inst✝⁸ : IsDomain R
p✝ q : R[X]
inst✝⁷ : CommRing T
p : T[X]
S : Type u_1
S' : Type u_2
inst✝⁶ : CommRing S
inst✝⁵ : IsDomain S
inst✝⁴ : Algebra T S
inst✝³ : CommRing S'
inst✝² : IsDomain S'
inst✝¹ : Algebra T S'
inst✝ : NoZeroSMulDivisors T S'
f : S →ₐ[T] S'
⊢ Set.MapsTo (⇑f) (p.rootSet S) (p.rootSet S')
state_after: R : Type u
S✝ : Type v
T : Type w
a b : R
n : ℕ
inst✝⁹ : CommRing R
inst✝⁸ : IsDomain R
p✝ q : R[X]
inst✝⁷ : CommRing T
p : T[X]
S : Type u_1
S' : Type u_2
inst✝⁶ : CommRing S
inst✝⁵ : IsDomain S
inst✝⁴ : Algebra T S
inst✝³ : CommRing S'
inst✝² : IsDomain S'
inst✝¹ : Algebra T S'
inst✝ : NoZeroSMulDivisors T S'
f : S →ₐ[T] S'
h₀ : map (algebraMap T S') p = 0
⊢ map (algebraMap T S) p = 0
tactic: refine rootSet_maps_to' (fun h₀ => ?_) f
state_before: R : Type u
S✝ : Type v
T : Type w
a b : R
n : ℕ
inst✝⁹ : CommRing R
inst✝⁸ : IsDomain R
p✝ q : R[X]
inst✝⁷ : CommRing T
p : T[X]
S : Type u_1
S' : Type u_2
inst✝⁶ : CommRing S
inst✝⁵ : IsDomain S
inst✝⁴ : Algebra T S
inst✝³ : CommRing S'
inst✝² : IsDomain S'
inst✝¹ : Algebra T S'
inst✝ : NoZeroSMulDivisors T S'
f : S →ₐ[T] S'
h₀ : map (algebraMap T S') p = 0
⊢ map (algebraMap T S) p = 0
state_after: R : Type u
S✝ : Type v
T : Type w
a b : R
n : ℕ
inst✝⁹ : CommRing R
inst✝⁸ : IsDomain R
p q : R[X]
inst✝⁷ : CommRing T
S : Type u_1
S' : Type u_2
inst✝⁶ : CommRing S
inst✝⁵ : IsDomain S
inst✝⁴ : Algebra T S
inst✝³ : CommRing S'
inst✝² : IsDomain S'
inst✝¹ : Algebra T S'
inst✝ : NoZeroSMulDivisors T S'
f : S →ₐ[T] S'
h₀ : map (algebraMap T S') 0 = 0
⊢ map (algebraMap T S) 0 = 0
tactic: obtain rfl : p = 0 :=
    map_injective _ (NoZeroSMulDivisors.algebraMap_injective T S') (by rwa [Polynomial.map_zero])
state_before: R : Type u
S✝ : Type v
T : Type w
a b : R
n : ℕ
inst✝⁹ : CommRing R
inst✝⁸ : IsDomain R
p q : R[X]
inst✝⁷ : CommRing T
S : Type u_1
S' : Type u_2
inst✝⁶ : CommRing S
inst✝⁵ : IsDomain S
inst✝⁴ : Algebra T S
inst✝³ : CommRing S'
inst✝² : IsDomain S'
inst✝¹ : Algebra T S'
inst✝ : NoZeroSMulDivisors T S'
f : S →ₐ[T] S'
h₀ : map (algebraMap T S') 0 = 0
⊢ map (algebraMap T S) 0 = 0
state_after: no goals
tactic: exact Polynomial.map_zero _
Theorem: IsAddFreimanIso.comp
File: Mathlib/Combinatorics/Additive/FreimanHom.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : CommMonoid α
inst✝¹ : CommMonoid β
inst✝ : CommMonoid γ
A A₁ A₂ : Set α
B B₁ B₂ : Set β
C : Set γ
f f₁ f₂ : α → β
g : β → γ
m n : ℕ
hg : IsMulFreimanIso n B C g
hf : IsMulFreimanIso n A B f
s t : Multiset α
hsA : ∀ ⦃x : α⦄, x ∈ s → x ∈ A
htA : ∀ ⦃x : α⦄, x ∈ t → x ∈ A
hs : card s = n
ht : card t = n
⊢ (map (g ∘ f) s).prod = (map (g ∘ f) t).prod ↔ s.prod = t.prod
state_after: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : CommMonoid α
inst✝¹ : CommMonoid β
inst✝ : CommMonoid γ
A A₁ A₂ : Set α
B B₁ B₂ : Set β
C : Set γ
f f₁ f₂ : α → β
g : β → γ
m n : ℕ
hg : IsMulFreimanIso n B C g
hf : IsMulFreimanIso n A B f
s t : Multiset α
hsA : ∀ ⦃x : α⦄, x ∈ s → x ∈ A
htA : ∀ ⦃x : α⦄, x ∈ t → x ∈ A
hs : card s = n
ht : card t = n
⊢ (map g (map f s)).prod = (map g (map f t)).prod ↔ s.prod = t.prod
tactic: rw [← map_map, ← map_map]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : CommMonoid α
inst✝¹ : CommMonoid β
inst✝ : CommMonoid γ
A A₁ A₂ : Set α
B B₁ B₂ : Set β
C : Set γ
f f₁ f₂ : α → β
g : β → γ
m n : ℕ
hg : IsMulFreimanIso n B C g
hf : IsMulFreimanIso n A B f
s t : Multiset α
hsA : ∀ ⦃x : α⦄, x ∈ s → x ∈ A
htA : ∀ ⦃x : α⦄, x ∈ t → x ∈ A
hs : card s = n
ht : card t = n
⊢ (map g (map f s)).prod = (map g (map f t)).prod ↔ s.prod = t.prod
state_after: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : CommMonoid α
inst✝¹ : CommMonoid β
inst✝ : CommMonoid γ
A A₁ A₂ : Set α
B B₁ B₂ : Set β
C : Set γ
f f₁ f₂ : α → β
g : β → γ
m n : ℕ
hg : IsMulFreimanIso n B C g
hf : IsMulFreimanIso n A B f
s t : Multiset α
hsA : ∀ ⦃x : α⦄, x ∈ s → x ∈ A
htA : ∀ ⦃x : α⦄, x ∈ t → x ∈ A
hs : card s = n
ht : card t = n
⊢ ∀ ⦃x : β⦄, x ∈ map f s → x ∈ B

F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : CommMonoid α
inst✝¹ : CommMonoid β
inst✝ : CommMonoid γ
A A₁ A₂ : Set α
B B₁ B₂ : Set β
C : Set γ
f f₁ f₂ : α → β
g : β → γ
m n : ℕ
hg : IsMulFreimanIso n B C g
hf : IsMulFreimanIso n A B f
s t : Multiset α
hsA : ∀ ⦃x : α⦄, x ∈ s → x ∈ A
htA : ∀ ⦃x : α⦄, x ∈ t → x ∈ A
hs : card s = n
ht : card t = n
⊢ ∀ ⦃x : β⦄, x ∈ map f t → x ∈ B
tactic: rw [hg.map_prod_eq_map_prod _ _ (by rwa [card_map]) (by rwa [card_map]),
      hf.map_prod_eq_map_prod hsA htA hs ht]
Theorem: Polynomial.zero_scaleRoots
File: Mathlib/RingTheory/Polynomial/ScaleRoots.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
A : Type u_3
K : Type u_4
inst✝¹ : Semiring R
inst✝ : Semiring S
s : R
⊢ scaleRoots 0 s = 0
state_after: case a
R : Type u_1
S : Type u_2
A : Type u_3
K : Type u_4
inst✝¹ : Semiring R
inst✝ : Semiring S
s : R
n✝ : ℕ
⊢ (scaleRoots 0 s).coeff n✝ = coeff 0 n✝
tactic: ext
state_before: case a
R : Type u_1
S : Type u_2
A : Type u_3
K : Type u_4
inst✝¹ : Semiring R
inst✝ : Semiring S
s : R
n✝ : ℕ
⊢ (scaleRoots 0 s).coeff n✝ = coeff 0 n✝
state_after: no goals
tactic: simp
Theorem: AlgebraicGeometry.PresheafedSpace.IsOpenImmersion.isIso_of_subset
File: Mathlib/Geometry/RingedSpace/OpenImmersion.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y : PresheafedSpace C
f : X ⟶ Y
H : IsOpenImmersion f
U : Opens ↑↑Y
hU : ↑U ⊆ Set.range ⇑f.base
⊢ IsIso (f.c.app (op U))
state_after: C : Type u
inst✝ : Category.{v, u} C
X Y : PresheafedSpace C
f : X ⟶ Y
H : IsOpenImmersion f
U : Opens ↑↑Y
hU : ↑U ⊆ Set.range ⇑f.base
this : U = ⋯.functor.obj ((Opens.map f.base).obj U)
⊢ IsIso (f.c.app (op U))
tactic: have : U = H.base_open.isOpenMap.functor.obj ((Opens.map f.base).obj U) := by
    ext1
    exact (Set.inter_eq_left.mpr hU).symm.trans Set.image_preimage_eq_inter_range.symm
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y : PresheafedSpace C
f : X ⟶ Y
H : IsOpenImmersion f
U : Opens ↑↑Y
hU : ↑U ⊆ Set.range ⇑f.base
this : U = ⋯.functor.obj ((Opens.map f.base).obj U)
⊢ IsIso (f.c.app (op U))
state_after: no goals
tactic: convert H.c_iso ((Opens.map f.base).obj U)
Theorem: Set.ncard_le_ncard_insert
File: Mathlib/Data/Set/Card.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
s✝ t : Set α
a : α
s : Set α
⊢ s.ncard ≤ (insert a s).ncard
state_after: no goals
tactic: classical
  refine
    s.finite_or_infinite.elim (fun h ↦ ?_) (fun h ↦ by (rw [h.ncard]; exact Nat.zero_le _))
  rw [ncard_insert_eq_ite h]; split_ifs <;> simp
Theorem: ProbabilityTheory.condIndep_iff_condIndepSets
File: Mathlib/Probability/Independence/Conditional.lean

Proof steps:
state_before: Ω : Type u_1
ι : Type u_2
m' m₁ m₂ mΩ : MeasurableSpace Ω
inst✝² : StandardBorelSpace Ω
inst✝¹ : Nonempty Ω
hm' : m' ≤ mΩ
μ : Measure Ω
inst✝ : IsFiniteMeasure μ
⊢ CondIndep m' m₁ m₂ hm' μ ↔ CondIndepSets m' hm' {s | MeasurableSet s} {s | MeasurableSet s} μ
state_after: no goals
tactic: simp only [CondIndep, CondIndepSets, Kernel.Indep]