ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Affine.Simplex.face_eq_mkOfPoint
File: Mathlib/LinearAlgebra/AffineSpace/Independent.lean

Proof steps:
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
n : ℕ
s : Simplex k P n
i : Fin (n + 1)
⊢ s.face ⋯ = mkOfPoint k (s.points i)
state_after: case h
k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
n : ℕ
s : Simplex k P n
i : Fin (n + 1)
i✝ : Fin (0 + 1)
⊢ (s.face ⋯).points i✝ = (mkOfPoint k (s.points i)).points i✝
tactic: ext
state_before: case h
k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
n : ℕ
s : Simplex k P n
i : Fin (n + 1)
i✝ : Fin (0 + 1)
⊢ (s.face ⋯).points i✝ = (mkOfPoint k (s.points i)).points i✝
state_after: case h
k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
n : ℕ
s : Simplex k P n
i : Fin (n + 1)
i✝ : Fin (0 + 1)
⊢ s.points (({i}.orderEmbOfFin ⋯) i✝) = s.points i
tactic: simp only [Affine.Simplex.mkOfPoint_points, Affine.Simplex.face_points]
state_before: case h
k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
n : ℕ
s : Simplex k P n
i : Fin (n + 1)
i✝ : Fin (0 + 1)
⊢ s.points (({i}.orderEmbOfFin ⋯) i✝) = s.points i
state_after: no goals
tactic: rw [Finset.orderEmbOfFin_singleton]
Theorem: CategoryTheory.Cat.leftUnitor_inv_app
File: Mathlib/CategoryTheory/Category/Cat.lean

Proof steps:
state_before: B C : Cat
F : B ⟶ C
X : ↑B
⊢ F.obj X = (𝟙 B ≫ F).obj X
state_after: no goals
tactic: simp
Theorem: Int.even_add_one
File: Mathlib/Algebra/Group/Int.lean

Proof steps:
state_before: u v m n : ℤ
⊢ Even (n + 1) ↔ ¬Even n
state_after: no goals
tactic: simp [even_add]
Theorem: Real.exp_bound_div_one_sub_of_interval'
File: Mathlib/Data/Complex/Exponential.lean

Proof steps:
state_before: x : ℝ
h1 : 0 < x
h2 : x < 1
⊢ rexp x < 1 / (1 - x)
state_after: x : ℝ
h1 : 0 < x
h2 : x < 1
H : 0 < 1 - (1 + x + x ^ 2) * (1 - x)
⊢ rexp x < 1 / (1 - x)
tactic: have H : 0 < 1 - (1 + x + x ^ 2) * (1 - x) := calc
    0 < x ^ 3 := by positivity
    _ = 1 - (1 + x + x ^ 2) * (1 - x) := by ring
