ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: SimpleGraph.set_walk_length_succ_eq
File: Mathlib/Combinatorics/SimpleGraph/Connectivity/WalkCounting.lean

Proof steps:
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
n : ℕ
⊢ {p | p.length = n.succ} = ⋃ w, ⋃ (h : G.Adj u w), Walk.cons h '' {p' | p'.length = n}
state_after: case h
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
n : ℕ
p : G.Walk u v
⊢ p ∈ {p | p.length = n.succ} ↔ p ∈ ⋃ w, ⋃ (h : G.Adj u w), Walk.cons h '' {p' | p'.length = n}
tactic: ext p
state_before: case h
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
n : ℕ
p : G.Walk u v
⊢ p ∈ {p | p.length = n.succ} ↔ p ∈ ⋃ w, ⋃ (h : G.Adj u w), Walk.cons h '' {p' | p'.length = n}
state_after: case h.nil
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u : V
n : ℕ
⊢ Walk.nil ∈ {p | p.length = n.succ} ↔ Walk.nil ∈ ⋃ w, ⋃ (h : G.Adj u w), Walk.cons h '' {p' | p'.length = n}

case h.cons
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
n : ℕ
w : V
huw : G.Adj u w
pwv : G.Walk w v
⊢ Walk.cons huw pwv ∈ {p | p.length = n.succ} ↔
    Walk.cons huw pwv ∈ ⋃ w, ⋃ (h : G.Adj u w), Walk.cons h '' {p' | p'.length = n}
tactic: cases' p with _ _ w _ huw pwv
Theorem: affineSpan_eq_affineSpan_lineMap_units
File: Mathlib/LinearAlgebra/AffineSpace/Combination.lean

Proof steps:
state_before: ι : Type u_1
k : Type u_2
V : Type u_3
P : Type u_4
inst✝⁴ : Ring k
inst✝³ : AddCommGroup V
inst✝² : Module k V
inst✝¹ : AffineSpace V P
inst✝ : Nontrivial k
s : Set P
p : P
hp : p ∈ s
w : ↑s → kˣ
⊢ affineSpan k (Set.range fun q => (AffineMap.lineMap p ↑q) ↑(w q)) = affineSpan k s
state_after: ι : Type u_1
k : Type u_2
V : Type u_3
P : Type u_4
inst✝⁴ : Ring k
inst✝³ : AddCommGroup V
inst✝² : Module k V
inst✝¹ : AffineSpace V P
inst✝ : Nontrivial k
s : Set P
p : P
hp : p ∈ s
w : ↑s → kˣ
this : s = Set.range Subtype.val
⊢ affineSpan k (Set.range fun q => (AffineMap.lineMap p ↑q) ↑(w q)) = affineSpan k s
tactic: have : s = Set.range ((↑) : s → P) := by simp
state_before: ι : Type u_1
k : Type u_2
V : Type u_3
P : Type u_4
inst✝⁴ : Ring k
inst✝³ : AddCommGroup V
inst✝² : Module k V
inst✝¹ : AffineSpace V P
inst✝ : Nontrivial k
s : Set P
p : P
hp : p ∈ s
w : ↑s → kˣ
this : s = Set.range Subtype.val
⊢ affineSpan k (Set.range fun q => (AffineMap.lineMap p ↑q) ↑(w q)) = affineSpan k s
state_after: ι : Type u_1
k : Type u_2
V : Type u_3
P : Type u_4
inst✝⁴ : Ring k
inst✝³ : AddCommGroup V
inst✝² : Module k V
inst✝¹ : AffineSpace V P
inst✝ : Nontrivial k
s : Set P
p : P
hp : p ∈ s
w : ↑s → kˣ
this : s = Set.range Subtype.val
⊢ affineSpan k (Set.range fun q => (AffineMap.lineMap p ↑q) ↑(w q)) = affineSpan k (Set.range Subtype.val)
tactic: conv_rhs =>
    rw [this]
