ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Complex.HadamardThreeLines.norm_le_interp_of_mem_verticalClosedStrip'
File: Mathlib/Analysis/Complex/Hadamard.lean

Proof steps:
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
f✝ f : ℂ → E
z : ℂ
a b : ℝ
hz : z ∈ verticalClosedStrip 0 1
hd : DiffContOnCl ℂ f (verticalStrip 0 1)
hB : BddAbove (norm ∘ f '' verticalClosedStrip 0 1)
ha : ∀ z ∈ re ⁻¹' {0}, ‖f z‖ ≤ a
hb : ∀ z ∈ re ⁻¹' {1}, ‖f z‖ ≤ b
this : ‖interpStrip f z‖ ≤ sSupNormIm f 0 ^ (1 - z.re) * sSupNormIm f 1 ^ z.re
⊢ ‖f z‖ ≤ a ^ (1 - z.re) * b ^ z.re
state_after: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
f✝ f : ℂ → E
z : ℂ
a b : ℝ
hz : z ∈ verticalClosedStrip 0 1
hd : DiffContOnCl ℂ f (verticalStrip 0 1)
hB : BddAbove (norm ∘ f '' verticalClosedStrip 0 1)
ha : ∀ z ∈ re ⁻¹' {0}, ‖f z‖ ≤ a
hb : ∀ z ∈ re ⁻¹' {1}, ‖f z‖ ≤ b
this : ‖interpStrip f z‖ ≤ sSupNormIm f 0 ^ (1 - z.re) * sSupNormIm f 1 ^ z.re
⊢ sSupNormIm f 0 ^ (1 - z.re) * sSupNormIm f 1 ^ z.re ≤ a ^ (1 - z.re) * b ^ z.re
tactic: apply (norm_le_interpStrip_of_mem_verticalClosedStrip f hz hd hB).trans (this.trans _)
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
f✝ f : ℂ → E
z : ℂ
a b : ℝ
hz : z ∈ verticalClosedStrip 0 1
hd : DiffContOnCl ℂ f (verticalStrip 0 1)
hB : BddAbove (norm ∘ f '' verticalClosedStrip 0 1)
ha : ∀ z ∈ re ⁻¹' {0}, ‖f z‖ ≤ a
hb : ∀ z ∈ re ⁻¹' {1}, ‖f z‖ ≤ b
this : ‖interpStrip f z‖ ≤ sSupNormIm f 0 ^ (1 - z.re) * sSupNormIm f 1 ^ z.re
⊢ sSupNormIm f 0 ^ (1 - z.re) * sSupNormIm f 1 ^ z.re ≤ a ^ (1 - z.re) * b ^ z.re
state_after: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
f✝ f : ℂ → E
z : ℂ
a b : ℝ
hz : z ∈ verticalClosedStrip 0 1
hd : DiffContOnCl ℂ f (verticalStrip 0 1)
hB : BddAbove (norm ∘ f '' verticalClosedStrip 0 1)
ha : ∀ z ∈ re ⁻¹' {0}, ‖f z‖ ≤ a
hb : ∀ z ∈ re ⁻¹' {1}, ‖f z‖ ≤ b
this : ‖interpStrip f z‖ ≤ sSupNormIm f 0 ^ (1 - z.re) * sSupNormIm f 1 ^ z.re
⊢ 0 ≤ b ^ z.re

E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
f✝ f : ℂ → E
z : ℂ
a b : ℝ
hz : z ∈ verticalClosedStrip 0 1
hd : DiffContOnCl ℂ f (verticalStrip 0 1)
hB : BddAbove (norm ∘ f '' verticalClosedStrip 0 1)
ha : ∀ z ∈ re ⁻¹' {0}, ‖f z‖ ≤ a
hb : ∀ z ∈ re ⁻¹' {1}, ‖f z‖ ≤ b
this : ‖interpStrip f z‖ ≤ sSupNormIm f 0 ^ (1 - z.re) * sSupNormIm f 1 ^ z.re
⊢ sSupNormIm f 0 ^ (1 - z.re) ≤ a ^ (1 - z.re)