state_before: x : ℝ
h1 : 0 < x
h2 : x < 1
H : 0 < 1 - (1 + x + x ^ 2) * (1 - x)
⊢ rexp x < 1 / (1 - x)
state_after: no goals
tactic: calc
    exp x ≤ _ := exp_bound' h1.le h2.le zero_lt_three
    _ ≤ 1 + x + x ^ 2 := by
      -- Porting note: was `norm_num [Finset.sum] <;> nlinarith`
      -- This proof should be restored after the norm_num plugin for big operators is ported.
      -- (It may also need the positivity extensions in #3907.)
      repeat erw [Finset.sum_range_succ]
      norm_num [Nat.factorial]
      nlinarith
    _ < 1 / (1 - x) := by rw [lt_div_iff] <;> nlinarith
Theorem: CategoryTheory.Limits.pullbackDiagonalMapIso_inv_snd_snd
File: Mathlib/CategoryTheory/Limits/Shapes/Diagonal.lean

Proof steps:
state_before: C : Type u_1
inst✝² : Category.{u_2, u_1} C
X Y Z : C
inst✝¹ : HasPullbacks C
U V₁ V₂ : C
f : X ⟶ Y
i : U ⟶ Y
i₁ : V₁ ⟶ pullback f i
i₂ : V₂ ⟶ pullback f i
inst✝ : HasPullback i₁ i₂
⊢ (pullbackDiagonalMapIso f i i₁ i₂).inv ≫
      snd (diagonal f) (map (i₁ ≫ snd f i) (i₂ ≫ snd f i) f f (i₁ ≫ fst f i) (i₂ ≫ fst f i) i ⋯ ⋯) ≫
        snd (i₁ ≫ snd f i) (i₂ ≫ snd f i) =
    snd i₁ i₂
state_after: C : Type u_1
inst✝² : Category.{u_2, u_1} C
X Y Z : C
inst✝¹ : HasPullbacks C
U V₁ V₂ : C
f : X ⟶ Y
i : U ⟶ Y
i₁ : V₁ ⟶ pullback f i
i₂ : V₂ ⟶ pullback f i
inst✝ : HasPullback i₁ i₂
⊢ {
          hom :=
            lift
              (snd (diagonal f) (map (i₁ ≫ snd f i) (i₂ ≫ snd f i) f f (i₁ ≫ fst f i) (i₂ ≫ fst f i) i ⋯ ⋯) ≫
                fst (i₁ ≫ snd f i) (i₂ ≫ snd f i))
              (snd (diagonal f) (map (i₁ ≫ snd f i) (i₂ ≫ snd f i) f f (i₁ ≫ fst f i) (i₂ ≫ fst f i) i ⋯ ⋯) ≫
                snd (i₁ ≫ snd f i) (i₂ ≫ snd f i))
              ⋯,
          inv :=
            lift (fst i₁ i₂ ≫ i₁ ≫ fst f i) (map i₁ i₂ (i₁ ≫ snd f i) (i₂ ≫ snd f i) (𝟙 V₁) (𝟙 V₂) (snd f i) ⋯ ⋯) ⋯,
          hom_inv_id := ⋯, inv_hom_id := ⋯ }.inv ≫
      snd (diagonal f) (map (i₁ ≫ snd f i) (i₂ ≫ snd f i) f f (i₁ ≫ fst f i) (i₂ ≫ fst f i) i ⋯ ⋯) ≫
        snd (i₁ ≫ snd f i) (i₂ ≫ snd f i) =
    snd i₁ i₂
tactic: delta pullbackDiagonalMapIso
state_before: C : Type u_1
inst✝² : Category.{u_2, u_1} C
X Y Z : C
inst✝¹ : HasPullbacks C
U V₁ V₂ : C
f : X ⟶ Y
i : U ⟶ Y
i₁ : V₁ ⟶ pullback f i
i₂ : V₂ ⟶ pullback f i
inst✝ : HasPullback i₁ i₂
⊢ {
          hom :=
            lift
              (snd (diagonal f) (map (i₁ ≫ snd f i) (i₂ ≫ snd f i) f f (i₁ ≫ fst f i) (i₂ ≫ fst f i) i ⋯ ⋯) ≫
                fst (i₁ ≫ snd f i) (i₂ ≫ snd f i))
              (snd (diagonal f) (map (i₁ ≫ snd f i) (i₂ ≫ snd f i) f f (i₁ ≫ fst f i) (i₂ ≫ fst f i) i ⋯ ⋯) ≫
                snd (i₁ ≫ snd f i) (i₂ ≫ snd f i))
              ⋯,
          inv :=
            lift (fst i₁ i₂ ≫ i₁ ≫ fst f i) (map i₁ i₂ (i₁ ≫ snd f i) (i₂ ≫ snd f i) (𝟙 V₁) (𝟙 V₂) (snd f i) ⋯ ⋯) ⋯,
          hom_inv_id := ⋯, inv_hom_id := ⋯ }.inv ≫
      snd (diagonal f) (map (i₁ ≫ snd f i) (i₂ ≫ snd f i) f f (i₁ ≫ fst f i) (i₂ ≫ fst f i) i ⋯ ⋯) ≫
        snd (i₁ ≫ snd f i) (i₂ ≫ snd f i) =
    snd i₁ i₂
state_after: no goals
tactic: simp
Theorem: Ordinal.lsub_lt_ord_lift
File: Mathlib/SetTheory/Cardinal/Cofinality.lean

Proof steps:
state_before: α : Type u_1
r : α → α → Prop
ι : Type u
f : ι → Ordinal.{max u v}
c : Ordinal.{max u v}
hι : Cardinal.lift.{v, u} #ι < c.cof
hf : ∀ (i : ι), f i < c
h : lsub f = c
⊢ False
state_after: α : Type u_1
r : α → α → Prop
ι : Type u
f : ι → Ordinal.{max u v}
hι : Cardinal.lift.{v, u} #ι < (lsub f).cof
hf : ∀ (i : ι), f i < lsub f
⊢ False
tactic: subst h
state_before: α : Type u_1
r : α → α → Prop
ι : Type u
f : ι → Ordinal.{max u v}
hι : Cardinal.lift.{v, u} #ι < (lsub f).cof
hf : ∀ (i : ι), f i < lsub f
⊢ False
state_after: no goals
tactic: exact (cof_lsub_le_lift.{u, v} f).not_lt hι
Theorem: MeasureTheory.Lp.simpleFunc.toLp_sub
File: Mathlib/MeasureTheory/Function/SimpleFuncDenseLp.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
E : Type u_4
F : Type u_5
𝕜 : Type u_6
inst✝² : MeasurableSpace α
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedAddCommGroup F
p : ℝ≥0∞
μ : Measure α
f g : α →ₛ E
hf : Memℒp (↑f) p μ
hg : Memℒp (↑g) p μ
⊢ toLp (f - g) ⋯ = toLp f hf - toLp g hg
state_after: no goals
tactic: simp only [sub_eq_add_neg, ← toLp_neg, ← toLp_add]
Theorem: AddSubgroup.Normal.map
File: Mathlib/Algebra/Group/Subgroup/Basic.lean

Proof steps:
state_before: G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝⁴ : Group G
inst✝³ : Group G'
inst✝² : Group G''
A : Type u_4
inst✝¹ : AddGroup A
N : Type u_5
inst✝ : Group N
H✝ H : Subgroup G
h : H.Normal
f : G →* N
hf : Surjective ⇑f
⊢ (Subgroup.map f H).Normal
state_after: G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝⁴ : Group G
inst✝³ : Group G'
inst✝² : Group G''
A : Type u_4
inst✝¹ : AddGroup A
N : Type u_5
inst✝ : Group N
H✝ H : Subgroup G
h : H.Normal
f : G →* N
hf : Surjective ⇑f
⊢ Subgroup.map f H.normalizer ≤ (Subgroup.map f H).normalizer
tactic: rw [← normalizer_eq_top, ← top_le_iff, ← f.range_top_of_surjective hf, f.range_eq_map, ←
    normalizer_eq_top.2 h]
state_before: G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝⁴ : Group G
inst✝³ : Group G'
inst✝² : Group G''
A : Type u_4
inst✝¹ : AddGroup A
N : Type u_5
inst✝ : Group N
H✝ H : Subgroup G
h : H.Normal
f : G →* N
hf : Surjective ⇑f
⊢ Subgroup.map f H.normalizer ≤ (Subgroup.map f H).normalizer
state_after: no goals
tactic: exact le_normalizer_map _
Theorem: indicator_le_thickenedIndicatorAux
File: Mathlib/Topology/MetricSpace/ThickenedIndicator.lean

Proof steps:
state_before: α : Type u_1
inst✝ : PseudoEMetricSpace α
δ : ℝ
E : Set α
⊢ (E.indicator fun x => 1) ≤ thickenedIndicatorAux δ E
state_after: α : Type u_1
inst✝ : PseudoEMetricSpace α
δ : ℝ
E : Set α
a : α
⊢ E.indicator (fun x => 1) a ≤ thickenedIndicatorAux δ E a
tactic: intro a
state_before: α : Type u_1
inst✝ : PseudoEMetricSpace α
δ : ℝ
E : Set α
a : α
⊢ E.indicator (fun x => 1) a ≤ thickenedIndicatorAux δ E a
state_after: case pos
α : Type u_1
inst✝ : PseudoEMetricSpace α
δ : ℝ
E : Set α
a : α
h : a ∈ E
⊢ E.indicator (fun x => 1) a ≤ thickenedIndicatorAux δ E a

case neg
α : Type u_1
inst✝ : PseudoEMetricSpace α
δ : ℝ
E : Set α
a : α
h : a ∉ E
⊢ E.indicator (fun x => 1) a ≤ thickenedIndicatorAux δ E a
tactic: by_cases h : a ∈ E
Theorem: CategoryTheory.Limits.mono_of_source_iso_zero
File: Mathlib/CategoryTheory/Limits/Shapes/ZeroMorphisms.lean

Proof steps:
state_before: C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasZeroObject C
inst✝ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
i : X ≅ 0
Z : C
g h : Z ⟶ X
x✝ : g ≫ f = h ≫ f
⊢ g = h
state_after: no goals
tactic: rw [zero_of_target_iso_zero g i, zero_of_target_iso_zero h i]
Theorem: Matrix.diagonal_mul_diagonal
File: Mathlib/Data/Matrix/Basic.lean

Proof steps:
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝² : NonUnitalNonAssocSemiring α
inst✝¹ : Fintype n
inst✝ : DecidableEq n
d₁ d₂ : n → α
⊢ diagonal d₁ * diagonal d₂ = diagonal fun i => d₁ i * d₂ i
state_after: case a
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝² : NonUnitalNonAssocSemiring α
inst✝¹ : Fintype n
inst✝ : DecidableEq n
d₁ d₂ : n → α
i j : n
⊢ (diagonal d₁ * diagonal d₂) i j = diagonal (fun i => d₁ i * d₂ i) i j
tactic: ext i j
state_before: case a
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝² : NonUnitalNonAssocSemiring α
inst✝¹ : Fintype n
inst✝ : DecidableEq n
d₁ d₂ : n → α
i j : n
⊢ (diagonal d₁ * diagonal d₂) i j = diagonal (fun i => d₁ i * d₂ i) i j
state_after: no goals
tactic: by_cases h : i = j <;>
  simp [h]
Theorem: AddSubgroup.ker_saturated
File: Mathlib/GroupTheory/Subgroup/Saturated.lean

Proof steps:
state_before: A₁ : Type u_1
A₂ : Type u_2
inst✝² : AddCommGroup A₁
inst✝¹ : AddCommGroup A₂
inst✝ : NoZeroSMulDivisors ℕ A₂
f : A₁ →+ A₂
⊢ f.ker.Saturated
state_after: A₁ : Type u_1
A₂ : Type u_2
inst✝² : AddCommGroup A₁
inst✝¹ : AddCommGroup A₂
inst✝ : NoZeroSMulDivisors ℕ A₂
f : A₁ →+ A₂
n : ℕ
g : A₁
hg : n • g ∈ f.ker
⊢ n = 0 ∨ g ∈ f.ker
tactic: intro n g hg
state_before: A₁ : Type u_1
A₂ : Type u_2
inst✝² : AddCommGroup A₁
inst✝¹ : AddCommGroup A₂
inst✝ : NoZeroSMulDivisors ℕ A₂
f : A₁ →+ A₂
n : ℕ
g : A₁
hg : n • g ∈ f.ker
⊢ n = 0 ∨ g ∈ f.ker
state_after: no goals
tactic: simpa only [f.mem_ker, nsmul_eq_smul, f.map_nsmul, smul_eq_zero] using hg
Theorem: CategoryTheory.Limits.imageMonoIsoSource_inv_ι
File: Mathlib/CategoryTheory/Limits/Shapes/Images.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
X Y : C
f : X ⟶ Y
inst✝ : Mono f
⊢ (imageMonoIsoSource f).inv ≫ image.ι f = f
state_after: no goals
tactic: simp [imageMonoIsoSource]
Theorem: CauSeq.neg_equiv_neg
File: Mathlib/Algebra/Order/CauSeq/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝² : LinearOrderedField α
inst✝¹ : Ring β
abv : β → α
inst✝ : IsAbsoluteValue abv
f g : CauSeq β abv
hf : f ≈ g
⊢ -f ≈ -g
state_after: no goals
tactic: simpa only [neg_sub'] using neg_limZero hf
Theorem: MeasurableEmbedding.integrableAtFilter_map_iff
File: Mathlib/MeasureTheory/Integral/IntegrableOn.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝² : MeasurableSpace α
inst✝¹ : NormedAddCommGroup E
f✝ g : α → E
s t : Set α
μ ν : Measure α
l l' : Filter α
inst✝ : MeasurableSpace β
e : α → β
he : MeasurableEmbedding e
f : β → E
⊢ IntegrableAtFilter f (map e l) (Measure.map e μ) ↔ IntegrableAtFilter (f ∘ e) l μ
state_after: α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝² : MeasurableSpace α
inst✝¹ : NormedAddCommGroup E
f✝ g : α → E
s t : Set α
μ ν : Measure α
l l' : Filter α
inst✝ : MeasurableSpace β
e : α → β
he : MeasurableEmbedding e
f : β → E
⊢ (∃ s ∈ map e l, IntegrableOn (f ∘ e) (e ⁻¹' s) μ) ↔ ∃ s ∈ l, IntegrableOn (f ∘ e) s μ
tactic: simp_rw [IntegrableAtFilter, he.integrableOn_map_iff]
state_before: α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝² : MeasurableSpace α
inst✝¹ : NormedAddCommGroup E
f✝ g : α → E
s t : Set α
μ ν : Measure α
l l' : Filter α
inst✝ : MeasurableSpace β
e : α → β
he : MeasurableEmbedding e
f : β → E
⊢ (∃ s ∈ map e l, IntegrableOn (f ∘ e) (e ⁻¹' s) μ) ↔ ∃ s ∈ l, IntegrableOn (f ∘ e) s μ
state_after: case mp.intro
α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝² : MeasurableSpace α
inst✝¹ : NormedAddCommGroup E
f✝ g : α → E
s✝ t : Set α
μ ν : Measure α
l l' : Filter α
inst✝ : MeasurableSpace β
e : α → β
he : MeasurableEmbedding e
f : β → E
s : Set β
hs : s ∈ map e l ∧ IntegrableOn (f ∘ e) (e ⁻¹' s) μ
⊢ ∃ s ∈ l, IntegrableOn (f ∘ e) s μ

case mpr.intro
α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝² : MeasurableSpace α
inst✝¹ : NormedAddCommGroup E
f✝ g : α → E
s✝ t : Set α
μ ν : Measure α
l l' : Filter α
inst✝ : MeasurableSpace β
e : α → β
he : MeasurableEmbedding e
f : β → E
s : Set α
hs : s ∈ l ∧ IntegrableOn (f ∘ e) s μ
⊢ ∃ s ∈ map e l, IntegrableOn (f ∘ e) (e ⁻¹' s) μ
tactic: constructor <;> rintro ⟨s, hs⟩
Theorem: Nat.coprime_iff_isRelPrime
File: Mathlib/Data/Nat/GCD/Basic.lean

Proof steps:
state_before: m n : ℕ
⊢ m.Coprime n ↔ IsRelPrime m n
state_after: m n : ℕ
⊢ m.gcd n = 1 ↔ ∀ ⦃d : ℕ⦄, d ∣ m.gcd n → d ∣ 1
tactic: simp_rw [coprime_iff_gcd_eq_one, IsRelPrime, ← and_imp, ← dvd_gcd_iff, isUnit_iff_dvd_one]
Theorem: Polynomial.natDegree_prod_le
File: Mathlib/Algebra/Polynomial/BigOperators.lean

Proof steps:
state_before: R : Type u
ι : Type w
s : Finset ι
inst✝ : CommSemiring R
f : ι → R[X]
t : Multiset R[X]
⊢ (∏ i ∈ s, f i).natDegree ≤ ∑ i ∈ s, (f i).natDegree
state_after: no goals
tactic: simpa using natDegree_multiset_prod_le (s.1.map f)
Theorem: Nonneg.toNonneg_of_nonneg
File: Mathlib/Algebra/Order/Ring/Unbundled/Nonneg.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : Zero α
inst✝ : LinearOrder α
a : α
h : 0 ≤ a
⊢ toNonneg a = ⟨a, h⟩
state_after: no goals
tactic: simp [toNonneg, h]
Theorem: Submodule.noZeroSMulDivisors_iff_torsion_eq_bot
File: Mathlib/Algebra/Module/Torsion.lean

Proof steps:
state_before: R : Type u_1
M : Type u_2
inst✝⁴ : CommSemiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : NoZeroDivisors R
inst✝ : Nontrivial R
⊢ NoZeroSMulDivisors R M ↔ torsion R M = ⊥
state_after: case mp
R : Type u_1
M : Type u_2
inst✝⁴ : CommSemiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : NoZeroDivisors R
inst✝ : Nontrivial R
h : NoZeroSMulDivisors R M
⊢ torsion R M = ⊥

case mpr
R : Type u_1
M : Type u_2
inst✝⁴ : CommSemiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : NoZeroDivisors R
inst✝ : Nontrivial R
h : torsion R M = ⊥
⊢ NoZeroSMulDivisors R M
tactic: constructor <;> intro h
Theorem: CstarRing.conjugate_le_norm_smul
File: Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/Order.lean

Proof steps:
state_before: A : Type u_1
inst✝⁹ : NonUnitalNormedRing A
inst✝⁸ : CompleteSpace A
inst✝⁷ : PartialOrder A
inst✝⁶ : StarRing A
inst✝⁵ : StarOrderedRing A
inst✝⁴ : CstarRing A
inst✝³ : NormedSpace ℂ A
inst✝² : StarModule ℂ A
inst✝¹ : SMulCommClass ℂ A A
inst✝ : IsScalarTower ℂ A A
a b : A
hb : autoParam (IsSelfAdjoint b) _auto✝
⊢ star a * b * a ≤ ‖b‖ • (star a * a)
state_after: A : Type u_1
inst✝⁹ : NonUnitalNormedRing A
inst✝⁸ : CompleteSpace A
inst✝⁷ : PartialOrder A
inst✝⁶ : StarRing A
inst✝⁵ : StarOrderedRing A
inst✝⁴ : CstarRing A
inst✝³ : NormedSpace ℂ A
inst✝² : StarModule ℂ A
inst✝¹ : SMulCommClass ℂ A A
inst✝ : IsScalarTower ℂ A A
a b : A
hb : autoParam (IsSelfAdjoint b) _auto✝
⊢ ∀ (a b : Unitization ℂ A), IsSelfAdjoint b → star a * b * a ≤ ‖b‖ • (star a * a)
tactic: suffices ∀ a b : Unitization ℂ A, IsSelfAdjoint b → star a * b * a ≤ ‖b‖ • (star a * a) by
    rw [← Unitization.inr_le_iff _ _ (by aesop) ((IsSelfAdjoint.all _).smul (.star_mul_self a))]
    simpa [Unitization.norm_inr] using this a b <| hb.inr ℂ
state_before: A : Type u_1
inst✝⁹ : NonUnitalNormedRing A
inst✝⁸ : CompleteSpace A
inst✝⁷ : PartialOrder A
inst✝⁶ : StarRing A
inst✝⁵ : StarOrderedRing A
inst✝⁴ : CstarRing A
inst✝³ : NormedSpace ℂ A
inst✝² : StarModule ℂ A
inst✝¹ : SMulCommClass ℂ A A
inst✝ : IsScalarTower ℂ A A
a b : A
hb : autoParam (IsSelfAdjoint b) _auto✝
⊢ ∀ (a b : Unitization ℂ A), IsSelfAdjoint b → star a * b * a ≤ ‖b‖ • (star a * a)
state_after: A : Type u_1
inst✝⁹ : NonUnitalNormedRing A
inst✝⁸ : CompleteSpace A
inst✝⁷ : PartialOrder A
inst✝⁶ : StarRing A
inst✝⁵ : StarOrderedRing A
inst✝⁴ : CstarRing A
inst✝³ : NormedSpace ℂ A
inst✝² : StarModule ℂ A
inst✝¹ : SMulCommClass ℂ A A
inst✝ : IsScalarTower ℂ A A
a✝ b✝ : A
hb✝ : autoParam (IsSelfAdjoint b✝) _auto✝
a b : Unitization ℂ A
hb : IsSelfAdjoint b
⊢ star a * b * a ≤ ‖b‖ • (star a * a)
tactic: intro a b hb
state_before: A : Type u_1
inst✝⁹ : NonUnitalNormedRing A
inst✝⁸ : CompleteSpace A
inst✝⁷ : PartialOrder A
inst✝⁶ : StarRing A
inst✝⁵ : StarOrderedRing A
inst✝⁴ : CstarRing A
inst✝³ : NormedSpace ℂ A
inst✝² : StarModule ℂ A
inst✝¹ : SMulCommClass ℂ A A
inst✝ : IsScalarTower ℂ A A
a✝ b✝ : A
hb✝ : autoParam (IsSelfAdjoint b✝) _auto✝
a b : Unitization ℂ A
hb : IsSelfAdjoint b
⊢ star a * b * a ≤ ‖b‖ • (star a * a)
state_after: no goals
tactic: calc
    star a * b * a ≤ star a * (algebraMap ℝ (Unitization ℂ A) ‖b‖) * a :=
      conjugate_le_conjugate hb.le_algebraMap_norm_self _
    _ = ‖b‖ • (star a * a) := by simp [Algebra.algebraMap_eq_smul_one]
Theorem: Matrix.transpose_col
File: Mathlib/Data/Matrix/RowCol.lean

Proof steps:
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
R : Type u_5
α : Type v
β : Type w
ι : Type u_6
v : m → α
⊢ (col ι v)ᵀ = row ι v
state_after: case a
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
R : Type u_5
α : Type v
β : Type w
ι : Type u_6
v : m → α
i✝ : ι
j✝ : m
⊢ (col ι v)ᵀ i✝ j✝ = row ι v i✝ j✝
tactic: ext
state_before: case a
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
R : Type u_5
α : Type v
β : Type w
ι : Type u_6
v : m → α
i✝ : ι
j✝ : m
⊢ (col ι v)ᵀ i✝ j✝ = row ι v i✝ j✝
state_after: no goals
tactic: rfl
Theorem: SimpleGraph.Walk.support_append
File: Mathlib/Combinatorics/SimpleGraph/Walk.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 w : V
p : G.Walk u v
p' : G.Walk v w
⊢ (p.append p').support = p.support ++ p'.support.tail
state_after: no goals
tactic: induction p <;> cases p' <;> simp [*]
Theorem: IsDedekindDomain.HeightOneSpectrum.intValuation_ne_zero
File: Mathlib/RingTheory/DedekindDomain/AdicValuation.lean

Proof steps:
state_before: R : Type u_1
inst✝⁴ : CommRing R
inst✝³ : IsDedekindDomain R
K : Type u_2
inst✝² : Field K
inst✝¹ : Algebra R K
inst✝ : IsFractionRing R K
v : HeightOneSpectrum R
x : R
hx : x ≠ 0
⊢ v.intValuationDef x ≠ 0
state_after: R : Type u_1
inst✝⁴ : CommRing R
inst✝³ : IsDedekindDomain R
K : Type u_2
inst✝² : Field K
inst✝¹ : Algebra R K
inst✝ : IsFractionRing R K
v : HeightOneSpectrum R
x : R
hx : x ≠ 0
⊢ ↑(ofAdd (-↑((Associates.mk v.asIdeal).count (Associates.mk (Ideal.span {x})).factors))) ≠ 0
tactic: rw [intValuationDef, if_neg hx]
state_before: R : Type u_1
inst✝⁴ : CommRing R
inst✝³ : IsDedekindDomain R
K : Type u_2
inst✝² : Field K
inst✝¹ : Algebra R K
inst✝ : IsFractionRing R K
v : HeightOneSpectrum R
x : R
hx : x ≠ 0
⊢ ↑(ofAdd (-↑((Associates.mk v.asIdeal).count (Associates.mk (Ideal.span {x})).factors))) ≠ 0
state_after: no goals
tactic: exact WithZero.coe_ne_zero
Theorem: MeasureTheory.Measure.sum_bool
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Type u_5
R : Type u_6
R' : Type u_7
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
f✝ : α → β
f : Bool → Measure α
⊢ sum f = f true + f false
state_after: no goals
tactic: rw [sum_fintype, Fintype.sum_bool]
Theorem: Matrix.natCast_fin_three
File: Mathlib/Data/Matrix/Notation.lean

Proof steps:
state_before: α : Type u
o n✝ m : ℕ
m' : Type uₘ
n' : Type uₙ
o' : Type uₒ
a b : ℕ
inst✝ : AddMonoidWithOne α
n : ℕ
⊢ ↑n = !![↑n, 0, 0; 0, ↑n, 0; 0, 0, ↑n]
state_after: case a
α : Type u
o n✝ m : ℕ
m' : Type uₘ
n' : Type uₙ
o' : Type uₒ
a b : ℕ
inst✝ : AddMonoidWithOne α
n : ℕ
i j : Fin 3
⊢ ↑n i j = !![↑n, 0, 0; 0, ↑n, 0; 0, 0, ↑n] i j
tactic: ext i j
state_before: case a
α : Type u
o n✝ m : ℕ
m' : Type uₘ
n' : Type uₙ
o' : Type uₒ
a b : ℕ
inst✝ : AddMonoidWithOne α
n : ℕ
i j : Fin 3
⊢ ↑n i j = !![↑n, 0, 0; 0, ↑n, 0; 0, 0, ↑n] i j
state_after: no goals
tactic: fin_cases i <;> fin_cases j <;> rfl
Theorem: contDiffOn_top_iff_deriv_of_isOpen
File: Mathlib/Analysis/Calculus/ContDiff/Basic.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
b : E × F → G
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
f₂ : 𝕜 → F
s₂ : Set 𝕜
hs : IsOpen s₂
⊢ ContDiffOn 𝕜 ⊤ f₂ s₂ ↔ DifferentiableOn 𝕜 f₂ s₂ ∧ ContDiffOn 𝕜 ⊤ (deriv f₂) s₂
state_after: 𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
b : E × F → G
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
f₂ : 𝕜 → F
s₂ : Set 𝕜
hs : IsOpen s₂
⊢ DifferentiableOn 𝕜 f₂ s₂ ∧ ContDiffOn 𝕜 ⊤ (derivWithin f₂ s₂) s₂ ↔
    DifferentiableOn 𝕜 f₂ s₂ ∧ ContDiffOn 𝕜 ⊤ (deriv f₂) s₂
tactic: rw [contDiffOn_top_iff_derivWithin hs.uniqueDiffOn]
state_before: 𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
b : E × F → G
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
f₂ : 𝕜 → F
s₂ : Set 𝕜
hs : IsOpen s₂
⊢ DifferentiableOn 𝕜 f₂ s₂ ∧ ContDiffOn 𝕜 ⊤ (derivWithin f₂ s₂) s₂ ↔
    DifferentiableOn 𝕜 f₂ s₂ ∧ ContDiffOn 𝕜 ⊤ (deriv f₂) s₂
state_after: no goals
tactic: exact Iff.rfl.and <| contDiffOn_congr fun _ => derivWithin_of_isOpen hs
Theorem: antitone_iff_apply₂
File: Mathlib/Order/Monotone/Basic.lean

Proof steps:
state_before: ι✝ : Type u_1
α✝ : Type u
β✝ : Type v
γ : Type w
δ : Type u_2
π : ι✝ → Type u_3
r : α✝ → α✝ → Prop
ι : Type u_4
α : Type u_5
β : ι → Type u_6
inst✝¹ : (i : ι) → Preorder (β i)
inst✝ : Preorder α
f : α → (i : ι) → β i
⊢ Antitone f ↔ ∀ (i : ι), Antitone fun x => f x i
state_after: no goals
tactic: simp [Antitone, Pi.le_def, @forall_swap ι]