ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: ContinuousMap.toLp_denseRange
File: Mathlib/MeasureTheory/Function/ContinuousMapDense.lean

Proof steps:
state_before: α : Type u_1
inst✝¹² : TopologicalSpace α
inst✝¹¹ : NormalSpace α
inst✝¹⁰ : R1Space α
inst✝⁹ : MeasurableSpace α
inst✝⁸ : BorelSpace α
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
μ : Measure α
p : ℝ≥0∞
inst✝⁶ : SecondCountableTopologyEither α E
_i : Fact (1 ≤ p)
hp : p ≠ ⊤
𝕜 : Type u_3
inst✝⁵ : NormedField 𝕜
inst✝⁴ : NormedAlgebra ℝ 𝕜
inst✝³ : NormedSpace 𝕜 E
inst✝² : CompactSpace α
inst✝¹ : μ.WeaklyRegular
inst✝ : IsFiniteMeasure μ
⊢ DenseRange ⇑(toLp p μ 𝕜)
state_after: α : Type u_1
inst✝¹² : TopologicalSpace α
inst✝¹¹ : NormalSpace α
inst✝¹⁰ : R1Space α
inst✝⁹ : MeasurableSpace α
inst✝⁸ : BorelSpace α
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
μ : Measure α
p : ℝ≥0∞
inst✝⁶ : SecondCountableTopologyEither α E
_i : Fact (1 ≤ p)
hp : p ≠ ⊤
𝕜 : Type u_3
inst✝⁵ : NormedField 𝕜
inst✝⁴ : NormedAlgebra ℝ 𝕜
inst✝³ : NormedSpace 𝕜 E
inst✝² : CompactSpace α
inst✝¹ : μ.WeaklyRegular
inst✝ : IsFiniteMeasure μ
⊢ range ⇑(BoundedContinuousFunction.toLp p μ 𝕜) ⊆ range ⇑(toLp p μ 𝕜)
tactic: refine (BoundedContinuousFunction.toLp_denseRange _ _ hp 𝕜).mono ?_
state_before: α : Type u_1
inst✝¹² : TopologicalSpace α
inst✝¹¹ : NormalSpace α
inst✝¹⁰ : R1Space α
inst✝⁹ : MeasurableSpace α
inst✝⁸ : BorelSpace α
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
μ : Measure α
p : ℝ≥0∞
inst✝⁶ : SecondCountableTopologyEither α E
_i : Fact (1 ≤ p)
hp : p ≠ ⊤
𝕜 : Type u_3
inst✝⁵ : NormedField 𝕜
inst✝⁴ : NormedAlgebra ℝ 𝕜
inst✝³ : NormedSpace 𝕜 E
inst✝² : CompactSpace α
inst✝¹ : μ.WeaklyRegular
inst✝ : IsFiniteMeasure μ
⊢ range ⇑(BoundedContinuousFunction.toLp p μ 𝕜) ⊆ range ⇑(toLp p μ 𝕜)
state_after: α : Type u_1
inst✝¹² : TopologicalSpace α
inst✝¹¹ : NormalSpace α
inst✝¹⁰ : R1Space α
inst✝⁹ : MeasurableSpace α
inst✝⁸ : BorelSpace α
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
μ : Measure α
p : ℝ≥0∞
inst✝⁶ : SecondCountableTopologyEither α E
_i : Fact (1 ≤ p)
hp : p ≠ ⊤
𝕜 : Type u_3
inst✝⁵ : NormedField 𝕜
inst✝⁴ : NormedAlgebra ℝ 𝕜
inst✝³ : NormedSpace 𝕜 E
inst✝² : CompactSpace α
inst✝¹ : μ.WeaklyRegular
inst✝ : IsFiniteMeasure μ
f : α →ᵇ E
⊢ (BoundedContinuousFunction.toLp p μ 𝕜) f ∈ range ⇑(toLp p μ 𝕜)
tactic: refine range_subset_iff.2 fun f ↦ ?_
state_before: α : Type u_1
inst✝¹² : TopologicalSpace α
inst✝¹¹ : NormalSpace α
inst✝¹⁰ : R1Space α
inst✝⁹ : MeasurableSpace α
inst✝⁸ : BorelSpace α
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
μ : Measure α
p : ℝ≥0∞
inst✝⁶ : SecondCountableTopologyEither α E
_i : Fact (1 ≤ p)
hp : p ≠ ⊤
𝕜 : Type u_3
inst✝⁵ : NormedField 𝕜
inst✝⁴ : NormedAlgebra ℝ 𝕜
inst✝³ : NormedSpace 𝕜 E
inst✝² : CompactSpace α
inst✝¹ : μ.WeaklyRegular
inst✝ : IsFiniteMeasure μ
f : α →ᵇ E
⊢ (BoundedContinuousFunction.toLp p μ 𝕜) f ∈ range ⇑(toLp p μ 𝕜)
state_after: no goals
tactic: exact ⟨f.toContinuousMap, rfl⟩
Theorem: Finset.affineCombination_congr
File: Mathlib/LinearAlgebra/AffineSpace/Combination.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
S : AffineSpace V P
ι : Type u_4
s : Finset ι
ι₂ : Type u_5
s₂ : Finset ι₂
w₁ w₂ : ι → k
hw : ∀ i ∈ s, w₁ i = w₂ i
p₁ p₂ : ι → P
hp : ∀ i ∈ s, p₁ i = p₂ i
⊢ (affineCombination k s p₁) w₁ = (affineCombination k s p₂) w₂
state_after: no goals
tactic: simp_rw [affineCombination_apply, s.weightedVSubOfPoint_congr hw hp]
Theorem: MeasureTheory.cylinder_eq_cylinder_union
File: Mathlib/MeasureTheory/Constructions/Cylinders.lean

