ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: CHSH_inequality_of_comm
File: Mathlib/Algebra/Star/CHSH.lean

Proof steps:
state_before: R : Type u
inst✝⁴ : OrderedCommRing R
inst✝³ : StarRing R
inst✝² : StarOrderedRing R
inst✝¹ : Algebra ℝ R
inst✝ : OrderedSMul ℝ R
A₀ A₁ B₀ B₁ : R
T : IsCHSHTuple A₀ A₁ B₀ B₁
⊢ A₀ * B₀ + A₀ * B₁ + A₁ * B₀ - A₁ * B₁ ≤ 2
state_after: R : Type u
inst✝⁴ : OrderedCommRing R
inst✝³ : StarRing R
inst✝² : StarOrderedRing R
inst✝¹ : Algebra ℝ R
inst✝ : OrderedSMul ℝ R
A₀ A₁ B₀ B₁ : R
T : IsCHSHTuple A₀ A₁ B₀ B₁
P : R := 2 - A₀ * B₀ - A₀ * B₁ - A₁ * B₀ + A₁ * B₁
⊢ A₀ * B₀ + A₀ * B₁ + A₁ * B₀ - A₁ * B₁ ≤ 2
tactic: let P := 2 - A₀ * B₀ - A₀ * B₁ - A₁ * B₀ + A₁ * B₁
state_before: R : Type u
inst✝⁴ : OrderedCommRing R
inst✝³ : StarRing R
inst✝² : StarOrderedRing R
inst✝¹ : Algebra ℝ R
inst✝ : OrderedSMul ℝ R
A₀ A₁ B₀ B₁ : R
T : IsCHSHTuple A₀ A₁ B₀ B₁
P : R := 2 - A₀ * B₀ - A₀ * B₁ - A₁ * B₀ + A₁ * B₁
⊢ A₀ * B₀ + A₀ * B₁ + A₁ * B₀ - A₁ * B₁ ≤ 2
state_after: R : Type u
inst✝⁴ : OrderedCommRing R
inst✝³ : StarRing R
inst✝² : StarOrderedRing R
inst✝¹ : Algebra ℝ R
inst✝ : OrderedSMul ℝ R
A₀ A₁ B₀ B₁ : R
T : IsCHSHTuple A₀ A₁ B₀ B₁
P : R := 2 - A₀ * B₀ - A₀ * B₁ - A₁ * B₀ + A₁ * B₁
i₁ : 0 ≤ P
⊢ A₀ * B₀ + A₀ * B₁ + A₁ * B₀ - A₁ * B₁ ≤ 2
tactic: have i₁ : 0 ≤ P := by
    have idem : P * P = 4 * P := CHSH_id T.A₀_inv T.A₁_inv T.B₀_inv T.B₁_inv
    have idem' : P = (1 / 4 : ℝ) • (P * P) := by
      have h : 4 * P = (4 : ℝ) • P := by simp [Algebra.smul_def]
      rw [idem, h, ← mul_smul]
      norm_num
    have sa : star P = P := by
      dsimp [P]
      simp only [star_add, star_sub, star_mul, star_ofNat, star_one, T.A₀_sa, T.A₁_sa, T.B₀_sa,
        T.B₁_sa, mul_comm B₀, mul_comm B₁]
    simpa only [← idem', sa]
      using smul_nonneg (by norm_num : (0 : ℝ) ≤ 1 / 4) (star_mul_self_nonneg P)
state_before: R : Type u
inst✝⁴ : OrderedCommRing R
inst✝³ : StarRing R
inst✝² : StarOrderedRing R
inst✝¹ : Algebra ℝ R
inst✝ : OrderedSMul ℝ R
A₀ A₁ B₀ B₁ : R
T : IsCHSHTuple A₀ A₁ B₀ B₁
P : R := 2 - A₀ * B₀ - A₀ * B₁ - A₁ * B₀ + A₁ * B₁
i₁ : 0 ≤ P
⊢ A₀ * B₀ + A₀ * B₁ + A₁ * B₀ - A₁ * B₁ ≤ 2
state_after: case a
R : Type u
inst✝⁴ : OrderedCommRing R
inst✝³ : StarRing R
inst✝² : StarOrderedRing R
inst✝¹ : Algebra ℝ R
inst✝ : OrderedSMul ℝ R
A₀ A₁ B₀ B₁ : R
T : IsCHSHTuple A₀ A₁ B₀ B₁
P : R := 2 - A₀ * B₀ - A₀ * B₁ - A₁ * B₀ + A₁ * B₁
i₁ : 0 ≤ P
⊢ 0 ≤ 2 - (A₀ * B₀ + A₀ * B₁ + A₁ * B₀ - A₁ * B₁)
tactic: apply le_of_sub_nonneg
state_before: case a
R : Type u
inst✝⁴ : OrderedCommRing R
inst✝³ : StarRing R
inst✝² : StarOrderedRing R
inst✝¹ : Algebra ℝ R
inst✝ : OrderedSMul ℝ R
A₀ A₁ B₀ B₁ : R
T : IsCHSHTuple A₀ A₁ B₀ B₁
P : R := 2 - A₀ * B₀ - A₀ * B₁ - A₁ * B₀ + A₁ * B₁
i₁ : 0 ≤ P
⊢ 0 ≤ 2 - (A₀ * B₀ + A₀ * B₁ + A₁ * B₀ - A₁ * B₁)
state_after: no goals
tactic: simpa only [sub_add_eq_sub_sub, ← sub_add] using i₁
Theorem: orderOf_one
File: Mathlib/GroupTheory/OrderOfElement.lean

Proof steps:
state_before: G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝ : Monoid G
a b x y : G
n m : ℕ
⊢ orderOf 1 = 1
state_after: no goals
tactic: rw [orderOf, ← minimalPeriod_id (x := (1 : G)), ← one_mul_eq_id]
Theorem: not_ringChar_dvd_of_invertible
File: Mathlib/Algebra/CharP/Invertible.lean

Proof steps:
state_before: K : Type u_1
inst✝¹ : Field K
t : ℕ
inst✝ : Invertible ↑t
⊢ ¬ringChar K ∣ t
state_after: K : Type u_1
inst✝¹ : Field K
t : ℕ
inst✝ : Invertible ↑t
⊢ ↑t ≠ 0
tactic: rw [← ringChar.spec, ← Ne]
state_before: K : Type u_1
inst✝¹ : Field K
t : ℕ
inst✝ : Invertible ↑t
⊢ ↑t ≠ 0
state_after: no goals
tactic: exact nonzero_of_invertible (t : K)
Theorem: IsometryEquiv.preimage_emetric_closedBall
File: Mathlib/Topology/MetricSpace/Isometry.lean

Proof steps:
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
inst✝² : PseudoEMetricSpace α
inst✝¹ : PseudoEMetricSpace β
inst✝ : PseudoEMetricSpace γ
h : α ≃ᵢ β
x : β
r : ℝ≥0∞
⊢ ⇑h ⁻¹' EMetric.closedBall x r = EMetric.closedBall (h.symm x) r
state_after: no goals
tactic: rw [← h.isometry.preimage_emetric_closedBall (h.symm x) r, h.apply_symm_apply]
Theorem: Asymptotics.IsLittleO.add_add
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 α
f₁ f₂ : α → E'
g₁ g₂ : α → F'
h₁ : f₁ =o[l] g₁
h₂ : f₂ =o[l] g₂
⊢ (fun x => f₁ x + f₂ x) =o[l] fun x => ‖g₁ x‖ + ‖g₂ x‖
state_after: no goals
tactic: refine (h₁.trans_le fun x => ?_).add (h₂.trans_le ?_) <;> simp [abs_of_nonneg, add_nonneg]
Theorem: Algebra.Generators.CotangentSpace.repr_map
File: Mathlib/RingTheory/Kaehler/CotangentComplex.lean

Proof steps:
state_before: R : Type u
S : Type v
inst✝¹⁰ : CommRing R
inst✝⁹ : CommRing S
inst✝⁸ : Algebra R S
P : Generators R S
R' : Type u'
S' : Type v'
inst✝⁷ : CommRing R'
inst✝⁶ : CommRing S'
inst✝⁵ : Algebra R' S'
P' : Generators R' S'
inst✝⁴ : Algebra R R'
inst✝³ : Algebra S S'
inst✝² : Algebra R S'
inst✝¹ : IsScalarTower R R' S'
inst✝ : IsScalarTower R S S'
f : P.Hom P'
i : P.vars
j : P'.vars
⊢ (P'.cotangentSpaceBasis.repr ((CotangentSpace.map f) (P.cotangentSpaceBasis i))) j =
    (aeval P'.val) ((pderiv j) (f.val i))
state_after: no goals
tactic: simp only [cotangentSpaceBasis_apply, map_tmul, _root_.map_one, Hom.toAlgHom_X,
    cotangentSpaceBasis_repr_one_tmul]
Theorem: Subgroup.quotientiInfEmbedding_apply
File: Mathlib/GroupTheory/Coset.lean

Proof steps:
state_before: α : Type u_1
inst✝ : Group α
s t : Subgroup α
ι : Type u_2
f : ι → Subgroup α
⊢ ∀ (a₁ a₂ : α),
    (fun q i => quotientMapOfLE ⋯ q) (Quotient.mk'' a₁) = (fun q i => quotientMapOfLE ⋯ q) (Quotient.mk'' a₂) →
      Quotient.mk'' a₁ = Quotient.mk'' a₂
state_after: no goals
tactic: simp_rw [funext_iff, quotientMapOfLE_apply_mk, eq', mem_iInf, imp_self, forall_const]
Theorem: _private.Mathlib.LinearAlgebra.CliffordAlgebra.Even.0.CliffordAlgebra.even.lift.fFold_fFold
File: Mathlib/LinearAlgebra/CliffordAlgebra/Even.lean

Proof steps:
state_before: R : Type uR
M : Type uM
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
Q : QuadraticForm R M
A : Type uA
B : Type uB
inst✝³ : Ring A
inst✝² : Ring B
inst✝¹ : Algebra R A
inst✝ : Algebra R B
f : EvenHom Q A
m : M
x : A × ↥(CliffordAlgebra.even.lift.S f)
⊢ ((CliffordAlgebra.even.lift.fFold f) m) (((CliffordAlgebra.even.lift.fFold f) m) x) = Q m • x
state_after: case mk.mk
R : Type uR
M : Type uM
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
Q : QuadraticForm R M
A : Type uA
B : Type uB
inst✝³ : Ring A
inst✝² : Ring B
inst✝¹ : Algebra R A
inst✝ : Algebra R B
f : EvenHom Q A
m : M
a : A
g : M →ₗ[R] A
hg : g ∈ CliffordAlgebra.even.lift.S f
⊢ ((CliffordAlgebra.even.lift.fFold f) m) (((CliffordAlgebra.even.lift.fFold f) m) (a, ⟨g, hg⟩)) = Q m • (a, ⟨g, hg⟩)
tactic: obtain ⟨a, ⟨g, hg⟩⟩ := x
state_before: case mk.mk
R : Type uR
M : Type uM
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
Q : QuadraticForm R M
A : Type uA
B : Type uB
inst✝³ : Ring A
inst✝² : Ring B
inst✝¹ : Algebra R A
inst✝ : Algebra R B
f : EvenHom Q A
m : M
a : A
g : M →ₗ[R] A
hg : g ∈ CliffordAlgebra.even.lift.S f
⊢ ((CliffordAlgebra.even.lift.fFold f) m) (((CliffordAlgebra.even.lift.fFold f) m) (a, ⟨g, hg⟩)) = Q m • (a, ⟨g, hg⟩)
state_after: case mk.mk.a
R : Type uR
M : Type uM
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
Q : QuadraticForm R M
A : Type uA
B : Type uB
inst✝³ : Ring A
inst✝² : Ring B
inst✝¹ : Algebra R A
inst✝ : Algebra R B
f : EvenHom Q A
m : M
a : A
g : M →ₗ[R] A
hg : g ∈ CliffordAlgebra.even.lift.S f
⊢ (((CliffordAlgebra.even.lift.fFold f) m) (((CliffordAlgebra.even.lift.fFold f) m) (a, ⟨g, hg⟩))).1 =
    (Q m • (a, ⟨g, hg⟩)).1

case mk.mk.a.a
R : Type uR
M : Type uM
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
Q : QuadraticForm R M
A : Type uA
B : Type uB
inst✝³ : Ring A
inst✝² : Ring B
inst✝¹ : Algebra R A
inst✝ : Algebra R B
f : EvenHom Q A
m : M
a : A
g : M →ₗ[R] A
hg : g ∈ CliffordAlgebra.even.lift.S f
⊢ ↑(((CliffordAlgebra.even.lift.fFold f) m) (((CliffordAlgebra.even.lift.fFold f) m) (a, ⟨g, hg⟩))).2 =
    ↑(Q m • (a, ⟨g, hg⟩)).2
tactic: ext : 2
Theorem: PNat.mod_le
File: Mathlib/Data/PNat/Basic.lean

Proof steps:
state_before: m k : ℕ+
⊢ m.mod k ≤ m ∧ m.mod k ≤ k
state_after: m k : ℕ+
⊢ ↑(m.mod k) ≤ ↑m ∧ ↑(m.mod k) ≤ ↑k
tactic: change (mod m k : ℕ) ≤ (m : ℕ) ∧ (mod m k : ℕ) ≤ (k : ℕ)
state_before: m k : ℕ+
⊢ ↑(m.mod k) ≤ ↑m ∧ ↑(m.mod k) ≤ ↑k
state_after: m k : ℕ+
⊢ (if ↑m % ↑k = 0 then ↑k else ↑m % ↑k) ≤ ↑m ∧ (if ↑m % ↑k = 0 then ↑k else ↑m % ↑k) ≤ ↑k
tactic: rw [mod_coe]
state_before: m k : ℕ+
⊢ (if ↑m % ↑k = 0 then ↑k else ↑m % ↑k) ≤ ↑m ∧ (if ↑m % ↑k = 0 then ↑k else ↑m % ↑k) ≤ ↑k
state_after: case pos
m k : ℕ+
h : ↑m % ↑k = 0
⊢ ↑k ≤ ↑m ∧ ↑k ≤ ↑k

case neg
m k : ℕ+
h : ¬↑m % ↑k = 0
⊢ ↑m % ↑k ≤ ↑m ∧ ↑m % ↑k ≤ ↑k
tactic: split_ifs with h
Theorem: Set.Finite.induction_on'
File: Mathlib/Data/Set/Finite.lean

Proof steps:
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
C : Set α → Prop
S : Set α
h : S.Finite
H0 : C ∅
H1 : ∀ {a : α} {s : Set α}, a ∈ S → s ⊆ S → a ∉ s → C s → C (insert a s)
⊢ C S
state_after: α : Type u
β : Type v
ι : Sort w
γ : Type x
C : Set α → Prop
S : Set α
h : S.Finite
H0 : C ∅
H1 : ∀ {a : α} {s : Set α}, a ∈ S → s ⊆ S → a ∉ s → C s → C (insert a s)
⊢ ∀ {a : α} {s : Set α}, a ∉ s → s.Finite → (fun s => s ⊆ S → C s) s → (fun s => s ⊆ S → C s) (insert a s)
tactic: refine @Set.Finite.induction_on α (fun s => s ⊆ S → C s) S h (fun _ => H0) ?_ Subset.rfl
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
C : Set α → Prop
S : Set α
h : S.Finite
H0 : C ∅
H1 : ∀ {a : α} {s : Set α}, a ∈ S → s ⊆ S → a ∉ s → C s → C (insert a s)
⊢ ∀ {a : α} {s : Set α}, a ∉ s → s.Finite → (fun s => s ⊆ S → C s) s → (fun s => s ⊆ S → C s) (insert a s)
state_after: α : Type u
β : Type v
ι : Sort w
γ : Type x
C : Set α → Prop
S : Set α
h : S.Finite
H0 : C ∅
H1 : ∀ {a : α} {s : Set α}, a ∈ S → s ⊆ S → a ∉ s → C s → C (insert a s)
a : α
s : Set α
has : a ∉ s
a✝ : s.Finite
hCs : s ⊆ S → C s
haS : insert a s ⊆ S
⊢ C (insert a s)
tactic: intro a s has _ hCs haS
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
C : Set α → Prop
S : Set α
h : S.Finite
H0 : C ∅
H1 : ∀ {a : α} {s : Set α}, a ∈ S → s ⊆ S → a ∉ s → C s → C (insert a s)
a : α
s : Set α
has : a ∉ s
a✝ : s.Finite
hCs : s ⊆ S → C s
haS : insert a s ⊆ S
⊢ C (insert a s)
state_after: α : Type u
β : Type v
ι : Sort w
γ : Type x
C : Set α → Prop
S : Set α
h : S.Finite
H0 : C ∅
H1 : ∀ {a : α} {s : Set α}, a ∈ S → s ⊆ S → a ∉ s → C s → C (insert a s)
a : α
s : Set α
has : a ∉ s
a✝ : s.Finite
hCs : s ⊆ S → C s
haS : a ∈ S ∧ s ⊆ S
⊢ C (insert a s)
tactic: rw [insert_subset_iff] at haS
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
C : Set α → Prop
S : Set α
h : S.Finite
H0 : C ∅
H1 : ∀ {a : α} {s : Set α}, a ∈ S → s ⊆ S → a ∉ s → C s → C (insert a s)
a : α
s : Set α
has : a ∉ s
a✝ : s.Finite
hCs : s ⊆ S → C s
haS : a ∈ S ∧ s ⊆ S
⊢ C (insert a s)
state_after: no goals
tactic: exact H1 haS.1 haS.2 has (hCs haS.2)
Theorem: CategoryTheory.NatIso.hcomp_inv
File: Mathlib/CategoryTheory/NatIso.lean

Proof steps:
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
E : Type u₃
inst✝ : Category.{v₃, u₃} E
F✝ G✝ : C ⥤ D
X Y : C
F G : C ⥤ D
H I : D ⥤ E
α : F ≅ G
β : H ≅ I
⊢ F ⋙ H ≅ G ⋙ I
state_after: case refine_1
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
E : Type u₃
inst✝ : Category.{v₃, u₃} E
F✝ G✝ : C ⥤ D
X Y : C
F G : C ⥤ D
H I : D ⥤ E
α : F ≅ G
β : H ≅ I
⊢ (α.hom ◫ β.hom) ≫ α.inv ◫ β.inv = 𝟙 (F ⋙ H)

case refine_2
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
E : Type u₃
inst✝ : Category.{v₃, u₃} E
F✝ G✝ : C ⥤ D
X Y : C
F G : C ⥤ D
H I : D ⥤ E
α : F ≅ G
β : H ≅ I
⊢ (α.inv ◫ β.inv) ≫ α.hom ◫ β.hom = 𝟙 (G ⋙ I)
tactic: refine ⟨α.hom ◫ β.hom, α.inv ◫ β.inv, ?_, ?_⟩
state_before: case refine_2
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
E : Type u₃
inst✝ : Category.{v₃, u₃} E
F✝ G✝ : C ⥤ D
X Y : C
F G : C ⥤ D
H I : D ⥤ E
α : F ≅ G
β : H ≅ I
⊢ (α.inv ◫ β.inv) ≫ α.hom ◫ β.hom = 𝟙 (G ⋙ I)
state_after: case refine_2.w.h
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
E : Type u₃
inst✝ : Category.{v₃, u₃} E
F✝ G✝ : C ⥤ D
X Y : C
F G : C ⥤ D
H I : D ⥤ E
α : F ≅ G
β : H ≅ I
x✝ : C
⊢ ((α.inv ◫ β.inv) ≫ α.hom ◫ β.hom).app x✝ = (𝟙 (G ⋙ I)).app x✝
tactic: ext
state_before: case refine_2.w.h
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
E : Type u₃
inst✝ : Category.{v₃, u₃} E
F✝ G✝ : C ⥤ D
X Y : C
F G : C ⥤ D
H I : D ⥤ E
α : F ≅ G
β : H ≅ I
x✝ : C
⊢ ((α.inv ◫ β.inv) ≫ α.hom ◫ β.hom).app x✝ = (𝟙 (G ⋙ I)).app x✝
state_after: case refine_2.w.h
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
E : Type u₃
inst✝ : Category.{v₃, u₃} E
F✝ G✝ : C ⥤ D
X Y : C
F G : C ⥤ D
H I : D ⥤ E
α : F ≅ G
β : H ≅ I
x✝ : C
⊢ ((α.inv ≫ α.hom) ◫ (β.inv ≫ β.hom)).app x✝ = (𝟙 (G ⋙ I)).app x✝
tactic: rw [← NatTrans.exchange]
state_before: case refine_2.w.h
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
E : Type u₃
inst✝ : Category.{v₃, u₃} E
F✝ G✝ : C ⥤ D
X Y : C
F G : C ⥤ D
H I : D ⥤ E
α : F ≅ G
β : H ≅ I
x✝ : C
⊢ ((α.inv ≫ α.hom) ◫ (β.inv ≫ β.hom)).app x✝ = (𝟙 (G ⋙ I)).app x✝
state_after: no goals
tactic: simp
Theorem: PiLp.nnnorm_equiv_symm_const'
File: Mathlib/Analysis/Normed/Lp/PiLp.lean

Proof steps:
state_before: p : ℝ≥0∞
𝕜 : Type u_1
ι : Type u_2
α : ι → Type u_3
β✝ : ι → Type u_4
inst✝⁸ : Fact (1 ≤ p)
inst✝⁷ : Fintype ι
inst✝⁶ : Semiring 𝕜
inst✝⁵ : (i : ι) → SeminormedAddCommGroup (α i)
inst✝⁴ : (i : ι) → SeminormedAddCommGroup (β✝ i)
inst✝³ : (i : ι) → Module 𝕜 (α i)
inst✝² : (i : ι) → Module 𝕜 (β✝ i)
c : 𝕜
β : Type u_5
inst✝¹ : SeminormedAddCommGroup β
inst✝ : Nonempty ι
b : β
⊢ ‖(WithLp.equiv p (ι → β)).symm (Function.const ι b)‖₊ = ↑(Fintype.card ι) ^ (1 / p).toReal * ‖b‖₊
state_after: case inl
𝕜 : Type u_1
ι : Type u_2
α : ι → Type u_3
β✝ : ι → Type u_4
inst✝⁸ : Fintype ι
inst✝⁷ : Semiring 𝕜
inst✝⁶ : (i : ι) → SeminormedAddCommGroup (α i)
inst✝⁵ : (i : ι) → SeminormedAddCommGroup (β✝ i)
inst✝⁴ : (i : ι) → Module 𝕜 (α i)
inst✝³ : (i : ι) → Module 𝕜 (β✝ i)
c : 𝕜
β : Type u_5
inst✝² : SeminormedAddCommGroup β
inst✝¹ : Nonempty ι
b : β
inst✝ : Fact (1 ≤ ⊤)
⊢ ‖(WithLp.equiv ⊤ (ι → β)).symm (Function.const ι b)‖₊ = ↑(Fintype.card ι) ^ (1 / ⊤).toReal * ‖b‖₊

case inr
p : ℝ≥0∞
𝕜 : Type u_1
ι : Type u_2
α : ι → Type u_3
β✝ : ι → Type u_4
inst✝⁸ : Fact (1 ≤ p)
inst✝⁷ : Fintype ι
inst✝⁶ : Semiring 𝕜
inst✝⁵ : (i : ι) → SeminormedAddCommGroup (α i)
inst✝⁴ : (i : ι) → SeminormedAddCommGroup (β✝ i)
inst✝³ : (i : ι) → Module 𝕜 (α i)
inst✝² : (i : ι) → Module 𝕜 (β✝ i)
c : 𝕜
β : Type u_5
inst✝¹ : SeminormedAddCommGroup β
inst✝ : Nonempty ι
b : β
hp : ¬p = ⊤
⊢ ‖(WithLp.equiv p (ι → β)).symm (Function.const ι b)‖₊ = ↑(Fintype.card ι) ^ (1 / p).toReal * ‖b‖₊
tactic: rcases em <| p = ∞ with (rfl | hp)
Theorem: IsAddSubmonoid.multiset_sum_mem
File: Mathlib/Deprecated/Submonoid.lean

Proof steps:
state_before: M✝ : Type u_1
inst✝² : Monoid M✝
s✝ : Set M✝
A : Type u_2
inst✝¹ : AddMonoid A
t : Set A
M : Type u_3
inst✝ : CommMonoid M
s : Set M
hs : IsSubmonoid s
m : Multiset M
⊢ (∀ a ∈ m, a ∈ s) → m.prod ∈ s
state_after: M✝ : Type u_1
inst✝² : Monoid M✝
s✝ : Set M✝
A : Type u_2
inst✝¹ : AddMonoid A
t : Set A
M : Type u_3
inst✝ : CommMonoid M
s : Set M
hs : IsSubmonoid s
m : Multiset M
l : List M
hl : ∀ a ∈ ⟦l⟧, a ∈ s
⊢ Multiset.prod ⟦l⟧ ∈ s
tactic: refine Quotient.inductionOn m fun l hl => ?_
state_before: M✝ : Type u_1
inst✝² : Monoid M✝
s✝ : Set M✝
A : Type u_2
inst✝¹ : AddMonoid A
t : Set A
M : Type u_3
inst✝ : CommMonoid M
s : Set M
hs : IsSubmonoid s
m : Multiset M
l : List M
hl : ∀ a ∈ ⟦l⟧, a ∈ s
⊢ Multiset.prod ⟦l⟧ ∈ s
state_after: M✝ : Type u_1
inst✝² : Monoid M✝
s✝ : Set M✝
A : Type u_2
inst✝¹ : AddMonoid A
t : Set A
M : Type u_3
inst✝ : CommMonoid M
s : Set M
hs : IsSubmonoid s
m : Multiset M
l : List M
hl : ∀ a ∈ ⟦l⟧, a ∈ s
⊢ l.prod ∈ s
tactic: rw [Multiset.quot_mk_to_coe, Multiset.prod_coe]
state_before: M✝ : Type u_1
inst✝² : Monoid M✝
s✝ : Set M✝
A : Type u_2
inst✝¹ : AddMonoid A
t : Set A
M : Type u_3
inst✝ : CommMonoid M
s : Set M
hs : IsSubmonoid s
m : Multiset M
l : List M
hl : ∀ a ∈ ⟦l⟧, a ∈ s
⊢ l.prod ∈ s
state_after: no goals
tactic: exact list_prod_mem hs hl
Theorem: Finset.powersetCard_eq_filter
File: Mathlib/Data/Finset/Powerset.lean

Proof steps:
state_before: α : Type u_1
s✝¹ t✝ : Finset α
n✝ : ?m.21109
s✝ t : Finset α
n : ℕ
s : Finset α
⊢ powersetCard n s = filter (fun x => x.card = n) s.powerset
state_after: case a
α : Type u_1
s✝¹ t✝ : Finset α
n✝ : ?m.21109
s✝ t : Finset α
n : ℕ
s a✝ : Finset α
⊢ a✝ ∈ powersetCard n s ↔ a✝ ∈ filter (fun x => x.card = n) s.powerset
tactic: ext
state_before: case a
α : Type u_1
s✝¹ t✝ : Finset α
n✝ : ?m.21109
s✝ t : Finset α
n : ℕ
s a✝ : Finset α
⊢ a✝ ∈ powersetCard n s ↔ a✝ ∈ filter (fun x => x.card = n) s.powerset
state_after: no goals
tactic: simp [mem_powersetCard]
Theorem: List.kerase_kerase
File: Mathlib/Data/List/Sigma.lean

Proof steps:
state_before: α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a a' : α
l : List (Sigma β)
⊢ kerase a (kerase a' l) = kerase a' (kerase a l)
state_after: case pos
α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a a' : α
l : List (Sigma β)
h : a = a'
⊢ kerase a (kerase a' l) = kerase a' (kerase a l)

case neg
α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a a' : α
l : List (Sigma β)
h : ¬a = a'
⊢ kerase a (kerase a' l) = kerase a' (kerase a l)
tactic: by_cases h : a = a'
state_before: case neg
α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a a' : α
l : List (Sigma β)
h : ¬a = a'
⊢ kerase a (kerase a' l) = kerase a' (kerase a l)
state_after: case neg.nil
α : Type u
β : α → Type v
l l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a a' : α
h : ¬a = a'
⊢ kerase a (kerase a' []) = kerase a' (kerase a [])

case neg.cons
α : Type u
β : α → Type v
l l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a a' : α
h : ¬a = a'
x : Sigma β
xs : List (Sigma β)
tail_ih✝ : kerase a (kerase a' xs) = kerase a' (kerase a xs)
⊢ kerase a (kerase a' (x :: xs)) = kerase a' (kerase a (x :: xs))
tactic: induction' l with x xs
Theorem: Multiset.add_eq_union_right_of_le
File: Mathlib/Data/Multiset/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type v
γ : Type u_2
inst✝ : DecidableEq α
x y z : Multiset α
h : z ≤ y
⊢ x + y = x ∪ z ↔ y = z ∧ x.Disjoint y
state_after: no goals
tactic: simpa only [and_comm] using add_eq_union_left_of_le h
Theorem: Lagrange.sum_basis
File: Mathlib/LinearAlgebra/Lagrange.lean

Proof steps:
state_before: F : Type u_1
inst✝¹ : Field F
ι : Type u_2
inst✝ : DecidableEq ι
s : Finset ι
v : ι → F
i j : ι
hvs : Set.InjOn v ↑s
hs : s.Nonempty
⊢ ∑ j ∈ s, Lagrange.basis s v j = 1
state_after: case refine_1
F : Type u_1
inst✝¹ : Field F
ι : Type u_2
inst✝ : DecidableEq ι
s : Finset ι
v : ι → F
i j : ι
hvs : Set.InjOn v ↑s
hs : s.Nonempty
⊢ (s.sup fun b => (Lagrange.basis s v b).degree) < ↑s.card

case refine_2
F : Type u_1
inst✝¹ : Field F
ι : Type u_2
inst✝ : DecidableEq ι
s : Finset ι
v : ι → F
i j : ι
hvs : Set.InjOn v ↑s
hs : s.Nonempty
⊢ degree 1 < ↑s.card

case refine_3
F : Type u_1
inst✝¹ : Field F
ι : Type u_2
inst✝ : DecidableEq ι
s : Finset ι
v : ι → F
i j : ι
hvs : Set.InjOn v ↑s
hs : s.Nonempty
⊢ ∀ i ∈ s, eval (v i) (∑ j ∈ s, Lagrange.basis s v j) = eval (v i) 1
tactic: refine eq_of_degrees_lt_of_eval_index_eq s hvs (lt_of_le_of_lt (degree_sum_le _ _) ?_) ?_ ?_
Theorem: Multiset.coe_ndinter
File: Mathlib/Data/Multiset/FinsetOps.lean

Proof steps:
state_before: α : Type u_1
inst✝ : DecidableEq α
s : Multiset α
l₁ l₂ : List α
⊢ (↑l₁).ndinter ↑l₂ = ↑(l₁ ∩ l₂)
state_after: α : Type u_1
inst✝ : DecidableEq α
s : Multiset α
l₁ l₂ : List α
⊢ List.filter (fun b => elem b l₂) l₁ ~ l₁ ∩ l₂
tactic: simp only [ndinter, mem_coe, filter_coe, coe_eq_coe, ← elem_eq_mem]
state_before: α : Type u_1
inst✝ : DecidableEq α
s : Multiset α
l₁ l₂ : List α
⊢ List.filter (fun b => elem b l₂) l₁ ~ l₁ ∩ l₂
state_after: no goals
tactic: apply Perm.refl
Theorem: FreeMagma.toFreeSemigroup_comp_map
File: Mathlib/Algebra/Free.lean

Proof steps:
state_before: α : Type u
β : Type v
f : α → β
⊢ toFreeSemigroup.comp (map f) = (FreeSemigroup.map f).comp toFreeSemigroup
state_after: case h
α : Type u
β : Type v
f : α → β
⊢ ⇑(toFreeSemigroup.comp (map f)) ∘ of = ⇑((FreeSemigroup.map f).comp toFreeSemigroup) ∘ of
tactic: ext1
state_before: case h
α : Type u
β : Type v
f : α → β
⊢ ⇑(toFreeSemigroup.comp (map f)) ∘ of = ⇑((FreeSemigroup.map f).comp toFreeSemigroup) ∘ of
state_after: no goals
tactic: rfl
Theorem: _private.Mathlib.Combinatorics.SimpleGraph.Regularity.Chunk.0.SzemerediRegularity.le_sum_card_subset_chunk_parts
File: Mathlib/Combinatorics/SimpleGraph/Regularity/Chunk.lean

Proof steps:
state_before: α : Type u_1
inst✝² : Fintype α
inst✝¹ : DecidableEq α
P : Finpartition univ
hP : P.IsEquipartition
G : SimpleGraph α
inst✝ : DecidableRel G.Adj
ε : ℝ
U : Finset α
hU : U ∈ P.parts
V : Finset α
𝒜 : Finset (Finset α)
s : Finset α
h𝒜 : 𝒜 ⊆ (chunk hP G ε hU).parts
hs : s ∈ 𝒜
⊢ ↑𝒜.card * ↑s.card * (↑m / (↑m + 1)) ≤ ↑(𝒜.sup id).card
state_after: α : Type u_1
inst✝² : Fintype α
inst✝¹ : DecidableEq α
P : Finpartition univ
hP : P.IsEquipartition
G : SimpleGraph α
inst✝ : DecidableRel G.Adj
ε : ℝ
U : Finset α
hU : U ∈ P.parts
V : Finset α
𝒜 : Finset (Finset α)
s : Finset α
h𝒜 : 𝒜 ⊆ (chunk hP G ε hU).parts
hs : s ∈ 𝒜
⊢ ↑𝒜.card * ↑m * ↑s.card ≤ ↑(𝒜.sup id).card * (↑m + 1)
tactic: rw [mul_div_assoc', div_le_iff coe_m_add_one_pos, mul_right_comm]
state_before: α : Type u_1
inst✝² : Fintype α
inst✝¹ : DecidableEq α
P : Finpartition univ
hP : P.IsEquipartition
G : SimpleGraph α
inst✝ : DecidableRel G.Adj
ε : ℝ
U : Finset α
hU : U ∈ P.parts
V : Finset α
𝒜 : Finset (Finset α)
s : Finset α
h𝒜 : 𝒜 ⊆ (chunk hP G ε hU).parts
hs : s ∈ 𝒜
⊢ ↑𝒜.card * ↑m * ↑s.card ≤ ↑(𝒜.sup id).card * (↑m + 1)
state_after: case refine_1
α : Type u_1
inst✝² : Fintype α
inst✝¹ : DecidableEq α
P : Finpartition univ
hP : P.IsEquipartition
G : SimpleGraph α
inst✝ : DecidableRel G.Adj
ε : ℝ
U : Finset α
hU : U ∈ P.parts
V : Finset α
𝒜 : Finset (Finset α)
s : Finset α
h𝒜 : 𝒜 ⊆ (chunk hP G ε hU).parts
hs : s ∈ 𝒜
⊢ ↑𝒜.card * ↑m ≤ ↑(𝒜.sup id).card

case refine_2
α : Type u_1
inst✝² : Fintype α
inst✝¹ : DecidableEq α
P : Finpartition univ
hP : P.IsEquipartition
G : SimpleGraph α
inst✝ : DecidableRel G.Adj
ε : ℝ
U : Finset α
hU : U ∈ P.parts
V : Finset α
𝒜 : Finset (Finset α)
s : Finset α
h𝒜 : 𝒜 ⊆ (chunk hP G ε hU).parts
hs : s ∈ 𝒜
⊢ ↑s.card ≤ ↑m + 1
tactic: refine mul_le_mul ?_ ?_ (cast_nonneg _) (cast_nonneg _)