ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: covBy_iff_Ioo_eq
File: Mathlib/Order/Cover.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝¹ : Preorder α
inst✝ : Preorder β
a b c : α
⊢ (∀ ⦃c : α⦄, a < c → ¬c < b) ↔ Ioo a b = ∅
state_after: no goals
tactic: simp [eq_empty_iff_forall_not_mem]
Theorem: BoxIntegral.Box.subbox_induction_on
File: Mathlib/Analysis/BoxIntegral/Partition/SubboxInduction.lean

Proof steps:
state_before: ι : Type u_1
inst✝ : Fintype ι
I✝ J : Box ι
p : Box ι → Prop
I : Box ι
H_ind : ∀ J ≤ I, (∀ J' ∈ splitCenter J, p J') → p J
H_nhds :
  ∀ z ∈ Box.Icc I,
    ∃ U ∈ 𝓝[Box.Icc I] z,
      ∀ J ≤ I,
        ∀ (m : ℕ),
          z ∈ Box.Icc J → Box.Icc J ⊆ U → (∀ (i : ι), J.upper i - J.lower i = (I.upper i - I.lower i) / 2 ^ m) → p J
⊢ p I
state_after: ι : Type u_1
inst✝ : Fintype ι
I✝ J✝ : Box ι
p : Box ι → Prop
I : Box ι
H_ind : ∀ J ≤ I, (∀ J' ∈ splitCenter J, p J') → p J
H_nhds :
  ∀ z ∈ Box.Icc I,
    ∃ U ∈ 𝓝[Box.Icc I] z,
      ∀ J ≤ I,
        ∀ (m : ℕ),
          z ∈ Box.Icc J → Box.Icc J ⊆ U → (∀ (i : ι), J.upper i - J.lower i = (I.upper i - I.lower i) / 2 ^ m) → p J
J : Box ι
hle : J ≤ I
hs : ∀ (s : Set ι), p (J.splitCenterBox s)
J' : Box ι
h' : J' ∈ splitCenter J
⊢ p J'
tactic: refine subbox_induction_on' I (fun J hle hs => H_ind J hle fun J' h' => ?_) H_nhds
state_before: ι : Type u_1
inst✝ : Fintype ι
I✝ J✝ : Box ι
p : Box ι → Prop
I : Box ι
H_ind : ∀ J ≤ I, (∀ J' ∈ splitCenter J, p J') → p J
H_nhds :
  ∀ z ∈ Box.Icc I,
    ∃ U ∈ 𝓝[Box.Icc I] z,
      ∀ J ≤ I,
        ∀ (m : ℕ),
          z ∈ Box.Icc J → Box.Icc J ⊆ U → (∀ (i : ι), J.upper i - J.lower i = (I.upper i - I.lower i) / 2 ^ m) → p J
J : Box ι
hle : J ≤ I
hs : ∀ (s : Set ι), p (J.splitCenterBox s)
J' : Box ι
h' : J' ∈ splitCenter J
⊢ p J'
state_after: case intro
ι : Type u_1
inst✝ : Fintype ι
I✝ J✝ : Box ι
p : Box ι → Prop
I : Box ι
H_ind : ∀ J ≤ I, (∀ J' ∈ splitCenter J, p J') → p J
H_nhds :
  ∀ z ∈ Box.Icc I,
    ∃ U ∈ 𝓝[Box.Icc I] z,
      ∀ J ≤ I,
        ∀ (m : ℕ),
          z ∈ Box.Icc J → Box.Icc J ⊆ U → (∀ (i : ι), J.upper i - J.lower i = (I.upper i - I.lower i) / 2 ^ m) → p J
J : Box ι
hle : J ≤ I
hs : ∀ (s : Set ι), p (J.splitCenterBox s)
s : Set ι
h' : J.splitCenterBox s ∈ splitCenter J
⊢ p (J.splitCenterBox s)
tactic: rcases mem_splitCenter.1 h' with ⟨s, rfl⟩
state_before: case intro
ι : Type u_1
inst✝ : Fintype ι
I✝ J✝ : Box ι
p : Box ι → Prop
I : Box ι
H_ind : ∀ J ≤ I, (∀ J' ∈ splitCenter J, p J') → p J
H_nhds :
  ∀ z ∈ Box.Icc I,
    ∃ U ∈ 𝓝[Box.Icc I] z,
      ∀ J ≤ I,
        ∀ (m : ℕ),
          z ∈ Box.Icc J → Box.Icc J ⊆ U → (∀ (i : ι), J.upper i - J.lower i = (I.upper i - I.lower i) / 2 ^ m) → p J