state_before: ι : Type u_1
k : Type u_2
V : Type u_3
P : Type u_4
inst✝⁴ : Ring k
inst✝³ : AddCommGroup V
inst✝² : Module k V
inst✝¹ : AffineSpace V P
inst✝ : Nontrivial k
s : Set P
p : P
hp : p ∈ s
w : ↑s → kˣ
this : s = Set.range Subtype.val
⊢ affineSpan k (Set.range fun q => (AffineMap.lineMap p ↑q) ↑(w q)) = affineSpan k (Set.range Subtype.val)
state_after: no goals
tactic: apply le_antisymm
    <;> intro q hq
    <;> erw [mem_affineSpan_iff_eq_weightedVSubOfPoint_vadd k V _ (⟨p, hp⟩ : s) q] at hq ⊢
    <;> obtain ⟨t, μ, rfl⟩ := hq
    <;> use t
    <;> [use fun x => μ x * ↑(w x); use fun x => μ x * ↑(w x)⁻¹]
    <;> simp [smul_smul]
Theorem: IntermediateField.isPurelyInseparable_adjoin_simple_iff_natSepDegree_eq_one
File: Mathlib/FieldTheory/PurelyInseparable.lean

Proof steps:
state_before: F : Type u
E : Type v
inst✝⁴ : Field F
inst✝³ : Field E
inst✝² : Algebra F E
K : Type w
inst✝¹ : Field K
inst✝ : Algebra F K
x : E
⊢ IsPurelyInseparable F ↥F⟮x⟯ ↔ (minpoly F x).natSepDegree = 1
state_after: no goals
tactic: rw [← le_perfectClosure_iff, adjoin_simple_le_iff, mem_perfectClosure_iff_natSepDegree_eq_one]
Theorem: Sym.multinomial_coe_fill_of_not_mem
File: Mathlib/Data/Nat/Choose/Multinomial.lean

Proof steps:
state_before: n : ℕ
α : Type u_1
inst✝ : DecidableEq α
m : Fin (n + 1)
s : Sym α (n - ↑m)
x : α
hx : x ∉ s
⊢ (↑(fill x m s)).multinomial = n.choose ↑m * (↑s).multinomial
state_after: n : ℕ
α : Type u_1
inst✝ : DecidableEq α
m : Fin (n + 1)
s : Sym α (n - ↑m)
x : α
hx : x ∉ s
⊢ (Multiset.card ↑(fill x m s)).choose (Multiset.count x ↑(fill x m s)) *
      (Multiset.filter (fun x_1 => x ≠ x_1) ↑(fill x m s)).multinomial =
    n.choose ↑m * (↑s).multinomial
tactic: rw [Multiset.multinomial_filter_ne x]
state_before: n : ℕ
α : Type u_1
inst✝ : DecidableEq α
m : Fin (n + 1)
s : Sym α (n - ↑m)
x : α
hx : x ∉ s
⊢ (Multiset.card ↑(fill x m s)).choose (Multiset.count x ↑(fill x m s)) *
      (Multiset.filter (fun x_1 => x ≠ x_1) ↑(fill x m s)).multinomial =
    n.choose ↑m * (↑s).multinomial
state_after: n : ℕ
α : Type u_1
inst✝ : DecidableEq α
m : Fin (n + 1)
s : Sym α (n - ↑m)
x : α
hx : x ∉ ↑s
⊢ (Multiset.card ↑(fill x m s)).choose (Multiset.count x ↑(fill x m s)) *
      (Multiset.filter (fun x_1 => x ≠ x_1) ↑(fill x m s)).multinomial =
    n.choose ↑m * (↑s).multinomial
tactic: rw [← mem_coe] at hx
state_before: n : ℕ
α : Type u_1
inst✝ : DecidableEq α
m : Fin (n + 1)
s : Sym α (n - ↑m)
x : α
hx : x ∉ ↑s
⊢ (Multiset.card ↑(fill x m s)).choose (Multiset.count x ↑(fill x m s)) *
      (Multiset.filter (fun x_1 => x ≠ x_1) ↑(fill x m s)).multinomial =
    n.choose ↑m * (↑s).multinomial
state_after: case refine_1
n : ℕ
α : Type u_1
inst✝ : DecidableEq α
m : Fin (n + 1)
s : Sym α (n - ↑m)
x : α
hx : x ∉ ↑s
⊢ (Multiset.card ↑(fill x m s)).choose (Multiset.count x ↑(fill x m s)) = n.choose ↑m