E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
f✝ f : ℂ → E
z : ℂ
a b : ℝ
hz : z ∈ verticalClosedStrip 0 1
hd : DiffContOnCl ℂ f (verticalStrip 0 1)
hB : BddAbove (norm ∘ f '' verticalClosedStrip 0 1)
ha : ∀ z ∈ re ⁻¹' {0}, ‖f z‖ ≤ a
hb : ∀ z ∈ re ⁻¹' {1}, ‖f z‖ ≤ b
this : ‖interpStrip f z‖ ≤ sSupNormIm f 0 ^ (1 - z.re) * sSupNormIm f 1 ^ z.re
⊢ sSupNormIm f 1 ^ z.re ≤ b ^ z.re
tactic: apply mul_le_mul_of_nonneg _ _ (Real.rpow_nonneg (sSupNormIm_nonneg f _) _)
Theorem: MulAction.isBlock_singleton
File: Mathlib/GroupTheory/GroupAction/Blocks.lean

Proof steps:
state_before: G : Type u_1
X : Type u_2
inst✝ : SMul G X
a : X
⊢ IsBlock G {a}
state_after: no goals
tactic: simp [IsBlock.def, Classical.or_iff_not_imp_left]
Theorem: LaurentPolynomial.invert_C
File: Mathlib/Algebra/Polynomial/Laurent.lean

Proof steps:
state_before: R✝ : Type u_1
R : Type u_2
inst✝ : CommSemiring R
t : R
⊢ invert (C t) = C t
state_after: case h
R✝ : Type u_1
R : Type u_2
inst✝ : CommSemiring R
t : R
a✝ : ℤ
⊢ (invert (C t)) a✝ = (C t) a✝
tactic: ext
state_before: case h
R✝ : Type u_1
R : Type u_2
inst✝ : CommSemiring R
t : R
a✝ : ℤ
⊢ (invert (C t)) a✝ = (C t) a✝
state_after: no goals
tactic: simp
Theorem: CliffordAlgebraComplex.toComplex_comp_ofComplex
File: Mathlib/LinearAlgebra/CliffordAlgebra/Equivs.lean

Proof steps:
state_before: ⊢ toComplex.comp ofComplex = AlgHom.id ℝ ℂ
state_after: case h

⊢ (toComplex.comp ofComplex) Complex.I = (AlgHom.id ℝ ℂ) Complex.I
tactic: ext1
state_before: case h

⊢ (toComplex.comp ofComplex) Complex.I = (AlgHom.id ℝ ℂ) Complex.I
state_after: case h

⊢ toComplex (ofComplex Complex.I) = Complex.I
tactic: dsimp only [AlgHom.comp_apply, Subtype.coe_mk, AlgHom.id_apply]
state_before: case h

⊢ toComplex (ofComplex Complex.I) = Complex.I
state_after: no goals
tactic: rw [ofComplex_I, toComplex_ι, one_smul]
Theorem: NumberField.InfinitePlace.isReal_comap_iff
File: Mathlib/NumberTheory/NumberField/Embeddings.lean

Proof steps:
state_before: k : Type u_1
inst✝³ : Field k
K : Type u_2
inst✝² : Field K
F : Type u_3
inst✝¹ : Field F
inst✝ : NumberField K
f : k ≃+* K
w : InfinitePlace K
⊢ (w.comap ↑f).IsReal ↔ w.IsReal
state_after: no goals
tactic: rw [← mk_embedding w, comap_mk, isReal_mk_iff, isReal_mk_iff, ComplexEmbedding.isReal_comp_iff]
Theorem: CategoryTheory.Limits.pushout.congrHom_hom
File: Mathlib/CategoryTheory/Limits/Shapes/Pullback/HasPullback.lean