J : Box ι
hle : J ≤ I
hs : ∀ (s : Set ι), p (J.splitCenterBox s)
s : Set ι
h' : J.splitCenterBox s ∈ splitCenter J
⊢ p (J.splitCenterBox s)
state_after: no goals
tactic: exact hs s
Theorem: Metric.closedEmbedding_of_pairwise_le_dist
File: Mathlib/Topology/MetricSpace/Basic.lean

Proof steps:
state_before: α✝ : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝³ : PseudoMetricSpace α✝
γ : Type w
inst✝² : MetricSpace γ
x : γ
s : Set γ
α : Type u_3
inst✝¹ : TopologicalSpace α
inst✝ : DiscreteTopology α
ε : ℝ
hε : 0 < ε
f : α → γ
hf : Pairwise fun x y => ε ≤ dist (f x) (f y)
⊢ Pairwise fun x y => (f x, f y) ∉ {p | dist p.1 p.2 < ε}
state_after: no goals
tactic: simpa using hf
Theorem: SimpleGraph.Walk.reverseAux_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 x : V
p : G.Walk u v
q : G.Walk u w
r : G.Walk w x
⊢ (p.reverseAux q).append r = p.reverseAux (q.append r)
state_after: no goals
tactic: induction p with
  | nil => rfl
  | cons h _ ih => simp [ih (cons (G.symm h) q)]
Theorem: Orthonormal.inner_products_summable
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
ι : Type u_4
x : E
v : ι → E
hv : Orthonormal 𝕜 v
⊢ Summable fun i => ‖⟪v i, x⟫_𝕜‖ ^ 2
state_after: case h
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
ι : Type u_4
x : E
v : ι → E
hv : Orthonormal 𝕜 v
⊢ HasSum (fun i => ‖⟪v i, x⟫_𝕜‖ ^ 2) (⨆ s, ∑ i ∈ s, ‖⟪v i, x⟫_𝕜‖ ^ 2)
tactic: use ⨆ s : Finset ι, ∑ i ∈ s, ‖⟪v i, x⟫‖ ^ 2
state_before: case h
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
ι : Type u_4
x : E
v : ι → E
hv : Orthonormal 𝕜 v
⊢ HasSum (fun i => ‖⟪v i, x⟫_𝕜‖ ^ 2) (⨆ s, ∑ i ∈ s, ‖⟪v i, x⟫_𝕜‖ ^ 2)
state_after: case h.h
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
ι : Type u_4
x : E
v : ι → E
hv : Orthonormal 𝕜 v
⊢ ∀ (i : ι), 0 ≤ ‖⟪v i, x⟫_𝕜‖ ^ 2