case refine_2
n : ℕ
α : Type u_1
inst✝ : DecidableEq α
m : Fin (n + 1)
s : Sym α (n - ↑m)
x : α
hx : x ∉ ↑s
⊢ (Multiset.filter (fun x_1 => x ≠ x_1) ↑(fill x m s)).multinomial = (↑s).multinomial
tactic: refine congrArg₂ _ ?_ ?_
Theorem: Sym2.card_image_offDiag
File: Mathlib/Data/Sym/Card.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
s : Finset α
⊢ (image Sym2.mk s.offDiag).card = s.card.choose 2
state_after: no goals
tactic: rw [Nat.choose_two_right, Nat.mul_sub_left_distrib, mul_one, ← offDiag_card,
    Nat.div_eq_of_eq_mul_right Nat.zero_lt_two (two_mul_card_image_offDiag s).symm]
Theorem: Batteries.RBNode.reverse_setBlack
File: .lake/packages/batteries/Batteries/Data/RBMap/WF.lean

Proof steps:
state_before: α : Type u_1
t : RBNode α
⊢ t.setBlack.reverse = t.reverse.setBlack
state_after: α : Type u_1
t : RBNode α
⊢ (match t with
      | nil => nil
      | node c l v r => node black l v r).reverse =
    match t.reverse with
    | nil => nil
    | node c l v r => node black l v r
tactic: unfold setBlack
state_before: α : Type u_1
t : RBNode α
⊢ (match t with
      | nil => nil
      | node c l v r => node black l v r).reverse =
    match t.reverse with
    | nil => nil
    | node c l v r => node black l v r
state_after: no goals
tactic: split <;> simp
Theorem: one_le_div_of_neg
File: Mathlib/Algebra/Order/Field/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedField α
a b c d : α
n : ℤ
hb : b < 0
⊢ 1 ≤ a / b ↔ a ≤ b
state_after: no goals
tactic: rw [le_div_iff_of_neg hb, one_mul]
Theorem: RingHom.FinitePresentation.of_comp_finiteType
File: Mathlib/RingTheory/FinitePresentation.lean

Proof steps:
state_before: A : Type u_1
B : Type u_2
C : Type u_3
inst✝² : CommRing A
inst✝¹ : CommRing B
inst✝ : CommRing C
f : A →+* B
g : B →+* C
hg : (g.comp f).FinitePresentation
hf : f.FiniteType
ins1 : Algebra A B := f.toAlgebra
ins2 : Algebra B C := g.toAlgebra
ins3 : Algebra A C := (g.comp f).toAlgebra
a : A
b : B
c : C
⊢ (a • b) • c = a • b • c
state_after: A : Type u_1
B : Type u_2
C : Type u_3
inst✝² : CommRing A
inst✝¹ : CommRing B
inst✝ : CommRing C
f : A →+* B
g : B →+* C
hg : (g.comp f).FinitePresentation
hf : f.FiniteType
ins1 : Algebra A B := f.toAlgebra
ins2 : Algebra B C := g.toAlgebra
ins3 : Algebra A C := (g.comp f).toAlgebra
a : A
b : B
c : C
⊢ (algebraMap B C) ((algebraMap A B) a) * ((algebraMap B C) b * c) = (algebraMap A C) a * ((algebraMap B C) b * c)
tactic: simp [Algebra.smul_def, mul_assoc]
state_before: A : Type u_1
B : Type u_2
C : Type u_3
inst✝² : CommRing A
inst✝¹ : CommRing B
inst✝ : CommRing C
f : A →+* B
g : B →+* C
hg : (g.comp f).FinitePresentation
hf : f.FiniteType
ins1 : Algebra A B := f.toAlgebra
ins2 : Algebra B C := g.toAlgebra
ins3 : Algebra A C := (g.comp f).toAlgebra
a : A
b : B
c : C
⊢ (algebraMap B C) ((algebraMap A B) a) * ((algebraMap B C) b * c) = (algebraMap A C) a * ((algebraMap B C) b * c)
state_after: no goals
tactic: rfl
Theorem: LieSubmodule.coe_toSubmodule_mk
File: Mathlib/Algebra/Lie/Submodule.lean

