ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: ConvexOn.translate_left
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✝³ : OrderedAddCommMonoid α
inst✝² : OrderedAddCommMonoid β
inst✝¹ : Module 𝕜 E
inst✝ : SMul 𝕜 β
s : Set E
f : E → β
hf : ConvexOn 𝕜 s f
c : E
⊢ ConvexOn 𝕜 ((fun z => c + z) ⁻¹' s) (f ∘ fun z => z + c)
state_after: no goals
tactic: simpa only [add_comm c] using hf.translate_right c
Theorem: ProbabilityTheory.cgf_zero_fun
File: Mathlib/Probability/Moments.lean

Proof steps:
state_before: Ω : Type u_1
ι : Type u_2
m : MeasurableSpace Ω
X : Ω → ℝ
p : ℕ
μ : Measure Ω
t : ℝ
⊢ cgf 0 μ t = log (μ Set.univ).toReal
state_after: no goals
tactic: simp only [cgf, mgf_zero_fun]
Theorem: div_le_div_right₀
File: Mathlib/Algebra/Order/GroupWithZero/Canonical.lean

Proof steps:
state_before: α : Type u_1
inst✝ : LinearOrderedCommGroupWithZero α
a b c d : α
m n : ℕ
hc : c ≠ 0
⊢ a / c ≤ b / c ↔ a ≤ b
state_after: no goals
tactic: rw [div_eq_mul_inv, div_eq_mul_inv, mul_le_mul_right₀ (inv_ne_zero hc)]
Theorem: LinearMap.proj_comp_stdBasis
File: Mathlib/LinearAlgebra/StdBasis.lean

Proof steps:
state_before: R : Type u_1
ι : Type u_2
inst✝³ : Semiring R
φ : ι → Type u_3
inst✝² : (i : ι) → AddCommMonoid (φ i)
inst✝¹ : (i : ι) → Module R (φ i)
inst✝ : DecidableEq ι
i j : ι
⊢ proj i ∘ₗ stdBasis R φ j = diag j i
state_after: no goals
tactic: rw [stdBasis_eq_pi_diag, proj_pi]
Theorem: Set.unbounded_lt_inter_not_lt
File: Mathlib/Order/Bounded.lean

Proof steps:
state_before: α : Type u_1
r : α → α → Prop
s t : Set α
inst✝ : SemilatticeSup α
a : α
⊢ Unbounded (fun x x_1 => x < x_1) (s ∩ {b | ¬b < a}) ↔ Unbounded (fun x x_1 => x < x_1) s
state_after: α : Type u_1
r : α → α → Prop
s t : Set α
inst✝ : SemilatticeSup α
a : α
⊢ Bounded (fun x x_1 => x < x_1) (s ∩ {b | ¬b < a}) ↔ Bounded (fun x x_1 => x < x_1) s
tactic: rw [← not_bounded_iff, ← not_bounded_iff, not_iff_not]
state_before: α : Type u_1
r : α → α → Prop
s t : Set α
inst✝ : SemilatticeSup α
a : α
⊢ Bounded (fun x x_1 => x < x_1) (s ∩ {b | ¬b < a}) ↔ Bounded (fun x x_1 => x < x_1) s
state_after: no goals
tactic: exact bounded_lt_inter_not_lt a
Theorem: SetTheory.PGame.bddBelow_range_of_small
File: Mathlib/SetTheory/Game/PGame.lean

Proof steps:
state_before: xl xr : Type u
ι : Type u_1
inst✝ : Small.{u, u_1} ι
f : ι → PGame
⊢ BddBelow (Set.range f)
state_after: xl xr : Type u
ι : Type u_1
inst✝ : Small.{u, u_1} ι
f : ι → PGame
x : PGame :=
  mk PEmpty.{u + 1} ((i : Shrink.{u, u_1} ι) × (f ((equivShrink ι).symm i)).RightMoves) PEmpty.elim fun x =>
    (f ((equivShrink ι).symm x.fst)).moveRight x.snd
⊢ BddBelow (Set.range f)
tactic: let x : PGame.{u} := ⟨PEmpty, Σ i, (f $ (equivShrink.{u} ι).symm i).RightMoves, PEmpty.elim,
    fun x ↦ moveRight _ x.2⟩
state_before: xl xr : Type u
ι : Type u_1
inst✝ : Small.{u, u_1} ι
f : ι → PGame
x : PGame :=
  mk PEmpty.{u + 1} ((i : Shrink.{u, u_1} ι) × (f ((equivShrink ι).symm i)).RightMoves) PEmpty.elim fun x =>
    (f ((equivShrink ι).symm x.fst)).moveRight x.snd
⊢ BddBelow (Set.range f)
state_after: xl xr : Type u
ι : Type u_1
inst✝ : Small.{u, u_1} ι
f : ι → PGame
x : PGame :=
  mk PEmpty.{u + 1} ((i : Shrink.{u, u_1} ι) × (f ((equivShrink ι).symm i)).RightMoves) PEmpty.elim fun x =>
    (f ((equivShrink ι).symm x.fst)).moveRight x.snd
i : ι
⊢ x ≤ f i
tactic: refine ⟨x, Set.forall_mem_range.2 fun i ↦ ?_⟩
state_before: xl xr : Type u
ι : Type u_1
inst✝ : Small.{u, u_1} ι
f : ι → PGame
x : PGame :=
  mk PEmpty.{u + 1} ((i : Shrink.{u, u_1} ι) × (f ((equivShrink ι).symm i)).RightMoves) PEmpty.elim fun x =>
    (f ((equivShrink ι).symm x.fst)).moveRight x.snd
i : ι
⊢ x ≤ f i
state_after: xl xr : Type u
ι : Type u_1
inst✝ : Small.{u, u_1} ι
f : ι → PGame
x : PGame :=
  mk PEmpty.{u + 1} ((i : Shrink.{u, u_1} ι) × (f ((equivShrink ι).symm i)).RightMoves) PEmpty.elim fun x =>
    (f ((equivShrink ι).symm x.fst)).moveRight x.snd
i : ι
⊢ (∀ (i_1 : x.LeftMoves), x.moveLeft i_1 ⧏ f ((equivShrink ι).symm ((equivShrink ι) i))) ∧
    ∀ (j : (f ((equivShrink ι).symm ((equivShrink ι) i))).RightMoves),
      x ⧏ (f ((equivShrink ι).symm ((equivShrink ι) i))).moveRight j
tactic: rw [← (equivShrink ι).symm_apply_apply i, le_iff_forall_lf]
state_before: xl xr : Type u
ι : Type u_1
inst✝ : Small.{u, u_1} ι
f : ι → PGame
x : PGame :=
  mk PEmpty.{u + 1} ((i : Shrink.{u, u_1} ι) × (f ((equivShrink ι).symm i)).RightMoves) PEmpty.elim fun x =>
    (f ((equivShrink ι).symm x.fst)).moveRight x.snd
i : ι
⊢ (∀ (i_1 : x.LeftMoves), x.moveLeft i_1 ⧏ f ((equivShrink ι).symm ((equivShrink ι) i))) ∧
    ∀ (j : (f ((equivShrink ι).symm ((equivShrink ι) i))).RightMoves),
      x ⧏ (f ((equivShrink ι).symm ((equivShrink ι) i))).moveRight j
state_after: no goals
tactic: simpa [x] using fun j ↦ @lf_moveRight x ⟨equivShrink ι i, j⟩
Theorem: Frm.Iso.mk_inv_toFun
File: Mathlib/Order/Category/Frm.lean

Proof steps:
state_before: α β : Frm
e : ↑α ≃o ↑β
⊢ { toFun := ⇑e, map_inf' := ⋯, map_top' := ⋯, map_sSup' := ⋯ } ≫
      { toFun := ⇑e.symm, map_inf' := ⋯, map_top' := ⋯, map_sSup' := ⋯ } =
    𝟙 α
state_after: case w
α β : Frm
e : ↑α ≃o ↑β
x✝ : (forget Frm).obj α
⊢ ({ toFun := ⇑e, map_inf' := ⋯, map_top' := ⋯, map_sSup' := ⋯ } ≫
        { toFun := ⇑e.symm, map_inf' := ⋯, map_top' := ⋯, map_sSup' := ⋯ })
      x✝ =
    (𝟙 α) x✝
tactic: ext
state_before: case w
α β : Frm
e : ↑α ≃o ↑β
x✝ : (forget Frm).obj α
⊢ ({ toFun := ⇑e, map_inf' := ⋯, map_top' := ⋯, map_sSup' := ⋯ } ≫
        { toFun := ⇑e.symm, map_inf' := ⋯, map_top' := ⋯, map_sSup' := ⋯ })
      x✝ =
    (𝟙 α) x✝
state_after: no goals
tactic: exact e.symm_apply_apply _
state_before: α β : Frm
e : ↑α ≃o ↑β
⊢ { toFun := ⇑e.symm, map_inf' := ⋯, map_top' := ⋯, map_sSup' := ⋯ } ≫
      { toFun := ⇑e, map_inf' := ⋯, map_top' := ⋯, map_sSup' := ⋯ } =
    𝟙 β
state_after: case w
α β : Frm
e : ↑α ≃o ↑β
x✝ : (forget Frm).obj β
⊢ ({ toFun := ⇑e.symm, map_inf' := ⋯, map_top' := ⋯, map_sSup' := ⋯ } ≫
        { toFun := ⇑e, map_inf' := ⋯, map_top' := ⋯, map_sSup' := ⋯ })
      x✝ =
    (𝟙 β) x✝
tactic: ext
state_before: case w
α β : Frm
e : ↑α ≃o ↑β
x✝ : (forget Frm).obj β
⊢ ({ toFun := ⇑e.symm, map_inf' := ⋯, map_top' := ⋯, map_sSup' := ⋯ } ≫
        { toFun := ⇑e, map_inf' := ⋯, map_top' := ⋯, map_sSup' := ⋯ })
      x✝ =
    (𝟙 β) x✝
state_after: no goals
tactic: exact e.apply_symm_apply _
Theorem: iInf_univ
File: Mathlib/Order/CompleteLattice.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
β₂ : Type u_3
γ : Type u_4
ι : Sort u_5
ι' : Sort u_6
κ : ι → Sort u_7
κ' : ι' → Sort u_8
inst✝ : CompleteLattice α
f✝ g s t : ι → α
a b : α
f : β → α
⊢ ⨅ x ∈ univ, f x = ⨅ x, f x
state_after: no goals
tactic: simp
Theorem: partialSups_eq_sup'_range
File: Mathlib/Order/PartialSups.lean

Proof steps:
state_before: α : Type u_1
inst✝ : SemilatticeSup α
f : ℕ → α
n : ℕ
x✝ : α
⊢ (partialSups f) n ≤ x✝ ↔ (Finset.range (n + 1)).sup' ⋯ f ≤ x✝
state_after: no goals
tactic: simp [Nat.lt_succ_iff]
Theorem: Batteries.RBNode.Ordered.alter
File: .lake/packages/batteries/Batteries/Data/RBMap/Alter.lean

Proof steps:
state_before: α : Type u_1
cut : α → Ordering
f : Option α → Option α
cmp : α → α → Ordering
t : RBNode α
H :
  ∀ {x : α} {t' : RBNode α} {p : Path α},
    RBNode.zoom cut t = (t', p) → f t'.root? = some x → Path.RootOrdered cmp p x ∧ OnRoot (cmpEq cmp x) t'
h : Ordered cmp t
⊢ Ordered cmp (alter cut f t)
state_after: α : Type u_1
cut : α → Ordering
f : Option α → Option α
cmp : α → α → Ordering
t : RBNode α
H :
  ∀ {x : α} {t' : RBNode α} {p : Path α},
    RBNode.zoom cut t = (t', p) → f t'.root? = some x → Path.RootOrdered cmp p x ∧ OnRoot (cmpEq cmp x) t'
h : Ordered cmp t
⊢ Ordered cmp
    (match RBNode.zoom cut t with
    | (nil, path) =>
      match f none with
      | none => t
      | some y => path.insertNew y
    | (node c a x b, path) =>
      match f (some x) with
      | none => path.del (a.append b) c
      | some y => path.fill (node c a y b))
tactic: simp [alter]
state_before: α : Type u_1
cut : α → Ordering
f : Option α → Option α
cmp : α → α → Ordering
t : RBNode α
H :
  ∀ {x : α} {t' : RBNode α} {p : Path α},
    RBNode.zoom cut t = (t', p) → f t'.root? = some x → Path.RootOrdered cmp p x ∧ OnRoot (cmpEq cmp x) t'
h : Ordered cmp t
⊢ Ordered cmp
    (match RBNode.zoom cut t with
    | (nil, path) =>
      match f none with
      | none => t
      | some y => path.insertNew y
    | (node c a x b, path) =>
      match f (some x) with
      | none => path.del (a.append b) c
      | some y => path.fill (node c a y b))
state_after: case h_1
α : Type u_1
cut : α → Ordering
f : Option α → Option α
cmp : α → α → Ordering
t : RBNode α
H :
  ∀ {x : α} {t' : RBNode α} {p : Path α},
    RBNode.zoom cut t = (t', p) → f t'.root? = some x → Path.RootOrdered cmp p x ∧ OnRoot (cmpEq cmp x) t'
h : Ordered cmp t
x✝ : RBNode α × Path α
snd✝ : Path α
heq✝ : RBNode.zoom cut t = (nil, snd✝)
⊢ Ordered cmp
    (match f none with
    | none => t
    | some y => snd✝.insertNew y)

case h_2
α : Type u_1
cut : α → Ordering
f : Option α → Option α
cmp : α → α → Ordering
t : RBNode α
H :
  ∀ {x : α} {t' : RBNode α} {p : Path α},
    RBNode.zoom cut t = (t', p) → f t'.root? = some x → Path.RootOrdered cmp p x ∧ OnRoot (cmpEq cmp x) t'
h : Ordered cmp t
x✝¹ : RBNode α × Path α
c✝ : RBColor
a✝ : RBNode α
x✝ : α
b✝ : RBNode α
path✝ : Path α
heq✝ : RBNode.zoom cut t = (node c✝ a✝ x✝ b✝, path✝)
⊢ Ordered cmp
    (match f (some x✝) with
    | none => path✝.del (a✝.append b✝) c✝
    | some y => path✝.fill (node c✝ a✝ y b✝))
tactic: split
Theorem: MeasureTheory.IsStoppingTime.measurableSet_eq_of_countable_range'
File: Mathlib/Probability/Process/Stopping.lean

Proof steps:
state_before: Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝ : LinearOrder ι
f : Filtration ι m
τ π : Ω → ι
hτ : IsStoppingTime f τ
h_countable : (Set.range τ).Countable
i : ι
⊢ MeasurableSet {ω | τ ω = i}
state_after: Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝ : LinearOrder ι
f : Filtration ι m
τ π : Ω → ι
hτ : IsStoppingTime f τ
h_countable : (Set.range τ).Countable
i : ι
⊢ MeasurableSet (Set.univ ∩ {ω | τ ω = i})
tactic: ← Set.univ_inter {ω | τ ω = i},
state_before: Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝ : LinearOrder ι
f : Filtration ι m
τ π : Ω → ι
hτ : IsStoppingTime f τ
h_countable : (Set.range τ).Countable
i : ι
⊢ MeasurableSet (Set.univ ∩ {ω | τ ω = i})
state_after: Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝ : LinearOrder ι
f : Filtration ι m
τ π : Ω → ι
hτ : IsStoppingTime f τ
h_countable : (Set.range τ).Countable
i : ι
⊢ MeasurableSet {ω | τ ω = i}
tactic: Set.univ_inter
state_before: Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝ : LinearOrder ι
f : Filtration ι m
τ π : Ω → ι
hτ : IsStoppingTime f τ
h_countable : (Set.range τ).Countable
i : ι
⊢ MeasurableSet {ω | τ ω = i}
state_after: no goals
tactic: exact hτ.measurableSet_eq_of_countable_range h_countable i
Theorem: MeasureTheory.OuterMeasure.le_boundedBy'
File: Mathlib/MeasureTheory/OuterMeasure/OfFunction.lean

Proof steps:
state_before: α : Type u_1
m : Set α → ℝ≥0∞
μ : OuterMeasure α
⊢ μ ≤ boundedBy m ↔ ∀ (s : Set α), s.Nonempty → μ s ≤ m s
state_after: α : Type u_1
m : Set α → ℝ≥0∞
μ : OuterMeasure α
⊢ ∀ (a : Set α), μ a ≤ m a ↔ a.Nonempty → μ a ≤ m a
tactic: rw [le_boundedBy, forall_congr']
state_before: α : Type u_1
m : Set α → ℝ≥0∞
μ : OuterMeasure α
⊢ ∀ (a : Set α), μ a ≤ m a ↔ a.Nonempty → μ a ≤ m a
state_after: α : Type u_1
m : Set α → ℝ≥0∞
μ : OuterMeasure α
s : Set α
⊢ μ s ≤ m s ↔ s.Nonempty → μ s ≤ m s
tactic: intro s
state_before: α : Type u_1
m : Set α → ℝ≥0∞
μ : OuterMeasure α
s : Set α
⊢ μ s ≤ m s ↔ s.Nonempty → μ s ≤ m s
state_after: no goals
tactic: rcases s.eq_empty_or_nonempty with h | h <;> simp [h]
Theorem: MeasureTheory.StronglyMeasurable.add_iff_right
File: Mathlib/MeasureTheory/Function/StronglyMeasurable/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
inst✝³ : Countable ι
f g : α → β
mα : MeasurableSpace α
inst✝² : TopologicalSpace β
inst✝¹ : CommGroup β
inst✝ : TopologicalGroup β
hf : StronglyMeasurable f
h : StronglyMeasurable (f * g)
⊢ g = f * g * f⁻¹
state_after: no goals
tactic: simp only [mul_inv_cancel_comm]
Theorem: MeasureTheory.Measure.map_of_not_aemeasurable
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 : α → β
μ : Measure α
hf : ¬AEMeasurable f μ
⊢ map f μ = 0
state_after: no goals
tactic: simp [map, hf]
Theorem: AffineSubspace.mem_perpBisector_iff_dist_eq'
File: Mathlib/Geometry/Euclidean/PerpBisector.lean

Proof steps:
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
c c₁ c₂ p₁ p₂ : P
⊢ c ∈ perpBisector p₁ p₂ ↔ dist p₁ c = dist p₂ c
state_after: no goals
tactic: simp only [mem_perpBisector_iff_dist_eq, dist_comm]
Theorem: MonoidHom.FixedPointFree.odd_card_of_involutive
File: Mathlib/GroupTheory/FixedPointFree.lean

Proof steps:
state_before: G : Type u_1
inst✝¹ : Group G
φ : G →* G
inst✝ : Finite G
hφ : FixedPointFree ⇑φ
h2 : Function.Involutive ⇑φ
⊢ Odd (Nat.card G)
state_after: G : Type u_1
inst✝¹ : Group G
φ : G →* G
inst✝ : Finite G
hφ : FixedPointFree ⇑φ
h2 : Function.Involutive ⇑φ
this : Fintype G
⊢ Odd (Nat.card G)
tactic: have := Fintype.ofFinite G
state_before: G : Type u_1
inst✝¹ : Group G
φ : G →* G
inst✝ : Finite G
hφ : FixedPointFree ⇑φ
h2 : Function.Involutive ⇑φ
this : Fintype G
⊢ Odd (Nat.card G)
state_after: G : Type u_1
inst✝¹ : Group G
φ : G →* G
inst✝ : Finite G
hφ : FixedPointFree ⇑φ
h2 : Function.Involutive ⇑φ
this : Fintype G
h : ¬Odd (Nat.card G)
⊢ False
tactic: by_contra h
state_before: G : Type u_1
inst✝¹ : Group G
φ : G →* G
inst✝ : Finite G
hφ : FixedPointFree ⇑φ
h2 : Function.Involutive ⇑φ
this : Fintype G
h : ¬Odd (Nat.card G)
⊢ False
state_after: G : Type u_1
inst✝¹ : Group G
φ : G →* G
inst✝ : Finite G
hφ : FixedPointFree ⇑φ
h2 : Function.Involutive ⇑φ
this : Fintype G
h : 2 ∣ Fintype.card G
⊢ False
tactic: rw [← Nat.even_iff_not_odd, even_iff_two_dvd, Nat.card_eq_fintype_card] at h
state_before: G : Type u_1
inst✝¹ : Group G
φ : G →* G
inst✝ : Finite G
hφ : FixedPointFree ⇑φ
h2 : Function.Involutive ⇑φ
this : Fintype G
h : 2 ∣ Fintype.card G
⊢ False
state_after: case intro
G : Type u_1
inst✝¹ : Group G
φ : G →* G
inst✝ : Finite G
hφ : FixedPointFree ⇑φ
h2 : Function.Involutive ⇑φ
this : Fintype G
h : 2 ∣ Fintype.card G
g : G
hg : orderOf g = 2
⊢ False
tactic: obtain ⟨g, hg⟩ := exists_prime_orderOf_dvd_card 2 h
state_before: case intro
G : Type u_1
inst✝¹ : Group G
φ : G →* G
inst✝ : Finite G
hφ : FixedPointFree ⇑φ
h2 : Function.Involutive ⇑φ
this : Fintype G
h : 2 ∣ Fintype.card G
g : G
hg : orderOf g = 2
⊢ False
state_after: no goals
tactic: exact hφ.orderOf_ne_two_of_involutive h2 g hg
Theorem: MultilinearMap.piLinearMap_apply_apply_apply
File: Mathlib/LinearAlgebra/Multilinear/Basic.lean

Proof steps:
state_before: R : Type uR
S : Type uS
ι : Type uι
n : ℕ
M : Fin n.succ → Type v
M₁ : ι → Type v₁
M₂ : Type v₂
M₃ : Type v₃
M' : Type v'
inst✝⁸ : CommSemiring R
inst✝⁷ : (i : ι) → AddCommMonoid (M₁ i)
inst✝⁶ : (i : Fin n.succ) → AddCommMonoid (M i)
inst✝⁵ : AddCommMonoid M₂
inst✝⁴ : (i : Fin n.succ) → Module R (M i)
inst✝³ : (i : ι) → Module R (M₁ i)
inst✝² : Module R M₂
f f' : MultilinearMap R M₁ M₂
M₁' : ι → Type u_1
inst✝¹ : (i : ι) → AddCommMonoid (M₁' i)
inst✝ : (i : ι) → Module R (M₁' i)
⊢ ∀ (x y : MultilinearMap R M₁' M₂),
    (fun g => (LinearMap.applyₗ g).compMultilinearMap compLinearMapMultilinear) (x + y) =
      (fun g => (LinearMap.applyₗ g).compMultilinearMap compLinearMapMultilinear) x +
        (fun g => (LinearMap.applyₗ g).compMultilinearMap compLinearMapMultilinear) y
state_after: no goals
tactic: aesop
state_before: R : Type uR
S : Type uS
ι : Type uι
n : ℕ
M : Fin n.succ → Type v
M₁ : ι → Type v₁
M₂ : Type v₂
M₃ : Type v₃
M' : Type v'
inst✝⁸ : CommSemiring R
inst✝⁷ : (i : ι) → AddCommMonoid (M₁ i)
inst✝⁶ : (i : Fin n.succ) → AddCommMonoid (M i)
inst✝⁵ : AddCommMonoid M₂
inst✝⁴ : (i : Fin n.succ) → Module R (M i)
inst✝³ : (i : ι) → Module R (M₁ i)
inst✝² : Module R M₂
f f' : MultilinearMap R M₁ M₂
M₁' : ι → Type u_1
inst✝¹ : (i : ι) → AddCommMonoid (M₁' i)
inst✝ : (i : ι) → Module R (M₁' i)
⊢ ∀ (m : R) (x : MultilinearMap R M₁' M₂),
    { toFun := fun g => (LinearMap.applyₗ g).compMultilinearMap compLinearMapMultilinear, map_add' := ⋯ }.toFun
        (m • x) =
      (RingHom.id R) m •
        { toFun := fun g => (LinearMap.applyₗ g).compMultilinearMap compLinearMapMultilinear, map_add' := ⋯ }.toFun x
state_after: no goals
tactic: aesop
Theorem: BoundedContinuousFunction.norm_coe_le_norm
File: Mathlib/Topology/ContinuousFunction/Bounded.lean

Proof steps:
state_before: F : Type u_1
α : Type u
β : Type v
γ : Type w
inst✝¹ : TopologicalSpace α
inst✝ : SeminormedAddCommGroup β
f g : α →ᵇ β
x✝ : α
C : ℝ
x : α
⊢ ‖f x‖ = dist (f x) (0 x)
state_after: no goals
tactic: simp [dist_zero_right]
Theorem: Asymptotics.IsLittleO.tendsto_inv_smul_nhds_zero
File: Mathlib/Analysis/Asymptotics/Asymptotics.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
G : Type u_5
E' : Type u_6
F' : Type u_7
G' : Type u_8
E'' : Type u_9
F'' : Type u_10
G'' : Type u_11
E''' : Type u_12
R : Type u_13
R' : Type u_14
𝕜 : Type u_15
𝕜' : Type u_16
inst✝¹⁵ : Norm E
inst✝¹⁴ : Norm F
inst✝¹³ : Norm G
inst✝¹² : SeminormedAddCommGroup E'
inst✝¹¹ : SeminormedAddCommGroup F'
inst✝¹⁰ : SeminormedAddCommGroup G'
inst✝⁹ : NormedAddCommGroup E''
inst✝⁸ : NormedAddCommGroup F''
inst✝⁷ : NormedAddCommGroup G''
inst✝⁶ : SeminormedRing R
inst✝⁵ : SeminormedAddGroup E'''
inst✝⁴ : SeminormedRing R'
inst✝³ : NormedDivisionRing 𝕜
inst✝² : NormedDivisionRing 𝕜'
c c' c₁ c₂ : ℝ
f✝ : α → E
g✝ : α → F
k : α → G
f' : α → E'
g' : α → F'
k' : α → G'
f'' : α → E''
g'' : α → F''
k'' : α → G''
l✝ l' : Filter α
inst✝¹ : Module 𝕜 E'
inst✝ : BoundedSMul 𝕜 E'
f : α → E'
g : α → 𝕜
l : Filter α
h : f =o[l] g
⊢ Tendsto (fun x => (g x)⁻¹ • f x) l (𝓝 0)
state_after: no goals
tactic: simpa only [div_eq_inv_mul, ← norm_inv, ← norm_smul, ← tendsto_zero_iff_norm_tendsto_zero] using
    h.norm_norm.tendsto_div_nhds_zero
Theorem: RingQuot.eqvGen_rel_eq
File: Mathlib/Algebra/RingQuot.lean

Proof steps:
state_before: R : Type uR
inst✝³ : Semiring R
S : Type uS
inst✝² : CommSemiring S
T : Type uT
A : Type uA
inst✝¹ : Semiring A
inst✝ : Algebra S A
r : R → R → Prop
⊢ EqvGen (Rel r) = RingConGen.Rel r
state_after: case h.h.a
R : Type uR
inst✝³ : Semiring R
S : Type uS
inst✝² : CommSemiring S
T : Type uT
A : Type uA
inst✝¹ : Semiring A
inst✝ : Algebra S A
r : R → R → Prop
x₁ x₂ : R
⊢ EqvGen (Rel r) x₁ x₂ ↔ RingConGen.Rel r x₁ x₂
tactic: ext x₁ x₂
state_before: case h.h.a
R : Type uR
inst✝³ : Semiring R
S : Type uS
inst✝² : CommSemiring S
T : Type uT
A : Type uA
inst✝¹ : Semiring A
inst✝ : Algebra S A
r : R → R → Prop
x₁ x₂ : R
⊢ EqvGen (Rel r) x₁ x₂ ↔ RingConGen.Rel r x₁ x₂
state_after: case h.h.a.mp
R : Type uR
inst✝³ : Semiring R
S : Type uS
inst✝² : CommSemiring S
T : Type uT
A : Type uA
inst✝¹ : Semiring A
inst✝ : Algebra S A
r : R → R → Prop
x₁ x₂ : R
⊢ EqvGen (Rel r) x₁ x₂ → RingConGen.Rel r x₁ x₂

case h.h.a.mpr
R : Type uR
inst✝³ : Semiring R
S : Type uS
inst✝² : CommSemiring S
T : Type uT
A : Type uA
inst✝¹ : Semiring A
inst✝ : Algebra S A
r : R → R → Prop
x₁ x₂ : R
⊢ RingConGen.Rel r x₁ x₂ → EqvGen (Rel r) x₁ x₂
tactic: constructor
Theorem: NonUnitalStarAlgHom.ext_continuousMap
File: Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/NonUnital.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
p : A → Prop
inst✝¹³ : CommSemiring R
inst✝¹² : Nontrivial R
inst✝¹¹ : StarRing R
inst✝¹⁰ : MetricSpace R
inst✝⁹ : TopologicalSemiring R
inst✝⁸ : ContinuousStar R
inst✝⁷ : NonUnitalRing A
inst✝⁶ : StarRing A
inst✝⁵ : TopologicalSpace A
inst✝⁴ : Module R A
inst✝³ : IsScalarTower R A A
inst✝² : SMulCommClass R A A
inst✝¹ : NonUnitalContinuousFunctionalCalculus R p
inst✝ : UniqueNonUnitalContinuousFunctionalCalculus R A
a : A
φ ψ : C(↑(σₙ R a), R)₀ →⋆ₙₐ[R] A
hφ : Continuous ⇑φ
hψ : Continuous ⇑ψ
h :
  φ { toContinuousMap := ContinuousMap.restrict (σₙ R a) (ContinuousMap.id R), map_zero' := ⋯ } =
    ψ { toContinuousMap := ContinuousMap.restrict (σₙ R a) (ContinuousMap.id R), map_zero' := ⋯ }
this : CompactSpace ↑(σₙ R a)
⊢ ↑0 = 0
state_after: no goals
tactic: simp
Theorem: tsub_le_iff_left
File: Mathlib/Algebra/Order/Sub/Defs.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝³ : Preorder α
inst✝² : AddCommSemigroup α
inst✝¹ : Sub α
inst✝ : OrderedSub α
a b c d : α
⊢ a - b ≤ c ↔ a ≤ b + c
state_after: no goals
tactic: rw [tsub_le_iff_right, add_comm]
Theorem: Matrix.tail_transpose
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 : ℕ
A : Matrix m' (Fin n.succ) α
⊢ vecTail (of.symm Aᵀ) = (vecTail ∘ A)ᵀ
state_after: case h.h
α : Type u
o n m : ℕ
m' : Type uₘ
n' : Type uₙ
o' : Type uₒ
a b : ℕ
A : Matrix m' (Fin n.succ) α
i : Fin n
j : m'
⊢ vecTail (of.symm Aᵀ) i j = (vecTail ∘ A)ᵀ i j
tactic: ext i j
state_before: case h.h
α : Type u
o n m : ℕ
m' : Type uₘ
n' : Type uₙ
o' : Type uₒ
a b : ℕ
A : Matrix m' (Fin n.succ) α
i : Fin n
j : m'
⊢ vecTail (of.symm Aᵀ) i j = (vecTail ∘ A)ᵀ i j
state_after: no goals
tactic: rfl
Theorem: _private.Mathlib.Combinatorics.SetFamily.CauchyDavenport.0.wellFoundedOn_devosAddRel
File: Mathlib/Combinatorics/SetFamily/CauchyDavenport.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : Group α
inst✝ : DecidableEq α
x y : Finset α × Finset α
s t : Finset α
⊢ {x | x.1.Nonempty ∧ x.2.Nonempty}.WellFoundedOn DevosMulRel
state_after: α : Type u_1
inst✝¹ : Group α
inst✝ : DecidableEq α
x y : Finset α × Finset α
s t : Finset α
n : ℕ
⊢ ({x | x.1.Nonempty ∧ x.2.Nonempty} ∩ (fun x => (x.1 * x.2).card) ⁻¹' {n}).WellFoundedOn
    ((fun x x_1 => x > x_1) on fun x => x.1.card + x.2.card)
tactic: refine wellFounded_lt.onFun.wellFoundedOn.prod_lex_of_wellFoundedOn_fiber fun n ↦
    Set.WellFoundedOn.prod_lex_of_wellFoundedOn_fiber ?_ fun n ↦
      wellFounded_lt.onFun.wellFoundedOn
state_before: α : Type u_1
inst✝¹ : Group α
inst✝ : DecidableEq α
x y : Finset α × Finset α
s t : Finset α
n : ℕ
⊢ ({x | x.1.Nonempty ∧ x.2.Nonempty} ∩ (fun x => (x.1 * x.2).card) ⁻¹' {n}).WellFoundedOn
    ((fun x x_1 => x > x_1) on fun x => x.1.card + x.2.card)
state_after: no goals
tactic: exact wellFounded_lt.onFun.wellFoundedOn.mono' fun x hx y _ ↦ tsub_lt_tsub_left_of_le <|
    add_le_add ((card_le_card_mul_right _ hx.1.2).trans_eq hx.2) <|
      (card_le_card_mul_left _ hx.1.1).trans_eq hx.2