Proof steps:
state_before: ι : Type u_1
α : ι → Type u_2
inst✝ : DecidableEq ι
I : Finset ι
S : Set ((i : { x // x ∈ I }) → α ↑i)
J : Finset ι
⊢ cylinder I S = cylinder (I ∪ J) ((fun f j => f ⟨↑j, ⋯⟩) ⁻¹' S)
state_after: case h
ι : Type u_1
α : ι → Type u_2
inst✝ : DecidableEq ι
I : Finset ι
S : Set ((i : { x // x ∈ I }) → α ↑i)
J : Finset ι
f : (i : ι) → α i
⊢ f ∈ cylinder I S ↔ f ∈ cylinder (I ∪ J) ((fun f j => f ⟨↑j, ⋯⟩) ⁻¹' S)
tactic: ext1 f
state_before: case h
ι : Type u_1
α : ι → Type u_2
inst✝ : DecidableEq ι
I : Finset ι
S : Set ((i : { x // x ∈ I }) → α ↑i)
J : Finset ι
f : (i : ι) → α i
⊢ f ∈ cylinder I S ↔ f ∈ cylinder (I ∪ J) ((fun f j => f ⟨↑j, ⋯⟩) ⁻¹' S)
state_after: no goals
tactic: simp only [mem_cylinder, mem_preimage]
Theorem: RingEquiv.prodZeroRing_symm_apply
File: Mathlib/Algebra/Ring/Prod.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
R : Type u_3
R' : Type u_4
S : Type u_5
S' : Type u_6
T : Type u_7
T' : Type u_8
inst✝⁴ : NonAssocSemiring R
inst✝³ : NonAssocSemiring S
inst✝² : NonAssocSemiring R'
inst✝¹ : NonAssocSemiring S'
inst✝ : Subsingleton S
⊢ ∀ (x y : R),
    { toFun := fun x => (x, 0), invFun := Prod.fst, left_inv := ⋯, right_inv := ⋯ }.toFun (x + y) =
      { toFun := fun x => (x, 0), invFun := Prod.fst, left_inv := ⋯, right_inv := ⋯ }.toFun x +
        { toFun := fun x => (x, 0), invFun := Prod.fst, left_inv := ⋯, right_inv := ⋯ }.toFun y
state_after: no goals
tactic: simp
state_before: α : Type u_1
β : Type u_2
R : Type u_3
R' : Type u_4
S : Type u_5
S' : Type u_6
T : Type u_7
T' : Type u_8
inst✝⁴ : NonAssocSemiring R
inst✝³ : NonAssocSemiring S
inst✝² : NonAssocSemiring R'
inst✝¹ : NonAssocSemiring S'
inst✝ : Subsingleton S
⊢ ∀ (x y : R),
    { toFun := fun x => (x, 0), invFun := Prod.fst, left_inv := ⋯, right_inv := ⋯ }.toFun (x * y) =
      { toFun := fun x => (x, 0), invFun := Prod.fst, left_inv := ⋯, right_inv := ⋯ }.toFun x *
        { toFun := fun x => (x, 0), invFun := Prod.fst, left_inv := ⋯, right_inv := ⋯ }.toFun y
state_after: no goals
tactic: simp
state_before: α : Type u_1
β : Type u_2
R : Type u_3
R' : Type u_4
S : Type u_5
S' : Type u_6
T : Type u_7
T' : Type u_8
inst✝⁴ : NonAssocSemiring R
inst✝³ : NonAssocSemiring S
inst✝² : NonAssocSemiring R'
inst✝¹ : NonAssocSemiring S'
inst✝ : Subsingleton S
x : R × S
⊢ (fun x => (x, 0)) x.1 = x
state_after: case mk
α : Type u_1
β : Type u_2
R : Type u_3
R' : Type u_4
S : Type u_5
S' : Type u_6
T : Type u_7
T' : Type u_8
inst✝⁴ : NonAssocSemiring R
inst✝³ : NonAssocSemiring S
inst✝² : NonAssocSemiring R'
inst✝¹ : NonAssocSemiring S'
inst✝ : Subsingleton S
fst✝ : R
snd✝ : S
⊢ (fun x => (x, 0)) (fst✝, snd✝).1 = (fst✝, snd✝)
tactic: cases x
state_before: case mk
α : Type u_1
β : Type u_2
R : Type u_3
R' : Type u_4
S : Type u_5
S' : Type u_6
T : Type u_7
T' : Type u_8
inst✝⁴ : NonAssocSemiring R
inst✝³ : NonAssocSemiring S
inst✝² : NonAssocSemiring R'
inst✝¹ : NonAssocSemiring S'
inst✝ : Subsingleton S
fst✝ : R
snd✝ : S
⊢ (fun x => (x, 0)) (fst✝, snd✝).1 = (fst✝, snd✝)
state_after: no goals
tactic: simp [eq_iff_true_of_subsingleton]
Theorem: UpperHalfPlane.abs_exp_two_pi_I_lt_one
File: Mathlib/Analysis/Complex/UpperHalfPlane/Exp.lean

Proof steps:
state_before: z : ℍ
⊢ ‖cexp (2 * ↑π * Complex.I * ↑z)‖ < 1
state_after: z : ℍ
⊢ 0 < 2 * π * z.im
tactic: simp only [coe_I, Complex.norm_eq_abs, Complex.abs_exp, mul_re, re_ofNat, ofReal_re, im_ofNat,
    ofReal_im, mul_zero, sub_zero, Complex.I_re, mul_im, zero_mul, add_zero, Complex.I_im, mul_one,
    sub_self, coe_re, coe_im, zero_sub, exp_lt_one_iff, Left.neg_neg_iff]
state_before: z : ℍ
⊢ 0 < 2 * π * z.im
state_after: no goals
tactic: positivity
Theorem: Set.bijOn_empty_iff_left
File: Mathlib/Data/Set/Function.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
s s₁ s₂ : Set α
t t₁ t₂ : Set β
p : Set γ
f f₁ f₂ f₃ : α → β
g g₁ g₂ : β → γ
f' f₁' f₂' : β → α
g' : γ → β
a : α
b : β
h : BijOn f s ∅
⊢ s = ∅
state_after: no goals
tactic: simpa using h.mapsTo
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
s s₁ s₂ : Set α
t t₁ t₂ : Set β
p : Set γ
f f₁ f₂ f₃ : α → β
g g₁ g₂ : β → γ
f' f₁' f₂' : β → α
g' : γ → β
a : α
b : β
⊢ s = ∅ → BijOn f s ∅
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
s₁ s₂ : Set α
t t₁ t₂ : Set β
p : Set γ
f f₁ f₂ f₃ : α → β
g g₁ g₂ : β → γ
f' f₁' f₂' : β → α
g' : γ → β
a : α
b : β
⊢ BijOn f ∅ ∅
tactic: rintro rfl
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
s₁ s₂ : Set α
t t₁ t₂ : Set β
p : Set γ
f f₁ f₂ f₃ : α → β
g g₁ g₂ : β → γ
f' f₁' f₂' : β → α
g' : γ → β
a : α
b : β
⊢ BijOn f ∅ ∅
state_after: no goals
tactic: exact bijOn_empty f
Theorem: Subring.closure_induction'
File: Mathlib/Algebra/Ring/Subring/Basic.lean

Proof steps:
state_before: R : Type u
S : Type v
T : Type w
inst✝² : Ring R
inst✝¹ : Ring S
inst✝ : Ring T
s : Set R
p : (x : R) → x ∈ closure s → Prop
mem : ∀ (x : R) (h : x ∈ s), p x ⋯
zero : p 0 ⋯
one : p 1 ⋯
add : ∀ (x : R) (hx : x ∈ closure s) (y : R) (hy : y ∈ closure s), p x hx → p y hy → p (x + y) ⋯
neg : ∀ (x : R) (hx : x ∈ closure s), p x hx → p (-x) ⋯
mul : ∀ (x : R) (hx : x ∈ closure s) (y : R) (hy : y ∈ closure s), p x hx → p y hy → p (x * y) ⋯
a : R
ha : a ∈ closure s
⊢ p a ha
state_after: R : Type u
S : Type v
T : Type w
inst✝² : Ring R
inst✝¹ : Ring S
inst✝ : Ring T
s : Set R
p : (x : R) → x ∈ closure s → Prop
mem : ∀ (x : R) (h : x ∈ s), p x ⋯
zero : p 0 ⋯
one : p 1 ⋯
add : ∀ (x : R) (hx : x ∈ closure s) (y : R) (hy : y ∈ closure s), p x hx → p y hy → p (x + y) ⋯
neg : ∀ (x : R) (hx : x ∈ closure s), p x hx → p (-x) ⋯
mul : ∀ (x : R) (hx : x ∈ closure s) (y : R) (hy : y ∈ closure s), p x hx → p y hy → p (x * y) ⋯
a : R
ha : a ∈ closure s
⊢ ∃ (x : a ∈ closure s), p a x
tactic: refine Exists.elim ?_ fun (ha : a ∈ closure s) (hc : p a ha) => hc
state_before: R : Type u
S : Type v
T : Type w
inst✝² : Ring R
inst✝¹ : Ring S
inst✝ : Ring T
s : Set R
p : (x : R) → x ∈ closure s → Prop
mem : ∀ (x : R) (h : x ∈ s), p x ⋯
zero : p 0 ⋯
one : p 1 ⋯
add : ∀ (x : R) (hx : x ∈ closure s) (y : R) (hy : y ∈ closure s), p x hx → p y hy → p (x + y) ⋯
neg : ∀ (x : R) (hx : x ∈ closure s), p x hx → p (-x) ⋯
mul : ∀ (x : R) (hx : x ∈ closure s) (y : R) (hy : y ∈ closure s), p x hx → p y hy → p (x * y) ⋯
a : R
ha : a ∈ closure s
⊢ ∃ (x : a ∈ closure s), p a x
state_after: case refine_1
R : Type u
S : Type v
T : Type w
inst✝² : Ring R
inst✝¹ : Ring S
inst✝ : Ring T
s : Set R
p : (x : R) → x ∈ closure s → Prop
mem : ∀ (x : R) (h : x ∈ s), p x ⋯
zero : p 0 ⋯
one : p 1 ⋯
add : ∀ (x : R) (hx : x ∈ closure s) (y : R) (hy : y ∈ closure s), p x hx → p y hy → p (x + y) ⋯
neg : ∀ (x : R) (hx : x ∈ closure s), p x hx → p (-x) ⋯
mul : ∀ (x : R) (hx : x ∈ closure s) (y : R) (hy : y ∈ closure s), p x hx → p y hy → p (x * y) ⋯
a : R
ha : a ∈ closure s
⊢ ∀ (x y : R),
    (∃ (x_1 : x ∈ closure s), p x x_1) → (∃ (x : y ∈ closure s), p y x) → ∃ (x_1 : x + y ∈ closure s), p (x + y) x_1

case refine_2
R : Type u
S : Type v
T : Type w
inst✝² : Ring R
inst✝¹ : Ring S
inst✝ : Ring T
s : Set R
p : (x : R) → x ∈ closure s → Prop
mem : ∀ (x : R) (h : x ∈ s), p x ⋯
zero : p 0 ⋯
one : p 1 ⋯
add : ∀ (x : R) (hx : x ∈ closure s) (y : R) (hy : y ∈ closure s), p x hx → p y hy → p (x + y) ⋯
neg : ∀ (x : R) (hx : x ∈ closure s), p x hx → p (-x) ⋯
mul : ∀ (x : R) (hx : x ∈ closure s) (y : R) (hy : y ∈ closure s), p x hx → p y hy → p (x * y) ⋯
a : R
ha : a ∈ closure s
⊢ ∀ (x y : R),
    (∃ (x_1 : x ∈ closure s), p x x_1) → (∃ (x : y ∈ closure s), p y x) → ∃ (x_1 : x * y ∈ closure s), p (x * y) x_1
tactic: refine
    closure_induction ha (fun m hm => ⟨subset_closure hm, mem m hm⟩) ⟨zero_mem _, zero⟩
      ⟨one_mem _, one⟩ ?_ (fun x hx => hx.elim fun hx' hx => ⟨neg_mem hx', neg _ _ hx⟩) ?_
Theorem: CategoryTheory.Prod.braiding_unitIso_inv_app
File: Mathlib/CategoryTheory/Products/Basic.lean

Proof steps:
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
X : C × D
⊢ (𝟭 (C × D)).obj X = (swap C D ⋙ swap D C).obj X
state_after: no goals
tactic: simp
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
X : D × C
⊢ (swap D C ⋙ swap C D).obj X = (𝟭 (D × C)).obj X
state_after: no goals
tactic: simp
Theorem: quadraticChar_neg_two
File: Mathlib/NumberTheory/LegendreSymbol/QuadraticChar/GaussSum.lean

Proof steps:
state_before: F : Type u_1
inst✝² : Field F
inst✝¹ : Fintype F
inst✝ : DecidableEq F
hF : ringChar F ≠ 2
⊢ (quadraticChar F) (-2) = χ₈' ↑(Fintype.card F)
state_after: no goals
tactic: rw [(by norm_num : (-2 : F) = -1 * 2), map_mul, χ₈'_eq_χ₄_mul_χ₈, quadraticChar_neg_one hF,
    quadraticChar_two hF, @cast_natCast _ (ZMod 4) _ _ _ (by decide : 4 ∣ 8)]
Theorem: Nat.bit_mod_two
File: Mathlib/Data/Nat/Bitwise.lean

Proof steps:
state_before: f : Bool → Bool → Bool
a : Bool
x : ℕ
⊢ bit a x % 2 = if a = true then 1 else 0
state_after: f : Bool → Bool → Bool
a : Bool
x : ℕ
⊢ (if a = true then 2 * x + 1 else 2 * x) % 2 = if a = true then 1 else 0
tactic: simp only [bit, ite_apply, ← mul_two, Bool.cond_eq_ite]
state_before: f : Bool → Bool → Bool
a : Bool
x : ℕ
⊢ (if a = true then 2 * x + 1 else 2 * x) % 2 = if a = true then 1 else 0
state_after: no goals
tactic: split_ifs <;> simp [Nat.add_mod]
Theorem: NonUnitalRingHom.comp_zero
File: Mathlib/Algebra/Ring/Hom/Defs.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : NonUnitalNonAssocSemiring α
inst✝¹ : NonUnitalNonAssocSemiring β
inst✝ : NonUnitalNonAssocSemiring γ
g✝ : β →ₙ+* γ
f : α →ₙ+* β
g : β →ₙ+* γ
⊢ g.comp 0 = 0
state_after: case a
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : NonUnitalNonAssocSemiring α
inst✝¹ : NonUnitalNonAssocSemiring β
inst✝ : NonUnitalNonAssocSemiring γ
g✝ : β →ₙ+* γ
f : α →ₙ+* β
g : β →ₙ+* γ
x✝ : α
⊢ (g.comp 0) x✝ = 0 x✝
tactic: ext
state_before: case a
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : NonUnitalNonAssocSemiring α
inst✝¹ : NonUnitalNonAssocSemiring β
inst✝ : NonUnitalNonAssocSemiring γ
g✝ : β →ₙ+* γ
f : α →ₙ+* β
g : β →ₙ+* γ
x✝ : α
⊢ (g.comp 0) x✝ = 0 x✝
state_after: no goals
tactic: simp
Theorem: Polynomial.support_X_pow
File: Mathlib/Algebra/Polynomial/Basic.lean

Proof steps:
state_before: R : Type u
a b : R
m n✝ : ℕ
inst✝ : Semiring R
p q : R[X]
H : ¬1 = 0
n : ℕ
⊢ (X ^ n).support = {n}
state_after: case h.e'_2.h.e'_3
R : Type u
a b : R
m n✝ : ℕ
inst✝ : Semiring R
p q : R[X]
H : ¬1 = 0
n : ℕ
⊢ X ^ n = (monomial n) 1
tactic: convert support_monomial n H
state_before: case h.e'_2.h.e'_3
R : Type u
a b : R
m n✝ : ℕ
inst✝ : Semiring R
p q : R[X]
H : ¬1 = 0
n : ℕ
⊢ X ^ n = (monomial n) 1
state_after: no goals
tactic: exact X_pow_eq_monomial n
Theorem: Matrix.linfty_opNorm_def
File: Mathlib/Analysis/Matrix.lean

Proof steps:
state_before: R : Type u_1
l : Type u_2
m : Type u_3
n : Type u_4
α : Type u_5
β : Type u_6
ι : Type u_7
inst✝⁴ : Fintype l
inst✝³ : Fintype m
inst✝² : Fintype n
inst✝¹ : Unique ι
inst✝ : SeminormedAddCommGroup α
A : Matrix m n α
⊢ ‖A‖ = ↑(Finset.univ.sup fun i => ∑ j : n, ‖A i j‖₊)
state_after: R : Type u_1
l : Type u_2
m : Type u_3
n : Type u_4
α : Type u_5
β : Type u_6
ι : Type u_7
inst✝⁴ : Fintype l
inst✝³ : Fintype m
inst✝² : Fintype n
inst✝¹ : Unique ι
inst✝ : SeminormedAddCommGroup α
A : Matrix m n α
⊢ ‖fun i => (WithLp.equiv 1 (n → α)).symm (A i)‖ = ↑(Finset.univ.sup fun i => ∑ j : n, ‖A i j‖₊)
tactic: change ‖fun i => (WithLp.equiv 1 _).symm (A i)‖ = _
state_before: R : Type u_1
l : Type u_2
m : Type u_3
n : Type u_4
α : Type u_5
β : Type u_6
ι : Type u_7
inst✝⁴ : Fintype l
inst✝³ : Fintype m
inst✝² : Fintype n
inst✝¹ : Unique ι
inst✝ : SeminormedAddCommGroup α
A : Matrix m n α
⊢ ‖fun i => (WithLp.equiv 1 (n → α)).symm (A i)‖ = ↑(Finset.univ.sup fun i => ∑ j : n, ‖A i j‖₊)
state_after: no goals
tactic: simp [Pi.norm_def, PiLp.nnnorm_eq_sum ENNReal.one_ne_top]
Theorem: Matrix.IsHermitian.fromBlocks₁₁
File: Mathlib/LinearAlgebra/Matrix/SchurComplement.lean

Proof steps:
state_before: l : Type u_1
m : Type u_2
n : Type u_3
α : Type u_4
𝕜 : Type u_5
inst✝⁵ : CommRing 𝕜
inst✝⁴ : PartialOrder 𝕜
inst✝³ : StarRing 𝕜
inst✝² : StarOrderedRing 𝕜
inst✝¹ : Fintype m
inst✝ : DecidableEq m
A : Matrix m m 𝕜
B : Matrix m n 𝕜
D : Matrix n n 𝕜
hA : A.IsHermitian
⊢ (Matrix.fromBlocks A B Bᴴ D).IsHermitian ↔ (D - Bᴴ * A⁻¹ * B).IsHermitian
state_after: l : Type u_1
m : Type u_2
n : Type u_3
α : Type u_4
𝕜 : Type u_5
inst✝⁵ : CommRing 𝕜
inst✝⁴ : PartialOrder 𝕜
inst✝³ : StarRing 𝕜
inst✝² : StarOrderedRing 𝕜
inst✝¹ : Fintype m
inst✝ : DecidableEq m
A : Matrix m m 𝕜
B : Matrix m n 𝕜
D : Matrix n n 𝕜
hA : A.IsHermitian
hBAB : (Bᴴ * A⁻¹ * B).IsHermitian
⊢ (Matrix.fromBlocks A B Bᴴ D).IsHermitian ↔ (D - Bᴴ * A⁻¹ * B).IsHermitian
tactic: have hBAB : (Bᴴ * A⁻¹ * B).IsHermitian := by
    apply isHermitian_conjTranspose_mul_mul
    apply hA.inv
state_before: l : Type u_1
m : Type u_2
n : Type u_3
α : Type u_4
𝕜 : Type u_5
inst✝⁵ : CommRing 𝕜
inst✝⁴ : PartialOrder 𝕜
inst✝³ : StarRing 𝕜
inst✝² : StarOrderedRing 𝕜
inst✝¹ : Fintype m
inst✝ : DecidableEq m
A : Matrix m m 𝕜
B : Matrix m n 𝕜
D : Matrix n n 𝕜
hA : A.IsHermitian
hBAB : (Bᴴ * A⁻¹ * B).IsHermitian
⊢ (Matrix.fromBlocks A B Bᴴ D).IsHermitian ↔ (D - Bᴴ * A⁻¹ * B).IsHermitian
state_after: l : Type u_1
m : Type u_2
n : Type u_3
α : Type u_4
𝕜 : Type u_5
inst✝⁵ : CommRing 𝕜
inst✝⁴ : PartialOrder 𝕜
inst✝³ : StarRing 𝕜
inst✝² : StarOrderedRing 𝕜
inst✝¹ : Fintype m
inst✝ : DecidableEq m
A : Matrix m m 𝕜
B : Matrix m n 𝕜
D : Matrix n n 𝕜
hA : A.IsHermitian
hBAB : (Bᴴ * A⁻¹ * B).IsHermitian
⊢ A.IsHermitian ∧ Bᴴ = Bᴴ ∧ Bᴴᴴ = B ∧ D.IsHermitian ↔ (D - Bᴴ * A⁻¹ * B).IsHermitian
tactic: rw [isHermitian_fromBlocks_iff]
state_before: l : Type u_1
m : Type u_2
n : Type u_3
α : Type u_4
𝕜 : Type u_5
inst✝⁵ : CommRing 𝕜
inst✝⁴ : PartialOrder 𝕜
inst✝³ : StarRing 𝕜
inst✝² : StarOrderedRing 𝕜
inst✝¹ : Fintype m
inst✝ : DecidableEq m
A : Matrix m m 𝕜
B : Matrix m n 𝕜
D : Matrix n n 𝕜
hA : A.IsHermitian
hBAB : (Bᴴ * A⁻¹ * B).IsHermitian
⊢ A.IsHermitian ∧ Bᴴ = Bᴴ ∧ Bᴴᴴ = B ∧ D.IsHermitian ↔ (D - Bᴴ * A⁻¹ * B).IsHermitian
state_after: case mp
l : Type u_1
m : Type u_2
n : Type u_3
α : Type u_4
𝕜 : Type u_5
inst✝⁵ : CommRing 𝕜
inst✝⁴ : PartialOrder 𝕜
inst✝³ : StarRing 𝕜
inst✝² : StarOrderedRing 𝕜
inst✝¹ : Fintype m
inst✝ : DecidableEq m
A : Matrix m m 𝕜
B : Matrix m n 𝕜
D : Matrix n n 𝕜
hA : A.IsHermitian
hBAB : (Bᴴ * A⁻¹ * B).IsHermitian
⊢ A.IsHermitian ∧ Bᴴ = Bᴴ ∧ Bᴴᴴ = B ∧ D.IsHermitian → (D - Bᴴ * A⁻¹ * B).IsHermitian

case mpr
l : Type u_1
m : Type u_2
n : Type u_3
α : Type u_4
𝕜 : Type u_5
inst✝⁵ : CommRing 𝕜
inst✝⁴ : PartialOrder 𝕜
inst✝³ : StarRing 𝕜
inst✝² : StarOrderedRing 𝕜
inst✝¹ : Fintype m
inst✝ : DecidableEq m
A : Matrix m m 𝕜
B : Matrix m n 𝕜
D : Matrix n n 𝕜
hA : A.IsHermitian
hBAB : (Bᴴ * A⁻¹ * B).IsHermitian
⊢ (D - Bᴴ * A⁻¹ * B).IsHermitian → A.IsHermitian ∧ Bᴴ = Bᴴ ∧ Bᴴᴴ = B ∧ D.IsHermitian
tactic: constructor
Theorem: List.length_injective_iff
File: Mathlib/Data/List/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
⊢ Injective length ↔ Subsingleton α
state_after: case mp
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
⊢ Injective length → Subsingleton α

case mpr
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
⊢ Subsingleton α → Injective length
tactic: constructor
Theorem: AddChar.to_mulShift_inj_of_isPrimitive
File: Mathlib/NumberTheory/LegendreSymbol/AddCharacter.lean

Proof steps:
state_before: R : Type u
inst✝¹ : CommRing R
R' : Type v
inst✝ : CommMonoid R'
ψ : AddChar R R'
hψ : ψ.IsPrimitive
⊢ Function.Injective ψ.mulShift
state_after: R : Type u
inst✝¹ : CommRing R
R' : Type v
inst✝ : CommMonoid R'
ψ : AddChar R R'
hψ : ψ.IsPrimitive
a b : R
h : ψ.mulShift a = ψ.mulShift b
⊢ a = b
tactic: intro a b h
state_before: R : Type u
inst✝¹ : CommRing R
R' : Type v
inst✝ : CommMonoid R'
ψ : AddChar R R'
hψ : ψ.IsPrimitive
a b : R
h : ψ.mulShift a = ψ.mulShift b
⊢ a = b
state_after: R : Type u
inst✝¹ : CommRing R
R' : Type v
inst✝ : CommMonoid R'
ψ : AddChar R R'
hψ : ψ.IsPrimitive
a b : R
h : ψ.mulShift a * ψ.mulShift (-b) = ψ.mulShift b * ψ.mulShift (-b)
⊢ a = b
tactic: apply_fun fun x => x * mulShift ψ (-b) at h
state_before: R : Type u
inst✝¹ : CommRing R
R' : Type v
inst✝ : CommMonoid R'
ψ : AddChar R R'
hψ : ψ.IsPrimitive
a b : R
h : ψ.mulShift a * ψ.mulShift (-b) = ψ.mulShift b * ψ.mulShift (-b)
⊢ a = b
state_after: R : Type u
inst✝¹ : CommRing R
R' : Type v
inst✝ : CommMonoid R'
ψ : AddChar R R'
hψ : ψ.IsPrimitive
a b : R
h : ψ.mulShift (a + -b) = 1
⊢ a = b
tactic: simp only [mulShift_mul, mulShift_zero, add_right_neg, mulShift_apply] at h
Theorem: AlgebraicGeometry.ProjectiveSpectrum.Proj.isLocalization_atPrime
File: Mathlib/AlgebraicGeometry/ProjectiveSpectrum/Scheme.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing A
inst✝¹ : Algebra R A
𝒜 : ℕ → Submodule R A
inst✝ : GradedAlgebra 𝒜
f : A
x : ↥(pbo f)
m : ℕ
f_deg : f ∈ 𝒜 m
hm : 0 < m
⊢ IsLocalization ((toSpec 𝒜 f).val.base x).asIdeal.primeCompl (AtPrime 𝒜 (↑x).asHomogeneousIdeal.toIdeal)
state_after: R : Type u_1
A : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing A
inst✝¹ : Algebra R A
𝒜 : ℕ → Submodule R A
inst✝ : GradedAlgebra 𝒜
f : A
x : ↥(pbo f)
m : ℕ
f_deg : f ∈ 𝒜 m
hm : 0 < m
this : Algebra (A⁰_ f) (AtPrime 𝒜 (↑x).asHomogeneousIdeal.toIdeal) := (mapId 𝒜 ⋯).toAlgebra
⊢ IsLocalization ((toSpec 𝒜 f).val.base x).asIdeal.primeCompl (AtPrime 𝒜 (↑x).asHomogeneousIdeal.toIdeal)
tactic: letI : Algebra (Away 𝒜 f) (AtPrime 𝒜 x.1.asHomogeneousIdeal.toIdeal) :=
    (mapId 𝒜 (Submonoid.powers_le.mpr x.2)).toAlgebra
state_before: R : Type u_1
A : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing A
inst✝¹ : Algebra R A
𝒜 : ℕ → Submodule R A
inst✝ : GradedAlgebra 𝒜
f : A
x : ↥(pbo f)
m : ℕ
f_deg : f ∈ 𝒜 m
hm : 0 < m
this : Algebra (A⁰_ f) (AtPrime 𝒜 (↑x).asHomogeneousIdeal.toIdeal) := (mapId 𝒜 ⋯).toAlgebra
⊢ IsLocalization ((toSpec 𝒜 f).val.base x).asIdeal.primeCompl (AtPrime 𝒜 (↑x).asHomogeneousIdeal.toIdeal)
state_after: case map_units'
R : Type u_1
A : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing A
inst✝¹ : Algebra R A
𝒜 : ℕ → Submodule R A
inst✝ : GradedAlgebra 𝒜
f : A
x : ↥(pbo f)
m : ℕ
f_deg : f ∈ 𝒜 m
hm : 0 < m
this : Algebra (A⁰_ f) (AtPrime 𝒜 (↑x).asHomogeneousIdeal.toIdeal) := (mapId 𝒜 ⋯).toAlgebra
⊢ ∀ (y : ↥((toSpec 𝒜 f).val.base x).asIdeal.primeCompl),
    IsUnit ((algebraMap (A⁰_ f) (AtPrime 𝒜 (↑x).asHomogeneousIdeal.toIdeal)) ↑y)

case surj'
R : Type u_1
A : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing A
inst✝¹ : Algebra R A
𝒜 : ℕ → Submodule R A
inst✝ : GradedAlgebra 𝒜
f : A
x : ↥(pbo f)
m : ℕ
f_deg : f ∈ 𝒜 m
hm : 0 < m
this : Algebra (A⁰_ f) (AtPrime 𝒜 (↑x).asHomogeneousIdeal.toIdeal) := (mapId 𝒜 ⋯).toAlgebra
⊢ ∀ (z : AtPrime 𝒜 (↑x).asHomogeneousIdeal.toIdeal),
    ∃ x_1,
      z * (algebraMap (A⁰_ f) (AtPrime 𝒜 (↑x).asHomogeneousIdeal.toIdeal)) ↑x_1.2 =
        (algebraMap (A⁰_ f) (AtPrime 𝒜 (↑x).asHomogeneousIdeal.toIdeal)) x_1.1

case exists_of_eq
R : Type u_1
A : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing A
inst✝¹ : Algebra R A
𝒜 : ℕ → Submodule R A
inst✝ : GradedAlgebra 𝒜
f : A
x : ↥(pbo f)
m : ℕ
f_deg : f ∈ 𝒜 m
hm : 0 < m
this : Algebra (A⁰_ f) (AtPrime 𝒜 (↑x).asHomogeneousIdeal.toIdeal) := (mapId 𝒜 ⋯).toAlgebra
⊢ ∀ {x_1 y : A⁰_ f},
    (algebraMap (A⁰_ f) (AtPrime 𝒜 (↑x).asHomogeneousIdeal.toIdeal)) x_1 =
        (algebraMap (A⁰_ f) (AtPrime 𝒜 (↑x).asHomogeneousIdeal.toIdeal)) y →
      ∃ c, ↑c * x_1 = ↑c * y
tactic: constructor