Proof steps:
state_before: C : Type u
inst✝² : Category.{v, u} C
W X✝ Y✝ Z✝ X Y Z : C
f₁ f₂ : X ⟶ Y
g₁ g₂ : X ⟶ Z
h₁ : f₁ = f₂
h₂ : g₁ = g₂
inst✝¹ : HasPushout f₁ g₁
inst✝ : HasPushout f₂ g₂
⊢ f₁ ≫ 𝟙 Y = 𝟙 X ≫ f₂
state_after: no goals
tactic: simp [h₁]
state_before: C : Type u
inst✝² : Category.{v, u} C
W X✝ Y✝ Z✝ X Y Z : C
f₁ f₂ : X ⟶ Y
g₁ g₂ : X ⟶ Z
h₁ : f₁ = f₂
h₂ : g₁ = g₂
inst✝¹ : HasPushout f₁ g₁
inst✝ : HasPushout f₂ g₂
⊢ g₁ ≫ 𝟙 Z = 𝟙 X ≫ g₂
state_after: no goals
tactic: simp [h₂]
Theorem: Set.kernImage_empty
File: Mathlib/Data/Set/Lattice.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
ι₂ : Sort u_6
κ : ι → Sort u_7
κ₁ : ι → Sort u_8
κ₂ : ι → Sort u_9
κ' : ι' → Sort u_10
f : α → β
⊢ kernImage f ∅ = (range f)ᶜ
state_after: no goals
tactic: rw [kernImage_eq_compl, compl_empty, image_univ]
Theorem: Primrec.nat_findGreatest
File: Mathlib/Computability/Primrec.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
σ : Type u_5
inst✝⁵ : Primcodable α
inst✝⁴ : Primcodable β
inst✝³ : Primcodable γ
inst✝² : Primcodable δ
inst✝¹ : Primcodable σ
f : α → ℕ
p : α → ℕ → Prop
inst✝ : (x : α) → (n : ℕ) → Decidable (p x n)
hf : Primrec f
hp : PrimrecRel p
x : α
⊢ Nat.rec 0 (fun n IH => if p x ((n, IH).1 + 1) then (n, IH).1 + 1 else (n, IH).2) (f x) = Nat.findGreatest (p x) (f x)
state_after: no goals
tactic: induction f x <;> simp [Nat.findGreatest, *]
Theorem: Cardinal.lift_continuum
File: Mathlib/SetTheory/Cardinal/Continuum.lean

Proof steps:
state_before: ⊢ lift.{v, u_1} 𝔠 = 𝔠
state_after: no goals
tactic: rw [← two_power_aleph0, lift_two_power, lift_aleph0, two_power_aleph0]
Theorem: Cardinal.type_cardinal
File: Mathlib/SetTheory/Cardinal/Ordinal.lean

Proof steps:
state_before: ⊢ (type fun x x_1 => x < x_1) = Ordinal.univ.{u, u + 1}
state_after: ⊢ (type fun x x_1 => x < x_1) = type fun x x_1 => x < x_1
tactic: rw [Ordinal.univ_id]
state_before: ⊢ (type fun x x_1 => x < x_1) = type fun x x_1 => x < x_1
state_after: no goals
tactic: exact Quotient.sound ⟨alephIdx.relIso⟩
Theorem: Ideal.radical_mul
File: Mathlib/RingTheory/Ideal/Operations.lean

Proof steps:
state_before: R : Type u
ι : Type u_1
inst✝ : CommSemiring R
I J K L : Ideal R
⊢ (I * J).radical = I.radical ⊓ J.radical
state_after: R : Type u
ι : Type u_1
inst✝ : CommSemiring R
I J K L : Ideal R
⊢ (I * J).radical ≤ I.radical ⊓ J.radical
tactic: refine le_antisymm ?_ fun r ⟨⟨m, hrm⟩, ⟨n, hrn⟩⟩ =>
    ⟨m + n, (pow_add r m n).symm ▸ mul_mem_mul hrm hrn⟩
state_before: R : Type u
ι : Type u_1
inst✝ : CommSemiring R
I J K L : Ideal R
⊢ (I * J).radical ≤ I.radical ⊓ J.radical
state_after: R : Type u
ι : Type u_1
inst✝ : CommSemiring R
I J K L : Ideal R
this : (I * J).radical ≤ (I ⊓ J).radical
⊢ (I * J).radical ≤ I.radical ⊓ J.radical
tactic: have := radical_mono <| @mul_le_inf _ _ I J
state_before: R : Type u
ι : Type u_1
inst✝ : CommSemiring R
I J K L : Ideal R
this : (I * J).radical ≤ (I ⊓ J).radical
⊢ (I * J).radical ≤ I.radical ⊓ J.radical
state_after: R : Type u
ι : Type u_1
inst✝ : CommSemiring R
I J K L : Ideal R
this : (I * J).radical ≤ I.radical ⊓ J.radical
⊢ (I * J).radical ≤ I.radical ⊓ J.radical
tactic: simp_rw [radical_inf I J] at this
state_before: R : Type u
ι : Type u_1
inst✝ : CommSemiring R
I J K L : Ideal R
this : (I * J).radical ≤ I.radical ⊓ J.radical
⊢ (I * J).radical ≤ I.radical ⊓ J.radical
state_after: no goals
tactic: assumption
Theorem: AlgebraicGeometry.Scheme.Pullback.t'_snd_fst_snd
File: Mathlib/AlgebraicGeometry/Pullbacks.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : X.OpenCover
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (𝒰.map i ≫ f) g
i j k : 𝒰.J
⊢ t' 𝒰 f g i j k ≫
      pullback.snd (fV 𝒰 f g j k) (fV 𝒰 f g j i) ≫
        pullback.fst (pullback.fst (𝒰.map j ≫ f) g ≫ 𝒰.map j) (𝒰.map i) ≫ pullback.snd (𝒰.map j ≫ f) g =
    pullback.fst (fV 𝒰 f g i j) (fV 𝒰 f g i k) ≫
      pullback.fst (pullback.fst (𝒰.map i ≫ f) g ≫ 𝒰.map i) (𝒰.map j) ≫ pullback.snd (𝒰.map i ≫ f) g