case h.hf
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
ι : Type u_4
x : E
v : ι → E
hv : Orthonormal 𝕜 v
⊢ IsLUB (Set.range fun s => ∑ i ∈ s, ‖⟪v i, x⟫_𝕜‖ ^ 2) (⨆ s, ∑ i ∈ s, ‖⟪v i, x⟫_𝕜‖ ^ 2)
tactic: apply hasSum_of_isLUB_of_nonneg
Theorem: Finset.mem_upShadow_iff
File: Mathlib/Combinatorics/SetFamily/Shadow.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
𝒜 : Finset (Finset α)
s t : Finset α
a : α
k r : ℕ
⊢ t ∈ ∂⁺ 𝒜 ↔ ∃ s ∈ 𝒜, ∃ a ∉ s, insert a s = t
state_after: no goals
tactic: simp_rw [upShadow, mem_sup, mem_image, mem_compl]
Theorem: multiplicative_of_symmetric_of_isTotal
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✝¹ : Monoid β
p r : α → α → Prop
inst✝ : IsTotal α r
f : α → α → β
hsymm : Symmetric p
hf_swap : ∀ {a b : α}, p a b → f a b * f b a = 1
hmul : ∀ {a b c : α}, r a b → r b c → p a b → p b c → p a c → f a c = f a b * f b c
a b c : α
pab : p a b
pbc : p b c
pac : p a c
hmul' : ∀ {b c : α}, r b c → p a b → p b c → p a c → f a c = f a b * f b c
⊢ f a c = f a b * f b c
state_after: case inl
α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝¹ : Monoid β
p r : α → α → Prop
inst✝ : IsTotal α r
f : α → α → β
hsymm : Symmetric p
hf_swap : ∀ {a b : α}, p a b → f a b * f b a = 1
hmul : ∀ {a b c : α}, r a b → r b c → p a b → p b c → p a c → f a c = f a b * f b c
a b c : α
pab : p a b
pbc : p b c
pac : p a c
hmul' : ∀ {b c : α}, r b c → p a b → p b c → p a c → f a c = f a b * f b c
rbc : r b c
⊢ f a c = f a b * f b c

case inr
α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝¹ : Monoid β
p r : α → α → Prop
inst✝ : IsTotal α r
f : α → α → β
hsymm : Symmetric p
hf_swap : ∀ {a b : α}, p a b → f a b * f b a = 1
hmul : ∀ {a b c : α}, r a b → r b c → p a b → p b c → p a c → f a c = f a b * f b c
a b c : α
pab : p a b
pbc : p b c
pac : p a c
hmul' : ∀ {b c : α}, r b c → p a b → p b c → p a c → f a c = f a b * f b c
rcb : r c b
⊢ f a c = f a b * f b c
tactic: obtain rbc | rcb := total_of r b c
Theorem: CategoryTheory.Pretriangulated.Triangle.yoneda_exact₂
File: Mathlib/CategoryTheory/Triangulated/Pretriangulated.lean

Proof steps:
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroObject C
inst✝² : HasShift C ℤ
inst✝¹ : Preadditive C
inst✝ : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive
hC : Pretriangulated C
T : Triangle C
hT : T ∈ distinguishedTriangles
X : C
f : T.obj₂ ⟶ X
hf : T.mor₁ ≫ f = 0
⊢ ∃ g, f = T.mor₂ ≫ g
state_after: case intro.intro
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroObject C
inst✝² : HasShift C ℤ
inst✝¹ : Preadditive C
inst✝ : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive
hC : Pretriangulated C
T : Triangle C
hT : T ∈ distinguishedTriangles
X : C
f : T.obj₂ ⟶ X
hf : T.mor₁ ≫ f = 0
g : T.obj₃ ⟶ (mk 0 (𝟙 X) 0).obj₃
hg₁ : T.mor₂ ≫ g = f ≫ (mk 0 (𝟙 X) 0).mor₂
right✝ : T.mor₃ ≫ (CategoryTheory.shiftFunctor C 1).map 0 = g ≫ (mk 0 (𝟙 X) 0).mor₃
⊢ ∃ g, f = T.mor₂ ≫ g
tactic: obtain ⟨g, ⟨hg₁, _⟩⟩ := complete_distinguished_triangle_morphism T _ hT
    (contractible_distinguished₁ X) 0 f (by aesop_cat)
state_before: case intro.intro
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroObject C
inst✝² : HasShift C ℤ
inst✝¹ : Preadditive C
inst✝ : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive
hC : Pretriangulated C
T : Triangle C
hT : T ∈ distinguishedTriangles
X : C
f : T.obj₂ ⟶ X
hf : T.mor₁ ≫ f = 0
g : T.obj₃ ⟶ (mk 0 (𝟙 X) 0).obj₃
hg₁ : T.mor₂ ≫ g = f ≫ (mk 0 (𝟙 X) 0).mor₂
right✝ : T.mor₃ ≫ (CategoryTheory.shiftFunctor C 1).map 0 = g ≫ (mk 0 (𝟙 X) 0).mor₃
⊢ ∃ g, f = T.mor₂ ≫ g
state_after: no goals
tactic: exact ⟨g, by simpa using hg₁.symm⟩
Theorem: tprod_eq_one_of_not_multipliable
File: Mathlib/Topology/Algebra/InfiniteSum/Defs.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : CommMonoid α
inst✝ : TopologicalSpace α
f g : β → α
a b : α
s : Finset β
h : ¬Multipliable f
⊢ ∏' (b : β), f b = 1
state_after: no goals
tactic: simp [tprod_def, h]
Theorem: List.Ico.filter_le_of_le
File: Mathlib/Data/List/Intervals.lean