Proof steps:
state_before: R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
N N' : LieSubmodule R L M
p : Submodule R M
h : ∀ {x : L} {m : M}, m ∈ p.carrier → ⁅x, m⁆ ∈ p.carrier
⊢ ↑{ toSubmodule := p, lie_mem := h } = p
state_after: case mk
R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
N N' : LieSubmodule R L M
toAddSubmonoid✝ : AddSubmonoid M
smul_mem'✝ : ∀ (c : R) {x : M}, x ∈ toAddSubmonoid✝.carrier → c • x ∈ toAddSubmonoid✝.carrier
h :
  ∀ {x : L} {m : M},
    m ∈ { toAddSubmonoid := toAddSubmonoid✝, smul_mem' := smul_mem'✝ }.carrier →
      ⁅x, m⁆ ∈ { toAddSubmonoid := toAddSubmonoid✝, smul_mem' := smul_mem'✝ }.carrier
⊢ ↑{ toAddSubmonoid := toAddSubmonoid✝, smul_mem' := smul_mem'✝, lie_mem := h } =
    { toAddSubmonoid := toAddSubmonoid✝, smul_mem' := smul_mem'✝ }
tactic: cases p
state_before: case mk
R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
N N' : LieSubmodule R L M
toAddSubmonoid✝ : AddSubmonoid M
smul_mem'✝ : ∀ (c : R) {x : M}, x ∈ toAddSubmonoid✝.carrier → c • x ∈ toAddSubmonoid✝.carrier
h :
  ∀ {x : L} {m : M},
    m ∈ { toAddSubmonoid := toAddSubmonoid✝, smul_mem' := smul_mem'✝ }.carrier →
      ⁅x, m⁆ ∈ { toAddSubmonoid := toAddSubmonoid✝, smul_mem' := smul_mem'✝ }.carrier
⊢ ↑{ toAddSubmonoid := toAddSubmonoid✝, smul_mem' := smul_mem'✝, lie_mem := h } =
    { toAddSubmonoid := toAddSubmonoid✝, smul_mem' := smul_mem'✝ }
state_after: no goals
tactic: rfl
Theorem: LieModule.isCompl_weightSpaceOf_zero_posFittingCompOf
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
inst✝¹ : IsNoetherian R M
inst✝ : IsArtinian R M
x : L
⊢ IsCompl (weightSpaceOf M 0 x) (posFittingCompOf R M x)
state_after: no goals
tactic: simpa only [isCompl_iff, codisjoint_iff, disjoint_iff, ← LieSubmodule.coe_toSubmodule_eq_iff,
    LieSubmodule.sup_coe_toSubmodule, LieSubmodule.inf_coe_toSubmodule,
    LieSubmodule.top_coeSubmodule, LieSubmodule.bot_coeSubmodule, coe_weightSpaceOf_zero] using
    (toEnd R L M x).isCompl_iSup_ker_pow_iInf_range_pow
Theorem: MeasureTheory.exp_llr_of_ac
File: Mathlib/MeasureTheory/Measure/LogLikelihoodRatio.lean