state_after: no goals
tactic: simp only [t', Category.assoc, pullbackSymmetry_hom_comp_snd_assoc,
    pullbackRightPullbackFstIso_inv_fst_assoc, pullback.lift_fst_assoc, t_fst_snd,
    pullbackRightPullbackFstIso_hom_fst_assoc]
Theorem: DirectSum.IsInternal.collectedBasis_orthonormal
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
G : ι → Type u_5
inst✝² : (i : ι) → NormedAddCommGroup (G i)
inst✝¹ : (i : ι) → InnerProductSpace 𝕜 (G i)
V✝ : (i : ι) → G i →ₗᵢ[𝕜] E
hV✝ : OrthogonalFamily 𝕜 G V✝
dec_V : (i : ι) → (x : G i) → Decidable (x ≠ 0)
inst✝ : DecidableEq ι
V : ι → Submodule 𝕜 E
hV : OrthogonalFamily 𝕜 (fun i => ↥(V i)) fun i => (V i).subtypeₗᵢ
hV_sum : IsInternal fun i => V i
α : ι → Type u_6
v_family : (i : ι) → Basis (α i) 𝕜 ↥(V i)
hv_family : ∀ (i : ι), Orthonormal 𝕜 ⇑(v_family i)
⊢ Orthonormal 𝕜 ⇑(hV_sum.collectedBasis v_family)
state_after: no goals
tactic: simpa only [hV_sum.collectedBasis_coe] using hV.orthonormal_sigma_orthonormal hv_family
Theorem: CategoryTheory.Pretriangulated.Triangle.mor₁_eq_zero_iff_mono₂
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
⊢ T.mor₁ = 0 ↔ Mono T.mor₂
state_after: case mp
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
⊢ T.mor₁ = 0 → Mono T.mor₂

case mpr
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
⊢ Mono T.mor₂ → T.mor₁ = 0
tactic: constructor
Theorem: AddSubgroup.comap_sup_eq_of_le_range
File: Mathlib/Algebra/Group/Subgroup/Basic.lean

Proof steps:
state_before: G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝⁴ : Group G
inst✝³ : Group G'
inst✝² : Group G''
A : Type u_4
inst✝¹ : AddGroup A
N : Type u_5
inst✝ : Group N
f : G →* N
H K : Subgroup N
hH : H ≤ f.range
hK : K ≤ f.range
⊢ map f (comap f H ⊔ comap f K) = map f (comap f (H ⊔ K))
state_after: no goals
tactic: rw [map_comap_eq, map_sup, map_comap_eq, map_comap_eq, inf_eq_right.mpr hH,
        inf_eq_right.mpr hK, inf_eq_right.mpr (sup_le hH hK)]
Theorem: InfClosed.preimage
File: Mathlib/Order/SupClosed.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝³ : SemilatticeInf α
inst✝² : SemilatticeInf β
ι : Sort u_4
S : Set (Set α)
f✝ : ι → Set α
s t : Set α
a✝ : α
inst✝¹ : FunLike F β α
inst✝ : InfHomClass F β α
hs : InfClosed s
f : F
a : β
ha : a ∈ ⇑f ⁻¹' s
b : β
hb : b ∈ ⇑f ⁻¹' s
⊢ a ⊓ b ∈ ⇑f ⁻¹' s
state_after: no goals
tactic: simpa [map_inf] using hs ha hb
Theorem: CategoryTheory.Subobject.mk_eq_mk_of_comm
File: Mathlib/CategoryTheory/Subobject/Basic.lean