Proof steps:
state_before: n m l : ℕ
hnl : n ≤ l
⊢ filter (fun x => decide (l ≤ x)) (Ico n m) = Ico l m
state_after: case inl
n m l : ℕ
hnl : n ≤ l
hlm : l ≤ m
⊢ filter (fun x => decide (l ≤ x)) (Ico n m) = Ico l m

case inr
n m l : ℕ
hnl : n ≤ l
hml : m ≤ l
⊢ filter (fun x => decide (l ≤ x)) (Ico n m) = Ico l m
tactic: rcases le_total l m with hlm | hml
Theorem: Finset.map_noncommSum
File: Mathlib/Data/Finset/NoncommProd.lean

Proof steps:
state_before: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
f✝ : α → β → β
op : α → α → α
inst✝³ : Monoid β
inst✝² : Monoid γ
inst✝¹ : FunLike F β γ
inst✝ : MonoidHomClass F β γ
s : Finset α
f : α → β
comm : (↑s).Pairwise fun a b => Commute (f a) (f b)
g : F
⊢ g (s.noncommProd f comm) = s.noncommProd (fun i => g (f i)) ⋯
state_after: no goals
tactic: simp [noncommProd, Multiset.map_noncommProd]
Theorem: HomogeneousLocalization.val_smul
File: Mathlib/RingTheory/GradedAlgebra/HomogeneousLocalization.lean

Proof steps:
state_before: ι : Type u_1
R : Type u_2
A : Type u_3
inst✝⁹ : AddCommMonoid ι
inst✝⁸ : DecidableEq ι
inst✝⁷ : CommRing R
inst✝⁶ : CommRing A
inst✝⁵ : Algebra R A
𝒜 : ι → Submodule R A
inst✝⁴ : GradedAlgebra 𝒜
x : Submonoid A
α : Type u_4
inst✝³ : SMul α R
inst✝² : SMul α A
inst✝¹ : IsScalarTower α R A
inst✝ : IsScalarTower α A A
n : α
x✝ : NumDenSameDeg 𝒜 x
⊢ (n • Quotient.mk'' x✝).val = n • val (Quotient.mk'' x✝)
state_after: ι : Type u_1
R : Type u_2
A : Type u_3
inst✝⁹ : AddCommMonoid ι
inst✝⁸ : DecidableEq ι
inst✝⁷ : CommRing R
inst✝⁶ : CommRing A
inst✝⁵ : Algebra R A
𝒜 : ι → Submodule R A
inst✝⁴ : GradedAlgebra 𝒜
x : Submonoid A
α : Type u_4
inst✝³ : SMul α R
inst✝² : SMul α A
inst✝¹ : IsScalarTower α R A
inst✝ : IsScalarTower α A A
n : α
x✝ : NumDenSameDeg 𝒜 x
⊢ Localization.mk ↑(n • x✝).num ⟨↑(n • x✝).den, ⋯⟩ = Localization.mk (n • ↑x✝.num) ⟨↑x✝.den, ⋯⟩
tactic: rw [← mk_smul, val_mk, val_mk, Localization.smul_mk]
state_before: ι : Type u_1
R : Type u_2
A : Type u_3
inst✝⁹ : AddCommMonoid ι
inst✝⁸ : DecidableEq ι
inst✝⁷ : CommRing R
inst✝⁶ : CommRing A
inst✝⁵ : Algebra R A
𝒜 : ι → Submodule R A
inst✝⁴ : GradedAlgebra 𝒜
x : Submonoid A
α : Type u_4
inst✝³ : SMul α R
inst✝² : SMul α A
inst✝¹ : IsScalarTower α R A
inst✝ : IsScalarTower α A A
n : α
x✝ : NumDenSameDeg 𝒜 x
⊢ Localization.mk ↑(n • x✝).num ⟨↑(n • x✝).den, ⋯⟩ = Localization.mk (n • ↑x✝.num) ⟨↑x✝.den, ⋯⟩
state_after: no goals
tactic: rfl
Theorem: stronglyMeasurable_const_smul_iff
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 : Type u_5
G : Type u_6
G₀ : Type u_7
inst✝⁹ : TopologicalSpace β
inst✝⁸ : Monoid M
inst✝⁷ : MulAction M β
inst✝⁶ : ContinuousConstSMul M β
inst✝⁵ : Group G
inst✝⁴ : MulAction G β
inst✝³ : ContinuousConstSMul G β
inst✝² : GroupWithZero G₀
inst✝¹ : MulAction G₀ β
inst✝ : ContinuousConstSMul G₀ β
m : MeasurableSpace α
c : G
h : StronglyMeasurable fun x => c • f x
⊢ StronglyMeasurable f
state_after: no goals
tactic: simpa only [inv_smul_smul] using h.const_smul' c⁻¹
Theorem: Matrix.transposeAlgEquiv_apply
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✝⁴ : CommSemiring R
inst✝³ : CommSemiring α
inst✝² : Fintype m
inst✝¹ : DecidableEq m
inst✝ : Algebra R α
r : R
⊢ { toFun := fun M => MulOpposite.op Mᵀ, invFun := __src✝¹.invFun, left_inv := ⋯, right_inv := ⋯ }.toFun
      ((algebraMap R (Matrix m m α)) r) =
    (algebraMap R (Matrix m m α)ᵐᵒᵖ) r