Proof steps:
state_before: α : Type u_1
mα : MeasurableSpace α
μ✝ ν✝ : Measure α
f : α → ℝ
μ ν : Measure α
inst✝¹ : SigmaFinite μ
inst✝ : μ.HaveLebesgueDecomposition ν
hμν : μ ≪ ν
⊢ (fun x => rexp (llr μ ν x)) =ᶠ[ae μ] fun x => (μ.rnDeriv ν x).toReal
state_after: case h
α : Type u_1
mα : MeasurableSpace α
μ✝ ν✝ : Measure α
f : α → ℝ
μ ν : Measure α
inst✝¹ : SigmaFinite μ
inst✝ : μ.HaveLebesgueDecomposition ν
hμν : μ ≪ ν
x : α
hx_eq : rexp (llr μ ν x) = if μ.rnDeriv ν x = 0 then 1 else (μ.rnDeriv ν x).toReal
hx_pos : 0 < μ.rnDeriv ν x
⊢ rexp (llr μ ν x) = (μ.rnDeriv ν x).toReal
tactic: filter_upwards [hμν.ae_le (exp_llr μ ν), Measure.rnDeriv_pos hμν] with x hx_eq hx_pos
state_before: case h
α : Type u_1
mα : MeasurableSpace α
μ✝ ν✝ : Measure α
f : α → ℝ
μ ν : Measure α
inst✝¹ : SigmaFinite μ
inst✝ : μ.HaveLebesgueDecomposition ν
hμν : μ ≪ ν
x : α
hx_eq : rexp (llr μ ν x) = if μ.rnDeriv ν x = 0 then 1 else (μ.rnDeriv ν x).toReal
hx_pos : 0 < μ.rnDeriv ν x
⊢ rexp (llr μ ν x) = (μ.rnDeriv ν x).toReal
state_after: no goals
tactic: rw [hx_eq, if_neg hx_pos.ne']
Theorem: tendsto_Ioo_atTop
File: Mathlib/Topology/Order/DenselyOrdered.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderTopology α
inst✝ : DenselyOrdered α
a b : α
s : Set α
l : Filter β
f✝ : α → β
f : β → ↑(Ioo a b)
⊢ Tendsto f l atTop ↔ Tendsto (fun x => ↑(f x)) l (𝓝[<] b)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderTopology α
inst✝ : DenselyOrdered α
a b : α
s : Set α
l : Filter β
f✝ : α → β
f : β → ↑(Ioo a b)
⊢ Tendsto (Subtype.val ∘ f) l (𝓝[<] b) ↔ Tendsto (fun x => ↑(f x)) l (𝓝[<] b)
tactic: rw [← comap_coe_Ioo_nhdsWithin_Iio, tendsto_comap_iff]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderTopology α
inst✝ : DenselyOrdered α
a b : α
s : Set α
l : Filter β
f✝ : α → β
f : β → ↑(Ioo a b)
⊢ Tendsto (Subtype.val ∘ f) l (𝓝[<] b) ↔ Tendsto (fun x => ↑(f x)) l (𝓝[<] b)
state_after: no goals
tactic: rfl
Theorem: exists_bounded_mem_Icc_of_closed_of_le
File: Mathlib/Topology/UrysohnsBounded.lean

Proof steps:
state_before: X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : NormalSpace X
s t : Set X
hs : IsClosed s
ht : IsClosed t
hd : Disjoint s t
a b : ℝ
hle : a ≤ b
f : X →ᵇ ℝ
hfs : EqOn (⇑f) 0 s
hft : EqOn (⇑f) 1 t
hf01 : ∀ (x : X), f x ∈ Icc 0 1
x : X
hx : x ∈ s
⊢ (BoundedContinuousFunction.const X a + (b - a) • f) x = Function.const X a x
state_after: no goals
tactic: simp [hfs hx]
state_before: X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : NormalSpace X
s t : Set X
hs : IsClosed s
ht : IsClosed t
hd : Disjoint s t
a b : ℝ
hle : a ≤ b
f : X →ᵇ ℝ
hfs : EqOn (⇑f) 0 s
hft : EqOn (⇑f) 1 t
hf01 : ∀ (x : X), f x ∈ Icc 0 1
x : X
hx : x ∈ t
⊢ (BoundedContinuousFunction.const X a + (b - a) • f) x = Function.const X b x
state_after: no goals
tactic: simp [hft hx]
state_before: X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : NormalSpace X
s t : Set X
hs : IsClosed s
ht : IsClosed t
hd : Disjoint s t
a b : ℝ
hle : a ≤ b
f : X →ᵇ ℝ
hfs : EqOn (⇑f) 0 s
hft : EqOn (⇑f) 1 t
hf01 : ∀ (x : X), f x ∈ Icc 0 1
x : X
⊢ a ≤ (BoundedContinuousFunction.const X a + (b - a) • f) x
state_after: X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : NormalSpace X
s t : Set X
hs : IsClosed s
ht : IsClosed t
hd : Disjoint s t
a b : ℝ
hle : a ≤ b
f : X →ᵇ ℝ
hfs : EqOn (⇑f) 0 s
hft : EqOn (⇑f) 1 t
hf01 : ∀ (x : X), f x ∈ Icc 0 1
x : X
⊢ a ≤ a + (b - a) * f x
tactic: dsimp
state_before: X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : NormalSpace X
s t : Set X
hs : IsClosed s
ht : IsClosed t
hd : Disjoint s t
a b : ℝ
hle : a ≤ b
f : X →ᵇ ℝ
hfs : EqOn (⇑f) 0 s
hft : EqOn (⇑f) 1 t
hf01 : ∀ (x : X), f x ∈ Icc 0 1
x : X
⊢ a ≤ a + (b - a) * f x
state_after: no goals
tactic: nlinarith [(hf01 x).1]
state_before: X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : NormalSpace X
s t : Set X
hs : IsClosed s
ht : IsClosed t
hd : Disjoint s t
a b : ℝ
hle : a ≤ b
f : X →ᵇ ℝ
hfs : EqOn (⇑f) 0 s
hft : EqOn (⇑f) 1 t
hf01 : ∀ (x : X), f x ∈ Icc 0 1
x : X
⊢ (BoundedContinuousFunction.const X a + (b - a) • f) x ≤ b
state_after: X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : NormalSpace X
s t : Set X
hs : IsClosed s
ht : IsClosed t
hd : Disjoint s t
a b : ℝ
hle : a ≤ b
f : X →ᵇ ℝ
hfs : EqOn (⇑f) 0 s
hft : EqOn (⇑f) 1 t
hf01 : ∀ (x : X), f x ∈ Icc 0 1
x : X
⊢ a + (b - a) * f x ≤ b
tactic: dsimp
state_before: X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : NormalSpace X
s t : Set X
hs : IsClosed s
ht : IsClosed t
hd : Disjoint s t
a b : ℝ
hle : a ≤ b
f : X →ᵇ ℝ
hfs : EqOn (⇑f) 0 s
hft : EqOn (⇑f) 1 t
hf01 : ∀ (x : X), f x ∈ Icc 0 1
x : X
⊢ a + (b - a) * f x ≤ b
state_after: no goals
tactic: nlinarith [(hf01 x).2]
Theorem: Polynomial.irreducible_of_mirror
File: Mathlib/Algebra/Polynomial/Mirror.lean

Proof steps:
state_before: R : Type u_1
inst✝¹ : CommRing R
inst✝ : NoZeroDivisors R
f : R[X]
h1 : ¬IsUnit f
h2 : ∀ (k : R[X]), f * f.mirror = k * k.mirror → k = f ∨ k = -f ∨ k = f.mirror ∨ k = -f.mirror
h3 : IsRelPrime f f.mirror
⊢ Irreducible f
state_after: case not_unit
R : Type u_1
inst✝¹ : CommRing R
inst✝ : NoZeroDivisors R
f : R[X]
h1 : ¬IsUnit f
h2 : ∀ (k : R[X]), f * f.mirror = k * k.mirror → k = f ∨ k = -f ∨ k = f.mirror ∨ k = -f.mirror
h3 : IsRelPrime f f.mirror
⊢ ¬IsUnit f

case isUnit_or_isUnit'
R : Type u_1
inst✝¹ : CommRing R
inst✝ : NoZeroDivisors R
f : R[X]
h1 : ¬IsUnit f
h2 : ∀ (k : R[X]), f * f.mirror = k * k.mirror → k = f ∨ k = -f ∨ k = f.mirror ∨ k = -f.mirror
h3 : IsRelPrime f f.mirror
⊢ ∀ (a b : R[X]), f = a * b → IsUnit a ∨ IsUnit b
tactic: constructor
Theorem: Finset.Ioc_subset_Icc_self
File: Mathlib/Order/Interval/Finset/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
inst✝¹ : Preorder α
inst✝ : LocallyFiniteOrder α
a a₁ a₂ b b₁ b₂ c x : α
⊢ Ioc a b ⊆ Icc a b
state_after: ι : Type u_1
α : Type u_2
inst✝¹ : Preorder α
inst✝ : LocallyFiniteOrder α
a a₁ a₂ b b₁ b₂ c x : α
⊢ Set.Ioc a b ⊆ Set.Icc a b
tactic: rw [← coe_subset, coe_Ioc, coe_Icc]
state_before: ι : Type u_1
α : Type u_2
inst✝¹ : Preorder α
inst✝ : LocallyFiniteOrder α
a a₁ a₂ b b₁ b₂ c x : α
⊢ Set.Ioc a b ⊆ Set.Icc a b
state_after: no goals
tactic: exact Set.Ioc_subset_Icc_self
Theorem: MeasureTheory.Memℒp.eLpNorm_mk_lt_top
File: Mathlib/MeasureTheory/Function/LpSpace.lean

Proof steps:
state_before: α✝ : Type u_1
E✝ : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α✝
p✝ : ℝ≥0∞
q : ℝ
μ✝ ν : Measure α✝
inst✝⁴ : NormedAddCommGroup E✝
inst✝³ : NormedAddCommGroup F
inst✝² : NormedAddCommGroup G
α : Type u_5
E : Type u_6
inst✝¹ : MeasurableSpace α
μ : Measure α
inst✝ : NormedAddCommGroup E
p : ℝ≥0∞
f : α → E
hfp : Memℒp f p μ
⊢ eLpNorm (↑(AEEqFun.mk f ⋯)) p μ < ⊤
state_after: no goals
tactic: simp [hfp.2]
Theorem: skewAdjointMatricesLieSubalgebraEquiv_apply
File: Mathlib/Algebra/Lie/SkewAdjoint.lean

Proof steps:
state_before: R : Type u
n : Type w
inst✝² : CommRing R
inst✝¹ : DecidableEq n
inst✝ : Fintype n
J P : Matrix n n R
h : Invertible P
A : ↥(skewAdjointMatricesLieSubalgebra J)
⊢ ↑((skewAdjointMatricesLieSubalgebraEquiv J P h) A) = P⁻¹ * ↑A * P
state_after: no goals
tactic: simp [skewAdjointMatricesLieSubalgebraEquiv]
Theorem: List.prod_replicate
File: Mathlib/Algebra/BigOperators/Group/List.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝² : Monoid M
inst✝¹ : Monoid N
inst✝ : Monoid P
l l₁ l₂ : List M
a✝ : M
n : ℕ
a : M
⊢ (replicate n a).prod = a ^ n
state_after: case zero
ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝² : Monoid M
inst✝¹ : Monoid N
inst✝ : Monoid P
l l₁ l₂ : List M
a✝ a : M
⊢ (replicate 0 a).prod = a ^ 0

case succ
ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝² : Monoid M
inst✝¹ : Monoid N
inst✝ : Monoid P
l l₁ l₂ : List M
a✝ a : M
n : ℕ
ih : (replicate n a).prod = a ^ n
⊢ (replicate (n + 1) a).prod = a ^ (n + 1)
tactic: induction' n with n ih
Theorem: LieAlgebra.Orthogonal.s_as_blocks
File: Mathlib/Algebra/Lie/Classical.lean

Proof steps:
state_before: n : Type u_1
p : Type u_2
q : Type u_3
l : Type u_4
R : Type u₂
inst✝⁶ : DecidableEq n
inst✝⁵ : DecidableEq p
inst✝⁴ : DecidableEq q
inst✝³ : DecidableEq l
inst✝² : CommRing R
inst✝¹ : Fintype p
inst✝ : Fintype q
⊢ S l R = fromBlocks 1 0 0 (-1)
state_after: n : Type u_1
p : Type u_2
q : Type u_3
l : Type u_4
R : Type u₂
inst✝⁶ : DecidableEq n
inst✝⁵ : DecidableEq p
inst✝⁴ : DecidableEq q
inst✝³ : DecidableEq l
inst✝² : CommRing R
inst✝¹ : Fintype p
inst✝ : Fintype q
⊢ S l R = diagonal (Sum.elim (fun x => 1) fun i => -1)
tactic: rw [← Matrix.diagonal_one, Matrix.diagonal_neg, Matrix.fromBlocks_diagonal]
state_before: n : Type u_1
p : Type u_2
q : Type u_3
l : Type u_4
R : Type u₂
inst✝⁶ : DecidableEq n
inst✝⁵ : DecidableEq p
inst✝⁴ : DecidableEq q
inst✝³ : DecidableEq l
inst✝² : CommRing R
inst✝¹ : Fintype p
inst✝ : Fintype q
⊢ S l R = diagonal (Sum.elim (fun x => 1) fun i => -1)
state_after: no goals
tactic: rfl
Theorem: Submodule.apply_mem_map₂
File: Mathlib/Algebra/Module/Submodule/Bilinear.lean

Proof steps:
state_before: ι : Sort uι
R : Type u_1
M : Type u_2
N : Type u_3
P : Type u_4
inst✝⁶ : CommSemiring R
inst✝⁵ : AddCommMonoid M
inst✝⁴ : AddCommMonoid N
inst✝³ : AddCommMonoid P
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R P
f : M →ₗ[R] N →ₗ[R] P
m : M
n : N
p : Submodule R M
q : Submodule R N
hm : m ∈ p
hn : n ∈ q
⊢ (f ↑⟨m, hm⟩) n = (f m) n
state_after: no goals
tactic: rfl
Theorem: Set.preimage_neg_Icc
File: Mathlib/Data/Set/Pointwise/Interval.lean

Proof steps:
state_before: α : Type u_1
inst✝ : OrderedAddCommGroup α
a b c : α
⊢ -Icc a b = Icc (-b) (-a)
state_after: no goals
tactic: simp [← Ici_inter_Iic, inter_comm]
Theorem: LightProfinite.proj_surjective
File: Mathlib/Topology/Category/LightProfinite/AsLimit.lean

Proof steps:
state_before: S : LightProfinite
n : ℕ
⊢ Function.Surjective ⇑(S.proj n)
state_after: S : LightProfinite
n : ℕ
⊢ Function.Surjective ⇑(lightToProfinite.map (S.proj n))
tactic: change Function.Surjective (lightToProfinite.map (S.proj n))
state_before: S : LightProfinite
n : ℕ
⊢ Function.Surjective ⇑(lightToProfinite.map (S.proj n))
state_after: S : LightProfinite
n : ℕ
⊢ Function.Surjective
    ⇑((lightToProfinite.obj S).asLimitCone.π.app
        ((sequentialFunctor (DiscreteQuotient ↑(lightToProfinite.obj S).toTop)).obj (Opposite.op n)))
tactic: rw [lightToProfinite_map_proj_eq]
state_before: S : LightProfinite
n : ℕ
⊢ Function.Surjective
    ⇑((lightToProfinite.obj S).asLimitCone.π.app
        ((sequentialFunctor (DiscreteQuotient ↑(lightToProfinite.obj S).toTop)).obj (Opposite.op n)))
state_after: no goals
tactic: exact DiscreteQuotient.proj_surjective _
Theorem: iSup_inf_eq
File: Mathlib/Order/CompleteBooleanAlgebra.lean

Proof steps:
state_before: α : Type u
β : Type v
ι : Sort w
κ : ι → Sort w'
inst✝ : Frame α
s t : Set α
a✝ b : α
f : ι → α
a : α
⊢ (⨆ i, f i) ⊓ a = ⨆ i, f i ⊓ a
state_after: no goals
tactic: rw [iSup, sSup_inf_eq, iSup_range]
Theorem: Rack.self_act_eq_iff_eq
File: Mathlib/Algebra/Quandle.lean

Proof steps:
state_before: R : Type u_1
inst✝ : Rack R
x y : R
⊢ x ◃ x = y ◃ y ↔ x = y
state_after: case mp
R : Type u_1
inst✝ : Rack R
x y : R
⊢ x ◃ x = y ◃ y → x = y

case mpr
R : Type u_1
inst✝ : Rack R
x y : R
⊢ x = y → x ◃ x = y ◃ y
tactic: constructor
state_before: case mp
R : Type u_1
inst✝ : Rack R
x y : R
⊢ x ◃ x = y ◃ y → x = y

case mpr
R : Type u_1
inst✝ : Rack R
x y : R
⊢ x = y → x ◃ x = y ◃ y
state_after: case mpr
R : Type u_1
inst✝ : Rack R
x y : R
⊢ x = y → x ◃ x = y ◃ y

case mp
R : Type u_1
inst✝ : Rack R
x y : R
⊢ x ◃ x = y ◃ y → x = y
tactic: swap
state_before: case mp
R : Type u_1
inst✝ : Rack R
x y : R
⊢ x ◃ x = y ◃ y → x = y
state_after: case mp
R : Type u_1
inst✝ : Rack R
x y : R
h : x ◃ x = y ◃ y
⊢ x = y
tactic: intro h
state_before: case mp
R : Type u_1
inst✝ : Rack R
x y : R
h : x ◃ x = y ◃ y
⊢ x = y
state_after: R : Type u_1
inst✝ : Rack R
x y : R
h : x ◃ x = y ◃ y
⊢ x = (x ◃ x) ◃⁻¹ x ◃ x

R : Type u_1
inst✝ : Rack R
x y : R
h : x ◃ x = y ◃ y
⊢ (x ◃ x) ◃⁻¹ x ◃ x = y
tactic: trans (x ◃ x) ◃⁻¹ x ◃ x