Proof steps:
state_before: C : Type u₁
inst✝³ : Category.{v₁, u₁} C
X Y Z : C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
B A₁ A₂ : C
f : A₁ ⟶ B
g : A₂ ⟶ B
inst✝¹ : Mono f
inst✝ : Mono g
i : A₁ ≅ A₂
w : i.hom ≫ g = f
⊢ (underlyingIso f ≪≫ i).hom ≫ g = (mk f).arrow
state_after: no goals
tactic: simp [w]
Theorem: MvPolynomial.IsWeightedHomogeneous.weighted_total_degree
File: Mathlib/RingTheory/MvPolynomial/WeightedHomogeneous.lean

Proof steps:
state_before: R : Type u_1
M : Type u_2
inst✝² : CommSemiring R
σ : Type u_3
inst✝¹ : AddCommMonoid M
φ ψ : MvPolynomial σ R
m n : M
inst✝ : SemilatticeSup M
w : σ → M
hφ : IsWeightedHomogeneous w φ n
h : φ ≠ 0
⊢ weightedTotalDegree' w φ = ↑n
state_after: R : Type u_1
M : Type u_2
inst✝² : CommSemiring R
σ : Type u_3
inst✝¹ : AddCommMonoid M
φ ψ : MvPolynomial σ R
m n : M
inst✝ : SemilatticeSup M
w : σ → M
hφ : IsWeightedHomogeneous w φ n
h : φ ≠ 0
⊢ (φ.support.sup fun s => ↑((weight w) s)) = ↑n
tactic: simp only [weightedTotalDegree']
state_before: R : Type u_1
M : Type u_2
inst✝² : CommSemiring R
σ : Type u_3
inst✝¹ : AddCommMonoid M
φ ψ : MvPolynomial σ R
m n : M
inst✝ : SemilatticeSup M
w : σ → M
hφ : IsWeightedHomogeneous w φ n
h : φ ≠ 0
⊢ (φ.support.sup fun s => ↑((weight w) s)) = ↑n
state_after: case a
R : Type u_1
M : Type u_2
inst✝² : CommSemiring R
σ : Type u_3
inst✝¹ : AddCommMonoid M
φ ψ : MvPolynomial σ R
m n : M
inst✝ : SemilatticeSup M
w : σ → M
hφ : IsWeightedHomogeneous w φ n
h : φ ≠ 0
⊢ (φ.support.sup fun s => ↑((weight w) s)) ≤ ↑n

case a
R : Type u_1
M : Type u_2
inst✝² : CommSemiring R
σ : Type u_3
inst✝¹ : AddCommMonoid M
φ ψ : MvPolynomial σ R
m n : M
inst✝ : SemilatticeSup M
w : σ → M
hφ : IsWeightedHomogeneous w φ n
h : φ ≠ 0
⊢ ↑n ≤ φ.support.sup fun s => ↑((weight w) s)
tactic: apply le_antisymm
Theorem: Isometry.hausdorffMeasure_preimage
File: Mathlib/MeasureTheory/Measure/Hausdorff.lean

Proof steps:
state_before: ι : Type u_1
X : Type u_2
Y : Type u_3
inst✝⁵ : EMetricSpace X
inst✝⁴ : EMetricSpace Y
inst✝³ : MeasurableSpace X
inst✝² : BorelSpace X
inst✝¹ : MeasurableSpace Y
inst✝ : BorelSpace Y
f : X → Y
d : ℝ
hf : Isometry f
hd : 0 ≤ d ∨ Surjective f
s : Set Y
⊢ μH[d] (f ⁻¹' s) = μH[d] (s ∩ range f)
state_after: no goals
tactic: rw [← hf.hausdorffMeasure_image hd, image_preimage_eq_inter_range]
Theorem: List.foldrIdx_eq_foldrIdxSpec
File: Mathlib/Data/List/Indexes.lean

Proof steps:
state_before: α : Type u
β : Type v
f : ℕ → α → β → β
b : β
as : List α
start : ℕ
⊢ foldrIdx f b as start = foldrIdxSpec f b as start
state_after: case nil
α : Type u
β : Type v
f : ℕ → α → β → β
b : β
start : ℕ
⊢ foldrIdx f b [] start = foldrIdxSpec f b [] start

case cons
α : Type u
β : Type v
f : ℕ → α → β → β
b : β
head✝ : α
tail✝ : List α
tail_ih✝ : ∀ (start : ℕ), foldrIdx f b tail✝ start = foldrIdxSpec f b tail✝ start
start : ℕ
⊢ foldrIdx f b (head✝ :: tail✝) start = foldrIdxSpec f b (head✝ :: tail✝) start
tactic: induction as generalizing start
Theorem: CategoryTheory.ShiftedHom.zero_comp
File: Mathlib/CategoryTheory/Shift/ShiftedHom.lean

Proof steps:
state_before: C : Type u_1
inst✝⁷ : Category.{u_5, u_1} C
D : Type u_2
inst✝⁶ : Category.{?u.52301, u_2} D
E : Type u_3
inst✝⁵ : Category.{?u.52308, u_3} E
M : Type u_4
inst✝⁴ : AddMonoid M
inst✝³ : HasShift C M
inst✝² : HasShift D M
inst✝¹ : HasShift E M
X Y Z T : C
inst✝ : Preadditive C
a b c : M
β : ShiftedHom Y Z b
h : b + a = c
⊢ comp 0 β h = 0
state_after: no goals
tactic: rw [comp, Limits.zero_comp]
Theorem: Set.Icc_add_bij
File: Mathlib/Algebra/Order/Interval/Set/Monoid.lean

Proof steps:
state_before: M : Type u_1
inst✝¹ : OrderedCancelAddCommMonoid M
inst✝ : ExistsAddOfLE M
a b c d : M
⊢ BijOn (fun x => x + d) (Icc a b) (Icc (a + d) (b + d))
state_after: M : Type u_1
inst✝¹ : OrderedCancelAddCommMonoid M
inst✝ : ExistsAddOfLE M
a b c d : M
⊢ BijOn (fun x => x + d) (Ici a ∩ Iic b) (Ici (a + d) ∩ Iic (b + d))
tactic: rw [← Ici_inter_Iic, ← Ici_inter_Iic]
state_before: M : Type u_1
inst✝¹ : OrderedCancelAddCommMonoid M
inst✝ : ExistsAddOfLE M
a b c d : M
⊢ BijOn (fun x => x + d) (Ici a ∩ Iic b) (Ici (a + d) ∩ Iic (b + d))
state_after: no goals
tactic: exact
    (Ici_add_bij a d).inter_mapsTo (fun x hx => add_le_add_right hx _) fun x hx =>
      le_of_add_le_add_right hx.2
Theorem: UniformConvexOn.mono
File: Mathlib/Analysis/Convex/Strong.lean

Proof steps:
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
φ ψ : ℝ → ℝ
s : Set E
a✝ b✝ m : ℝ
x✝ y✝ : E
f g : E → ℝ
hψφ : ψ ≤ φ
hf : UniformConvexOn s φ f
x : E
hx : x ∈ s
y : E
hy : y ∈ s
a b : ℝ
ha : 0 ≤ a
hb : 0 ≤ b
hab : a + b = 1
⊢ a • f x + b • f y - a * b * φ ‖x - y‖ ≤ a • f x + b • f y - a * b * ψ ‖x - y‖
state_after: case h.h
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
φ ψ : ℝ → ℝ
s : Set E
a✝ b✝ m : ℝ
x✝ y✝ : E
f g : E → ℝ
hψφ : ψ ≤ φ
hf : UniformConvexOn s φ f
x : E
hx : x ∈ s
y : E
hy : y ∈ s
a b : ℝ
ha : 0 ≤ a
hb : 0 ≤ b
hab : a + b = 1
⊢ ψ ‖x - y‖ ≤ φ ‖x - y‖
tactic: gcongr
state_before: case h.h
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
φ ψ : ℝ → ℝ
s : Set E
a✝ b✝ m : ℝ
x✝ y✝ : E
f g : E → ℝ
hψφ : ψ ≤ φ
hf : UniformConvexOn s φ f
x : E
hx : x ∈ s
y : E
hy : y ∈ s
a b : ℝ
ha : 0 ≤ a
hb : 0 ≤ b
hab : a + b = 1
⊢ ψ ‖x - y‖ ≤ φ ‖x - y‖
state_after: no goals
tactic: apply hψφ
Theorem: left_inv_eq_right_inv
File: Mathlib/Algebra/Group/Defs.lean

Proof steps:
state_before: G : Type u_1
M : Type u_2
inst✝ : Monoid M
a b c : M
m n : ℕ
hba : b * a = 1
hac : a * c = 1
⊢ b = c
state_after: no goals
tactic: rw [← one_mul c, ← hba, mul_assoc, hac, mul_one b]
Theorem: MeasureTheory.IsFundamentalDomain.lintegral_eq_tsum_of_ac
File: Mathlib/MeasureTheory/Group/FundamentalDomain.lean

Proof steps:
state_before: G : Type u_1
H : Type u_2
α : Type u_3
β : Type u_4
E : Type u_5
inst✝¹⁰ : Group G
inst✝⁹ : Group H
inst✝⁸ : MulAction G α
inst✝⁷ : MeasurableSpace α
inst✝⁶ : MulAction H β
inst✝⁵ : MeasurableSpace β
inst✝⁴ : NormedAddCommGroup E
s t : Set α
μ : Measure α
inst✝³ : MeasurableSpace G
inst✝² : MeasurableSMul G α
inst✝¹ : SMulInvariantMeasure G α μ
inst✝ : Countable G
ν : Measure α
h : IsFundamentalDomain G s μ
hν : ν ≪ μ
f : α → ℝ≥0∞
⊢ ∫⁻ (x : α), f x ∂ν = ∑' (g : G), ∫⁻ (x : α) in g • s, f x ∂ν
state_after: no goals
tactic: rw [← lintegral_sum_measure, h.sum_restrict_of_ac hν]
Theorem: CategoryTheory.Limits.parallelPair.eqOfHomEq_hom_app
File: Mathlib/CategoryTheory/Limits/Shapes/Equalizers.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y : C
f g f' g' : X ⟶ Y
hf : f = f'
hg : g = g'
⊢ (parallelPair f g).map left ≫ (Iso.refl ((parallelPair f g).obj one)).hom =
    (Iso.refl ((parallelPair f g).obj zero)).hom ≫ (parallelPair f' g').map left
state_after: no goals
tactic: simp [hf]
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y : C
f g f' g' : X ⟶ Y
hf : f = f'
hg : g = g'
⊢ (parallelPair f g).map right ≫ (Iso.refl ((parallelPair f g).obj one)).hom =
    (Iso.refl ((parallelPair f g).obj zero)).hom ≫ (parallelPair f' g').map right
state_after: no goals
tactic: simp [hg]
Theorem: SimpleGraph.Embedding.mapNeighborSet_apply_coe
File: Mathlib/Combinatorics/SimpleGraph/Maps.lean

Proof steps:
state_before: V : Type u_1
W : Type u_2
X : Type u_3
G : SimpleGraph V
G' : SimpleGraph W
u v✝ : V
H : SimpleGraph W
f : G ↪g G'
v : V
⊢ Injective fun w => ⟨f ↑w, ⋯⟩
state_after: case mk.mk
V : Type u_1
W : Type u_2
X : Type u_3
G : SimpleGraph V
G' : SimpleGraph W
u v✝ : V
H : SimpleGraph W
f : G ↪g G'
v w₁ : V
h₁ : w₁ ∈ G.neighborSet v
w₂ : V
h₂ : w₂ ∈ G.neighborSet v
h : (fun w => ⟨f ↑w, ⋯⟩) ⟨w₁, h₁⟩ = (fun w => ⟨f ↑w, ⋯⟩) ⟨w₂, h₂⟩
⊢ ⟨w₁, h₁⟩ = ⟨w₂, h₂⟩
tactic: rintro ⟨w₁, h₁⟩ ⟨w₂, h₂⟩ h
state_before: case mk.mk
V : Type u_1
W : Type u_2
X : Type u_3
G : SimpleGraph V
G' : SimpleGraph W
u v✝ : V
H : SimpleGraph W
f : G ↪g G'
v w₁ : V
h₁ : w₁ ∈ G.neighborSet v
w₂ : V
h₂ : w₂ ∈ G.neighborSet v
h : (fun w => ⟨f ↑w, ⋯⟩) ⟨w₁, h₁⟩ = (fun w => ⟨f ↑w, ⋯⟩) ⟨w₂, h₂⟩
⊢ ⟨w₁, h₁⟩ = ⟨w₂, h₂⟩
state_after: case mk.mk
V : Type u_1
W : Type u_2
X : Type u_3
G : SimpleGraph V
G' : SimpleGraph W
u v✝ : V
H : SimpleGraph W
f : G ↪g G'
v w₁ : V
h₁ : w₁ ∈ G.neighborSet v
w₂ : V
h₂ : w₂ ∈ G.neighborSet v
h : f ↑⟨w₁, h₁⟩ = f ↑⟨w₂, h₂⟩
⊢ w₁ = w₂
tactic: rw [Subtype.mk_eq_mk] at h ⊢
state_before: case mk.mk
V : Type u_1
W : Type u_2
X : Type u_3
G : SimpleGraph V
G' : SimpleGraph W
u v✝ : V
H : SimpleGraph W
f : G ↪g G'
v w₁ : V
h₁ : w₁ ∈ G.neighborSet v
w₂ : V
h₂ : w₂ ∈ G.neighborSet v
h : f ↑⟨w₁, h₁⟩ = f ↑⟨w₂, h₂⟩
⊢ w₁ = w₂
state_after: no goals
tactic: exact f.inj' h
Theorem: List.getElem?_zipWith_eq_some
File: Mathlib/Data/List/Zip.lean

Proof steps:
state_before: α : Type u
β : Type u_1
γ : Type u_2
δ : Type u_3
ε : Type u_4
f : α → β → γ
l₁ : List α
l₂ : List β
z : γ
i : ℕ
⊢ (zipWith f l₁ l₂)[i]? = some z ↔ ∃ x y, l₁[i]? = some x ∧ l₂[i]? = some y ∧ f x y = z
state_after: case nil
α : Type u
β : Type u_1
γ : Type u_2
δ : Type u_3
ε : Type u_4
f : α → β → γ
z : γ
l₂ : List β
i : ℕ
⊢ (zipWith f [] l₂)[i]? = some z ↔ ∃ x y, [][i]? = some x ∧ l₂[i]? = some y ∧ f x y = z

case cons
α : Type u
β : Type u_1
γ : Type u_2
δ : Type u_3
ε : Type u_4
f : α → β → γ
z : γ
head✝ : α
tail✝ : List α
tail_ih✝ :
  ∀ (l₂ : List β) (i : ℕ), (zipWith f tail✝ l₂)[i]? = some z ↔ ∃ x y, tail✝[i]? = some x ∧ l₂[i]? = some y ∧ f x y = z
l₂ : List β
i : ℕ
⊢ (zipWith f (head✝ :: tail✝) l₂)[i]? = some z ↔ ∃ x y, (head✝ :: tail✝)[i]? = some x ∧ l₂[i]? = some y ∧ f x y = z
tactic: induction l₁ generalizing l₂ i
Theorem: EuclideanGeometry.angle_le_pi_div_two_of_angle_eq_pi_div_two
File: Mathlib/Geometry/Euclidean/Angle/Unoriented/RightAngle.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
p₁ p₂ p₃ : P
h : ∠ p₁ p₂ p₃ = π / 2
⊢ ∠ p₂ p₃ p₁ ≤ π / 2
state_after: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p₁ p₂ p₃ : P
h : ⟪p₂ -ᵥ p₃, p₁ -ᵥ p₂⟫_ℝ = 0
⊢ ∠ p₂ p₃ p₁ ≤ π / 2
tactic: rw [angle, ← inner_eq_zero_iff_angle_eq_pi_div_two, real_inner_comm, ← neg_eq_zero, ←
    inner_neg_left, neg_vsub_eq_vsub_rev] at h
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p₁ p₂ p₃ : P
h : ⟪p₂ -ᵥ p₃, p₁ -ᵥ p₂⟫_ℝ = 0
⊢ ∠ p₂ p₃ p₁ ≤ π / 2
state_after: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p₁ p₂ p₃ : P
h : ⟪p₂ -ᵥ p₃, p₁ -ᵥ p₂⟫_ℝ = 0
⊢ InnerProductGeometry.angle (p₂ -ᵥ p₃) (p₂ -ᵥ p₃ + (p₁ -ᵥ p₂)) ≤ π / 2
tactic: rw [angle, ← vsub_add_vsub_cancel p₁ p₂ p₃, add_comm]
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p₁ p₂ p₃ : P
h : ⟪p₂ -ᵥ p₃, p₁ -ᵥ p₂⟫_ℝ = 0
⊢ InnerProductGeometry.angle (p₂ -ᵥ p₃) (p₂ -ᵥ p₃ + (p₁ -ᵥ p₂)) ≤ π / 2
state_after: no goals
tactic: exact angle_add_le_pi_div_two_of_inner_eq_zero h
Theorem: Finset.card_le_card_of_injOn
File: Mathlib/Data/Finset/Card.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
R : Type u_3
s t✝ u : Finset α
f✝ : α → β
n : ℕ
t : Finset β
f : α → β
hf : ∀ a ∈ s, f a ∈ t
f_inj : Set.InjOn f ↑s
⊢ s.card ≤ t.card
state_after: no goals
tactic: classical
  calc
    s.card = (s.image f).card := (card_image_of_injOn f_inj).symm
    _      ≤ t.card           := card_le_card <| image_subset_iff.2 hf