state_after: no goals
tactic: simp only [algebraMap_eq_diagonal, diagonal_transpose, MulOpposite.algebraMap_apply]
Theorem: Finset.erase_insert
File: Mathlib/Data/Finset/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s✝ t u v : Finset α
a✝ b a : α
s : Finset α
h : a ∉ s
⊢ (insert a s).erase a = s
state_after: no goals
tactic: rw [erase_insert_eq_erase, erase_eq_of_not_mem h]
Theorem: AddLECancellable.tsub_lt_self_iff
File: Mathlib/Algebra/Order/Sub/Canonical.lean

Proof steps:
state_before: α : Type u_1
inst✝² : CanonicallyLinearOrderedAddCommMonoid α
inst✝¹ : Sub α
inst✝ : OrderedSub α
a b c d : α
ha : AddLECancellable a
⊢ a - b < a ↔ 0 < a ∧ 0 < b
state_after: α : Type u_1
inst✝² : CanonicallyLinearOrderedAddCommMonoid α
inst✝¹ : Sub α
inst✝ : OrderedSub α
a b c d : α
ha : AddLECancellable a
h : a - b < a
⊢ 0 ≠ b
tactic: refine
    ⟨fun h => ⟨(zero_le _).trans_lt h, (zero_le b).lt_of_ne ?_⟩, fun h => ha.tsub_lt_self h.1 h.2⟩
state_before: α : Type u_1
inst✝² : CanonicallyLinearOrderedAddCommMonoid α
inst✝¹ : Sub α
inst✝ : OrderedSub α
a b c d : α
ha : AddLECancellable a
h : a - b < a
⊢ 0 ≠ b
state_after: α : Type u_1
inst✝² : CanonicallyLinearOrderedAddCommMonoid α
inst✝¹ : Sub α
inst✝ : OrderedSub α
a c d : α
ha : AddLECancellable a
h : a - 0 < a
⊢ False
tactic: rintro rfl
state_before: α : Type u_1
inst✝² : CanonicallyLinearOrderedAddCommMonoid α
inst✝¹ : Sub α
inst✝ : OrderedSub α
a c d : α
ha : AddLECancellable a
h : a - 0 < a
⊢ False
state_after: α : Type u_1
inst✝² : CanonicallyLinearOrderedAddCommMonoid α
inst✝¹ : Sub α
inst✝ : OrderedSub α
a c d : α
ha : AddLECancellable a
h : a < a
⊢ False
tactic: rw [tsub_zero] at h
state_before: α : Type u_1
inst✝² : CanonicallyLinearOrderedAddCommMonoid α
inst✝¹ : Sub α
inst✝ : OrderedSub α
a c d : α
ha : AddLECancellable a
h : a < a
⊢ False
state_after: no goals
tactic: exact h.false
Theorem: AddSubmonoid.prod_le_iff
File: Mathlib/Algebra/Group/Submonoid/Operations.lean

Proof steps:
state_before: M : Type u_1
N : Type u_2
P : Type u_3
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : MulOneClass P
S : Submonoid M
A : Type u_4
inst✝ : SetLike A M
hA : SubmonoidClass A M
S' : A
s : Submonoid M
t : Submonoid N
u : Submonoid (M × N)
⊢ s.prod t ≤ u ↔ map (inl M N) s ≤ u ∧ map (inr M N) t ≤ u
state_after: case mp
M : Type u_1
N : Type u_2
P : Type u_3
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : MulOneClass P
S : Submonoid M
A : Type u_4
inst✝ : SetLike A M
hA : SubmonoidClass A M
S' : A
s : Submonoid M
t : Submonoid N
u : Submonoid (M × N)
⊢ s.prod t ≤ u → map (inl M N) s ≤ u ∧ map (inr M N) t ≤ u

case mpr
M : Type u_1
N : Type u_2
P : Type u_3
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : MulOneClass P
S : Submonoid M
A : Type u_4
inst✝ : SetLike A M
hA : SubmonoidClass A M
S' : A
s : Submonoid M
t : Submonoid N
u : Submonoid (M × N)
⊢ map (inl M N) s ≤ u ∧ map (inr M N) t ≤ u → s.prod t ≤ u
tactic: constructor
Theorem: norm_inner_le_norm
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
x y : E
⊢ ‖⟪x, y⟫_𝕜‖ ≤ ‖x‖ * ‖y‖
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
x y : E
⊢ ‖⟪x, y⟫_𝕜‖ ≤ √(re ⟪x, x⟫_𝕜) * √(re ⟪y, y⟫_𝕜)
tactic: rw [norm_eq_sqrt_inner (𝕜 := 𝕜) x, norm_eq_sqrt_inner (𝕜 := 𝕜) y]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
x y : E
⊢ ‖⟪x, y⟫_𝕜‖ ≤ √(re ⟪x, x⟫_𝕜) * √(re ⟪y, y⟫_𝕜)
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
x y : E
this : InnerProductSpace.Core 𝕜 E := InnerProductSpace.toCore
⊢ ‖⟪x, y⟫_𝕜‖ ≤ √(re ⟪x, x⟫_𝕜) * √(re ⟪y, y⟫_𝕜)
tactic: letI : InnerProductSpace.Core 𝕜 E := InnerProductSpace.toCore
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
x y : E
this : InnerProductSpace.Core 𝕜 E := InnerProductSpace.toCore
⊢ ‖⟪x, y⟫_𝕜‖ ≤ √(re ⟪x, x⟫_𝕜) * √(re ⟪y, y⟫_𝕜)
state_after: no goals
tactic: exact InnerProductSpace.Core.norm_inner_le_norm x y
Theorem: Polynomial.restriction_one
File: Mathlib/RingTheory/Polynomial/Basic.lean

Proof steps:
state_before: R : Type u
S : Type u_1
inst✝ : Ring R
i : ℕ
⊢ ↑((restriction 1).coeff i) = ↑(coeff 1 i)
state_after: R : Type u
S : Type u_1
inst✝ : Ring R
i : ℕ
⊢ (if i = 0 then 1 else 0) = ↑(if i = 0 then 1 else 0)
tactic: rw [coeff_restriction', coeff_one, coeff_one]
state_before: R : Type u
S : Type u_1
inst✝ : Ring R
i : ℕ
⊢ (if i = 0 then 1 else 0) = ↑(if i = 0 then 1 else 0)
state_after: no goals
tactic: split_ifs <;> rfl
Theorem: NumberField.isUnit_iff_norm
File: Mathlib/NumberTheory/NumberField/Units/Basic.lean

Proof steps:
state_before: K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
x : 𝓞 K
⊢ IsUnit x ↔ |↑((RingOfIntegers.norm ℚ) x)| = 1
state_after: case h.e'_2.a
K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
x : 𝓞 K
⊢ |↑((RingOfIntegers.norm ℚ) x)| = 1 ↔ IsUnit ((RingOfIntegers.norm ℚ) x)
tactic: convert (RingOfIntegers.isUnit_norm ℚ (F := K)).symm
state_before: case h.e'_2.a
K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
x : 𝓞 K
⊢ |↑((RingOfIntegers.norm ℚ) x)| = 1 ↔ IsUnit ((RingOfIntegers.norm ℚ) x)
state_after: no goals
tactic: rw [← abs_one, abs_eq_abs, ← Rat.RingOfIntegers.isUnit_iff]
Theorem: CategoryTheory.MonoidalCategory.whiskerLeft_rightUnitor
File: Mathlib/CategoryTheory/Monoidal/Category.lean

Proof steps:
state_before: C✝ : Type u
𝒞 : Category.{v, u} C✝
inst✝² : MonoidalCategory C✝
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : MonoidalCategory C
U V W X✝ Y✝ Z X Y : C
⊢ X ◁ (ρ_ Y).hom = (α_ X Y (𝟙_ C)).inv ≫ (ρ_ (X ⊗ Y)).hom
state_after: no goals
tactic: rw [← whiskerRight_iff, comp_whiskerRight, ← cancel_epi (α_ _ _ _).inv, ←
      cancel_epi (X ◁ (α_ _ _ _).inv), pentagon_inv_assoc, triangle_assoc_comp_right, ←
      associator_inv_naturality_middle, ← whiskerLeft_comp_assoc, triangle_assoc_comp_right,
      associator_inv_naturality_right]
Theorem: WithBot.image_coe_Icc
File: Mathlib/Order/Interval/Set/WithBotTop.lean

Proof steps:
state_before: α : Type u_1
inst✝ : Preorder α
a b : α
⊢ some '' Icc a b = Icc ↑a ↑b
state_after: no goals
tactic: rw [← preimage_coe_Icc, image_preimage_eq_inter_range, range_coe,
    inter_eq_self_of_subset_left
      (Subset.trans Icc_subset_Ici_self <| Ici_subset_Ioi.2 <| bot_lt_coe a)]
Theorem: Right.neg_nonpos_iff
File: Mathlib/Algebra/Order/Group/Unbundled/Basic.lean

Proof steps:
state_before: α : Type u
inst✝² : Group α
inst✝¹ : LE α
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b c : α
⊢ a⁻¹ ≤ 1 ↔ 1 ≤ a
state_after: α : Type u
inst✝² : Group α
inst✝¹ : LE α
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b c : α
⊢ a⁻¹ * a ≤ 1 * a ↔ 1 ≤ a
tactic: rw [← mul_le_mul_iff_right a]
state_before: α : Type u
inst✝² : Group α
inst✝¹ : LE α
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b c : α
⊢ a⁻¹ * a ≤ 1 * a ↔ 1 ≤ a
state_after: no goals
tactic: simp
Theorem: Polynomial.Monic.degree_map
File: Mathlib/Algebra/Polynomial/Monic.lean

Proof steps:
state_before: R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝² : Semiring R
inst✝¹ : Semiring S
inst✝ : Nontrivial S
P : R[X]
hmo : P.Monic
f : R →+* S
⊢ (Polynomial.map f P).degree = P.degree
state_after: case pos
R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝² : Semiring R
inst✝¹ : Semiring S
inst✝ : Nontrivial S
P : R[X]
hmo : P.Monic
f : R →+* S
hP : P = 0
⊢ (Polynomial.map f P).degree = P.degree

case neg
R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝² : Semiring R
inst✝¹ : Semiring S
inst✝ : Nontrivial S
P : R[X]
hmo : P.Monic
f : R →+* S
hP : ¬P = 0
⊢ (Polynomial.map f P).degree = P.degree
tactic: by_cases hP : P = 0
Theorem: List.map_map_permutations'Aux
File: Mathlib/Data/List/Permutation.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
f : α → β
t : α
ts : List α
⊢ map (map f) (permutations'Aux t ts) = permutations'Aux (f t) (map f ts)
state_after: case nil
α : Type u_1
β : Type u_2
f : α → β
t : α
⊢ map (map f) (permutations'Aux t []) = permutations'Aux (f t) (map f [])

case cons
α : Type u_1
β : Type u_2
f : α → β
t a : α
ts : List α
ih : map (map f) (permutations'Aux t ts) = permutations'Aux (f t) (map f ts)
⊢ map (map f) (permutations'Aux t (a :: ts)) = permutations'Aux (f t) (map f (a :: ts))
tactic: induction' ts with a ts ih
Theorem: Finset.Nat.antidiagonalEquivFin_apply_val
File: Mathlib/Data/Finset/NatAntidiagonal.lean

Proof steps:
state_before: n : ℕ
x✝ : Fin (n + 1)
i : ℕ
h : i < n + 1
⊢ (i, n - i) ∈ antidiagonal n
state_after: n : ℕ
x✝ : Fin (n + 1)
i : ℕ
h : i < n + 1
⊢ i ≤ n
tactic: rw [mem_antidiagonal, add_comm, tsub_add_cancel_iff_le]
state_before: n : ℕ
x✝ : Fin (n + 1)
i : ℕ
h : i < n + 1
⊢ i ≤ n
state_after: no goals
tactic: exact Nat.le_of_lt_succ h
state_before: n : ℕ
⊢ LeftInverse
    (fun x =>
      match x with
      | ⟨i, h⟩ => ⟨(i, n - i), ⋯⟩)
    fun x =>
    match x with
    | ⟨(i, j), h⟩ => ⟨i, ⋯⟩
state_after: case mk.mk
n i j : ℕ
h : (i, j) ∈ antidiagonal n
⊢ (fun x =>
        match x with
        | ⟨i, h⟩ => ⟨(i, n - i), ⋯⟩)
      ((fun x =>
          match x with
          | ⟨(i, j), h⟩ => ⟨i, ⋯⟩)
        ⟨(i, j), h⟩) =
    ⟨(i, j), h⟩
tactic: rintro ⟨⟨i, j⟩, h⟩
state_before: case mk.mk
n i j : ℕ
h : (i, j) ∈ antidiagonal n
⊢ (fun x =>
        match x with
        | ⟨i, h⟩ => ⟨(i, n - i), ⋯⟩)
      ((fun x =>
          match x with
          | ⟨(i, j), h⟩ => ⟨i, ⋯⟩)
        ⟨(i, j), h⟩) =
    ⟨(i, j), h⟩
state_after: case mk.mk.h
n i j : ℕ
h : (i, j) ∈ antidiagonal n
⊢ (↑((fun x =>
            match x with
            | ⟨i, h⟩ => ⟨(i, n - i), ⋯⟩)
          ((fun x =>
              match x with
              | ⟨(i, j), h⟩ => ⟨i, ⋯⟩)
            ⟨(i, j), h⟩))).1 =
    (↑⟨(i, j), h⟩).1
tactic: ext
state_before: case mk.mk.h
n i j : ℕ
h : (i, j) ∈ antidiagonal n
⊢ (↑((fun x =>
            match x with
            | ⟨i, h⟩ => ⟨(i, n - i), ⋯⟩)
          ((fun x =>
              match x with
              | ⟨(i, j), h⟩ => ⟨i, ⋯⟩)
            ⟨(i, j), h⟩))).1 =
    (↑⟨(i, j), h⟩).1
state_after: no goals
tactic: rfl
Theorem: Nat.two_mul_odd_div_two
File: Mathlib/Data/Nat/Defs.lean

Proof steps:
state_before: a b c d m n k : ℕ
p q : ℕ → Prop
hn : n % 2 = 1
⊢ 2 * (n / 2) = n - 1
state_after: no goals
tactic: conv => rhs; rw [← Nat.mod_add_div n 2, hn, Nat.add_sub_cancel_left]