1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: LieIdeal.idealizer_eq_normalizer
File: Mathlib/Algebra/Lie/Normalizer.lean

tactic: ext x
state_before: R : Type u_1
L : Type u_2
M : Type u_3
M' : Type u_4
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
N N₁ N₂ : LieSubmodule R L M
I : LieIdeal R L
⊢ idealizer I = normalizer I
state_after: case h
R : Type u_1
L : Type u_2
M : Type u_3
M' : Type u_4
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
N N₁ N₂ : LieSubmodule R L M
I : LieIdeal R L
x : L
⊢ x ∈ idealizer I ↔ x ∈ normalizer I

tactic: exact forall_congr' fun y ↦ by simp only [← lie_skew x y, neg_mem_iff]
state_before: case h
R : Type u_1
L : Type u_2
M : Type u_3
M' : Type u_4
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
N N₁ N₂ : LieSubmodule R L M
I : LieIdeal R L
x : L
⊢ x ∈ idealizer I ↔ x ∈ normalizer I
state_after: no goals

tactic: simp only [← lie_skew x y, neg_mem_iff]
state_before: R : Type u_1
L : Type u_2
M : Type u_3
M' : Type u_4
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
N N₁ N₂ : LieSubmodule R L M
I : LieIdeal R L
x y : L
⊢ ⁅x, y⁆ ∈ I ↔ ⁅y, x⁆ ∈ I
state_after: no goals
Theorem: LinearMap.concaveOn
File: Mathlib/Analysis/Convex/Function.lean

tactic: rw [f.map_add, f.map_smul, f.map_smul]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
α : Type u_4
β : Type u_5
ι : Type u_6
inst✝⁶ : OrderedSemiring 𝕜
inst✝⁵ : AddCommMonoid E
inst✝⁴ : AddCommMonoid F
inst✝³ : OrderedAddCommMonoid α
inst✝² : OrderedAddCommMonoid β
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 β
f : E →ₗ[𝕜] β
s : Set E
hs : Convex 𝕜 s
x✝⁸ : E
x✝⁷ : x✝⁸ ∈ s
x✝⁶ : E
x✝⁵ : x✝⁶ ∈ s
x✝⁴ x✝³ : 𝕜
x✝² : 0 ≤ x✝⁴
x✝¹ : 0 ≤ x✝³
x✝ : x✝⁴ + x✝³ = 1
⊢ x✝⁴ • f x✝⁸ + x✝³ • f x✝⁶ ≤ f (x✝⁴ • x✝⁸ + x✝³ • x✝⁶)
state_after: no goals
Theorem: neg_concaveOn_iff
File: Mathlib/Analysis/Convex/Function.lean

tactic: rw [← neg_convexOn_iff, neg_neg f]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
α : Type u_4
β : Type u_5
ι : Type u_6
inst✝⁵ : OrderedSemiring 𝕜
inst✝⁴ : AddCommMonoid E
inst✝³ : AddCommMonoid F
inst✝² : OrderedAddCommGroup β
inst✝¹ : SMul 𝕜 E
inst✝ : Module 𝕜 β
s : Set E
f g : E → β
⊢ ConcaveOn 𝕜 s (-f) ↔ ConvexOn 𝕜 s f
state_after: no goals
Theorem: Ideal.quotientEquivAlgOfEq_symm
File: Mathlib/RingTheory/Ideal/QuotientOperations.lean

tactic: ext
state_before: R : Type u
S : Type v
F : Type w
inst✝⁶ : CommRing R
inst✝⁵ : Semiring S
R₁ : Type u_1
R₂ : Type u_2
A : Type u_3
B : Type u_4
inst✝⁴ : CommSemiring R₁
inst✝³ : CommSemiring R₂
inst✝² : CommRing A
inst✝¹ : Algebra R₁ A
inst✝ : Algebra R₂ A
I J : Ideal A
h : I = J
⊢ (quotientEquivAlgOfEq R₁ h).symm = quotientEquivAlgOfEq R₁ ⋯
state_after: case h
R : Type u
S : Type v
F : Type w
inst✝⁶ : CommRing R
inst✝⁵ : Semiring S
R₁ : Type u_1
R₂ : Type u_2
A : Type u_3
B : Type u_4
inst✝⁴ : CommSemiring R₁
inst✝³ : CommSemiring R₂
inst✝² : CommRing A
inst✝¹ : Algebra R₁ A
inst✝ : Algebra R₂ A
I J : Ideal A
h : I = J
a✝ : A ⧸ J
⊢ (quotientEquivAlgOfEq R₁ h).symm a✝ = (quotientEquivAlgOfEq R₁ ⋯) a✝

tactic: rfl
state_before: case h
R : Type u
S : Type v
F : Type w
inst✝⁶ : CommRing R
inst✝⁵ : Semiring S
R₁ : Type u_1
R₂ : Type u_2
A : Type u_3
B : Type u_4
inst✝⁴ : CommSemiring R₁
inst✝³ : CommSemiring R₂
inst✝² : CommRing A
inst✝¹ : Algebra R₁ A
inst✝ : Algebra R₂ A
I J : Ideal A
h : I = J
a✝ : A ⧸ J
⊢ (quotientEquivAlgOfEq R₁ h).symm a✝ = (quotientEquivAlgOfEq R₁ ⋯) a✝
state_after: no goals
Theorem: AlgebraicGeometry.Scheme.Pullback.t'_snd_fst_fst
File: Mathlib/AlgebraicGeometry/Pullbacks.lean

tactic: simp only [t', Category.assoc, pullbackSymmetry_hom_comp_snd_assoc,
  pullbackRightPullbackFstIso_inv_fst_assoc, pullback.lift_fst_assoc, t_fst_fst,
  pullbackRightPullbackFstIso_hom_fst_assoc]
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 ≫ pullback.fst ≫ pullback.fst = pullback.fst ≫ pullback.snd
state_after: no goals
Theorem: InnerProductGeometry.sin_angle_sub_of_inner_eq_zero
File: Mathlib/Geometry/Euclidean/Angle/Unoriented/RightAngle.lean

tactic: rw [← neg_eq_zero, ← inner_neg_right] at h
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
h : ⟪x, y⟫_ℝ = 0
h0 : x ≠ 0 ∨ y ≠ 0
⊢ Real.sin (angle x (x - y)) = ‖y‖ / ‖x - y‖
state_after: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
h : ⟪x, -y⟫_ℝ = 0
h0 : x ≠ 0 ∨ y ≠ 0
⊢ Real.sin (angle x (x - y)) = ‖y‖ / ‖x - y‖

tactic: rw [or_comm, ← neg_ne_zero, or_comm] at h0
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
h : ⟪x, -y⟫_ℝ = 0
h0 : x ≠ 0 ∨ y ≠ 0
⊢ Real.sin (angle x (x - y)) = ‖y‖ / ‖x - y‖
state_after: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
h : ⟪x, -y⟫_ℝ = 0
h0 : x ≠ 0 ∨ -y ≠ 0
⊢ Real.sin (angle x (x - y)) = ‖y‖ / ‖x - y‖

tactic: rw [sub_eq_add_neg, sin_angle_add_of_inner_eq_zero h h0, norm_neg]
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
h : ⟪x, -y⟫_ℝ = 0
h0 : x ≠ 0 ∨ -y ≠ 0
⊢ Real.sin (angle x (x - y)) = ‖y‖ / ‖x - y‖
state_after: no goals
Theorem: CategoryTheory.Limits.IsColimit.coconePointsIsoOfNatIso_hom_desc
File: Mathlib/CategoryTheory/Limits/IsLimit.lean

tactic: simp
state_before: J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F✝ : J ⥤ C
t✝ : Cocone F✝
F G : J ⥤ C
s : Cocone F
r t : Cocone G
P : IsColimit s
Q : IsColimit t
w : F ≅ G
⊢ ∀ (j : J), s.ι.app j ≫ (P.coconePointsIsoOfNatIso Q w).hom ≫ Q.desc r = s.ι.app j ≫ P.map r w.hom
state_after: no goals
Theorem: EllipticCurve.ofJ_0_of_three_ne_zero
File: Mathlib/AlgebraicGeometry/EllipticCurve/Weierstrass.lean

tactic: rw [ofJ, dif_pos rfl, dif_neg h3.out]
state_before: R : Type u
inst✝² : CommRing R
E : EllipticCurve R
F : Type u
inst✝¹ : Field F
j : F
inst✝ : DecidableEq F
h3 : NeZero 3
⊢ ofJ 0 = ofJ0 F
state_after: no goals
Theorem: MeasureTheory.measure_le_integral_pos
File: Mathlib/MeasureTheory/Integral/Average.lean

tactic: simpa only [average_eq_integral] using
  measure_le_average_pos (IsProbabilityMeasure.ne_zero μ) hf
state_before: α : Type u_1
E : Type u_2
F : Type u_3
m0 : MeasurableSpace α
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : CompleteSpace E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace ℝ F
inst✝¹ : CompleteSpace F
μ ν : Measure α
s t N : Set α
f : α → ℝ
inst✝ : IsProbabilityMeasure μ
hf : Integrable f μ
⊢ 0 < μ {x | f x ≤ ∫ (a : α), f a ∂μ}
state_after: no goals
Theorem: CategoryTheory.MorphismProperty.LeftFraction.map_ofInv_hom_id
File: Mathlib/CategoryTheory/Localization/CalculusOfFractions.lean

tactic: letI := hL _ hs
state_before: C : Type u_1
D : Type u_2
inst✝¹ : Category.{u_3, u_1} C
inst✝ : Category.{u_4, u_2} D
W : MorphismProperty C
X Y : C
s : Y ⟶ X
hs : W s
L : C ⥤ D
hL : W.IsInvertedBy L
⊢ (ofInv s hs).map L hL ≫ L.map s = 𝟙 (L.obj X)
state_after: C : Type u_1
D : Type u_2
inst✝¹ : Category.{u_3, u_1} C
inst✝ : Category.{u_4, u_2} D
W : MorphismProperty C
X Y : C
s : Y ⟶ X
hs : W s
L : C ⥤ D
hL : W.IsInvertedBy L
this : IsIso (L.map s) := hL s hs
⊢ (ofInv s hs).map L hL ≫ L.map s = 𝟙 (L.obj X)

tactic: simp [map]
state_before: C : Type u_1
D : Type u_2
inst✝¹ : Category.{u_3, u_1} C
inst✝ : Category.{u_4, u_2} D
W : MorphismProperty C
X Y : C
s : Y ⟶ X
hs : W s
L : C ⥤ D
hL : W.IsInvertedBy L
this : IsIso (L.map s) := hL s hs
⊢ (ofInv s hs).map L hL ≫ L.map s = 𝟙 (L.obj X)
state_after: no goals
Theorem: IsSimpleModule.toSpanSingleton_surjective
File: Mathlib/RingTheory/SimpleModule.lean

tactic: rw [← range_eq_top, ← span_singleton_eq_range, span_singleton_eq_top R hm]
state_before: ι : Type u_1
R : Type u_2
S : Type u_3
inst✝⁶ : Ring R
inst✝⁵ : Ring S
M : Type u_4
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
m✝ : Submodule R M
N : Type u_5
inst✝² : AddCommGroup N
inst✝¹ : Module R N
inst✝ : IsSimpleModule R M
m : M
hm : m ≠ 0
⊢ Function.Surjective ⇑(toSpanSingleton R M m)
state_after: no goals
Theorem: oneLePart_of_one_lt_oneLePart
File: Mathlib/Algebra/Order/Group/PosPart.lean

tactic: rw [oneLePart, right_lt_sup, not_le] at ha
state_before: α : Type u_1
β : Type u_2
inst✝² : LinearOrder α
inst✝¹ : Group α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a : α
ha : 1 < a⁺ᵐ
⊢ a⁺ᵐ = a
state_after: α : Type u_1
β : Type u_2
inst✝² : LinearOrder α
inst✝¹ : Group α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a : α
ha : 1 < a
⊢ a⁺ᵐ = a

tactic: exact oneLePart_eq_self.2 ha.le
state_before: α : Type u_1
β : Type u_2
inst✝² : LinearOrder α
inst✝¹ : Group α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a : α
ha : 1 < a
⊢ a⁺ᵐ = a
state_after: no goals
Theorem: Set.image2_image_left
File: Mathlib/Data/Set/NAry.lean

tactic: ext
state_before: α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
γ' : Type u_6
δ : Type u_7
δ' : Type u_8
ε : Type u_9
ε' : Type u_10
ζ : Type u_11
ζ' : Type u_12
ν : Type u_13
f✝ f' : α → β → γ
g✝ g' : α → β → γ → δ
s s' : Set α
t t' : Set β
u u' : Set γ
v : Set δ
a a' : α
b b' : β
c c' : γ
d d' : δ
f : γ → β → δ
g : α → γ
⊢ image2 f (g '' s) t = image2 (fun a b => f (g a) b) s t
state_after: case h
α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
γ' : Type u_6
δ : Type u_7
δ' : Type u_8
ε : Type u_9
ε' : Type u_10
ζ : Type u_11
ζ' : Type u_12
ν : Type u_13
f✝ f' : α → β → γ
g✝ g' : α → β → γ → δ
s s' : Set α
t t' : Set β
u u' : Set γ
v : Set δ
a a' : α
b b' : β
c c' : γ
d d' : δ
f : γ → β → δ
g : α → γ
x✝ : δ
⊢ x✝ ∈ image2 f (g '' s) t ↔ x✝ ∈ image2 (fun a b => f (g a) b) s t

tactic: simp
state_before: case h
α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
γ' : Type u_6
δ : Type u_7
δ' : Type u_8
ε : Type u_9
ε' : Type u_10
ζ : Type u_11
ζ' : Type u_12
ν : Type u_13
f✝ f' : α → β → γ
g✝ g' : α → β → γ → δ
s s' : Set α
t t' : Set β
u u' : Set γ
v : Set δ
a a' : α
b b' : β
c c' : γ
d d' : δ
f : γ → β → δ
g : α → γ
x✝ : δ
⊢ x✝ ∈ image2 f (g '' s) t ↔ x✝ ∈ image2 (fun a b => f (g a) b) s t
state_after: no goals
Theorem: CategoryTheory.Abelian.factorThruImage_comp_coimageIsoImage'_inv
File: Mathlib/CategoryTheory/Abelian/Basic.lean

tactic: simp only [IsImage.isoExt_inv, image.isImage_lift, image.fac_lift,
  coimageStrongEpiMonoFactorisation_e]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : Abelian C
X Y : C
f : X ⟶ Y
⊢ factorThruImage f ≫ (coimageIsoImage' f).inv = cokernel.π (kernel.ι f)
state_after: no goals
Theorem: Nat.coprime_mul_right_add_right
File: Mathlib/Data/Nat/GCD/Basic.lean

tactic: rw [Coprime, Coprime, gcd_mul_right_add_right]
state_before: m n k : ℕ
⊢ m.Coprime (k * m + n) ↔ m.Coprime n
state_after: no goals
Theorem: Composition.orderEmbOfFin_boundaries
File: Mathlib/Combinatorics/Enumerative/Composition.lean

tactic: refine (Finset.orderEmbOfFin_unique' _ ?_).symm
state_before: n : ℕ
c : Composition n
⊢ c.boundaries.orderEmbOfFin ⋯ = c.boundary
state_after: n : ℕ
c : Composition n
⊢ ∀ (x : Fin (c.length + 1)), c.boundary x ∈ c.boundaries

tactic: exact fun i => (Finset.mem_map' _).2 (Finset.mem_univ _)
state_before: n : ℕ
c : Composition n
⊢ ∀ (x : Fin (c.length + 1)), c.boundary x ∈ c.boundaries
state_after: no goals
Theorem: List.eq_cons_of_mem_head?
File: Mathlib/Data/List/Basic.lean

tactic: simp only [head?, Option.mem_def, Option.some_inj] at h
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
x a : α
l : List α
h : x ∈ (a :: l).head?
⊢ a :: l = x :: (a :: l).tail
state_after: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
x a : α
l : List α
h : a = x
⊢ a :: l = x :: (a :: l).tail

tactic: exact h ▸ rfl
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
x a : α
l : List α
h : a = x
⊢ a :: l = x :: (a :: l).tail
state_after: no goals
Theorem: AffineIsometry.nndist_map
File: Mathlib/Analysis/NormedSpace/AffineIsometry.lean

tactic: simp [nndist_dist]
state_before: 𝕜 : Type u_1
V : Type u_2
V₁ : Type u_3
V₁' : Type u_4
V₂ : Type u_5
V₃ : Type u_6
V₄ : Type u_7
P₁ : Type u_8
P₁' : Type u_9
P : Type u_10
P₂ : Type u_11
P₃ : Type u_12
P₄ : Type u_13
inst✝²⁴ : NormedField 𝕜
inst✝²³ : SeminormedAddCommGroup V
inst✝²² : NormedSpace 𝕜 V
inst✝²¹ : PseudoMetricSpace P
inst✝²⁰ : NormedAddTorsor V P
inst✝¹⁹ : SeminormedAddCommGroup V₁
inst✝¹⁸ : NormedSpace 𝕜 V₁
inst✝¹⁷ : PseudoMetricSpace P₁
inst✝¹⁶ : NormedAddTorsor V₁ P₁
inst✝¹⁵ : SeminormedAddCommGroup V₁'
inst✝¹⁴ : NormedSpace 𝕜 V₁'
inst✝¹³ : MetricSpace P₁'
inst✝¹² : NormedAddTorsor V₁' P₁'
inst✝¹¹ : SeminormedAddCommGroup V₂
inst✝¹⁰ : NormedSpace 𝕜 V₂
inst✝⁹ : PseudoMetricSpace P₂
inst✝⁸ : NormedAddTorsor V₂ P₂
inst✝⁷ : SeminormedAddCommGroup V₃
inst✝⁶ : NormedSpace 𝕜 V₃
inst✝⁵ : PseudoMetricSpace P₃
inst✝⁴ : NormedAddTorsor V₃ P₃
inst✝³ : SeminormedAddCommGroup V₄
inst✝² : NormedSpace 𝕜 V₄
inst✝¹ : PseudoMetricSpace P₄
inst✝ : NormedAddTorsor V₄ P₄
f : P →ᵃⁱ[𝕜] P₂
f₁ : P₁' →ᵃⁱ[𝕜] P₂
x y : P
⊢ nndist (f x) (f y) = nndist x y
state_after: no goals
Theorem: Finset.singleton_eq_univ
File: Mathlib/Data/Fintype/Basic.lean

tactic: ext b
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : Fintype α
s t : Finset α
inst✝ : Subsingleton α
a : α
⊢ {a} = univ
state_after: case a
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : Fintype α
s t : Finset α
inst✝ : Subsingleton α
a b : α
⊢ b ∈ {a} ↔ b ∈ univ

tactic: simp [Subsingleton.elim a b]
state_before: case a
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : Fintype α
s t : Finset α
inst✝ : Subsingleton α
a b : α
⊢ b ∈ {a} ↔ b ∈ univ
state_after: no goals
Theorem: multipliable_iff_vanishing
File: Mathlib/Topology/Algebra/InfiniteSum/Group.lean

tactic: rw [multipliable_iff_cauchySeq_finset, cauchySeq_finset_iff_prod_vanishing]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝³ : CommGroup α
inst✝² : UniformSpace α
inst✝¹ : UniformGroup α
f g : β → α
a a₁ a₂ : α
inst✝ : CompleteSpace α
⊢ Multipliable f ↔ ∀ e ∈ 𝓝 1, ∃ s, ∀ (t : Finset β), Disjoint t s → ∏ b ∈ t, f b ∈ e
state_after: no goals
Theorem: OrderIso.isLUB_image
File: Mathlib/Order/Bounds/OrderIso.lean

tactic: simp
state_before: α : Type u_1
β : Type u_2
inst✝¹ : Preorder α
inst✝ : Preorder β
f : α ≃o β
s : Set α
x : β
h : IsLUB (⇑f '' s) x
⊢ ∀ {x y : α}, f x ≤ f y ↔ x ≤ y
state_after: no goals

tactic: simp
state_before: α : Type u_1
β : Type u_2
inst✝¹ : Preorder α
inst✝ : Preorder β
f : α ≃o β
s : Set α
x : β
h : IsLUB s (f.symm x)
⊢ ∀ {x y : β}, f.symm x ≤ f.symm y ↔ x ≤ y
state_after: no goals
Theorem: Filter.map_pi_map_coprodᵢ_le
File: Mathlib/Order/Filter/Pi.lean

tactic: simp only [le_def, mem_map, mem_coprodᵢ_iff]
state_before: ι : Type u_1
α : ι → Type u_2
f f₁ f₂ : (i : ι) → Filter (α i)
s : (i : ι) → Set (α i)
p : (i : ι) → α i → Prop
β : ι → Type u_3
m : (i : ι) → α i → β i
⊢ map (fun k i => m i (k i)) (Filter.coprodᵢ f) ≤ Filter.coprodᵢ fun i => map (m i) (f i)
state_after: ι : Type u_1
α : ι → Type u_2
f f₁ f₂ : (i : ι) → Filter (α i)
s : (i : ι) → Set (α i)
p : (i : ι) → α i → Prop
β : ι → Type u_3
m : (i : ι) → α i → β i
⊢ ∀ (x : Set ((i : ι) → β i)),
    (∀ (i : ι), ∃ t₁, m i ⁻¹' t₁ ∈ f i ∧ eval i ⁻¹' t₁ ⊆ x) →
      ∀ (i : ι), ∃ t₁ ∈ f i, eval i ⁻¹' t₁ ⊆ (fun k i => m i (k i)) ⁻¹' x

tactic: intro s h i
state_before: ι : Type u_1
α : ι → Type u_2
f f₁ f₂ : (i : ι) → Filter (α i)
s : (i : ι) → Set (α i)
p : (i : ι) → α i → Prop
β : ι → Type u_3
m : (i : ι) → α i → β i
⊢ ∀ (x : Set ((i : ι) → β i)),
    (∀ (i : ι), ∃ t₁, m i ⁻¹' t₁ ∈ f i ∧ eval i ⁻¹' t₁ ⊆ x) →
      ∀ (i : ι), ∃ t₁ ∈ f i, eval i ⁻¹' t₁ ⊆ (fun k i => m i (k i)) ⁻¹' x
state_after: ι : Type u_1
α : ι → Type u_2
f f₁ f₂ : (i : ι) → Filter (α i)
s✝ : (i : ι) → Set (α i)
p : (i : ι) → α i → Prop
β : ι → Type u_3
m : (i : ι) → α i → β i
s : Set ((i : ι) → β i)
h : ∀ (i : ι), ∃ t₁, m i ⁻¹' t₁ ∈ f i ∧ eval i ⁻¹' t₁ ⊆ s
i : ι
⊢ ∃ t₁ ∈ f i, eval i ⁻¹' t₁ ⊆ (fun k i => m i (k i)) ⁻¹' s

tactic: obtain ⟨t, H, hH⟩ := h i
state_before: ι : Type u_1
α : ι → Type u_2
f f₁ f₂ : (i : ι) → Filter (α i)
s✝ : (i : ι) → Set (α i)
p : (i : ι) → α i → Prop
β : ι → Type u_3
m : (i : ι) → α i → β i
s : Set ((i : ι) → β i)
h : ∀ (i : ι), ∃ t₁, m i ⁻¹' t₁ ∈ f i ∧ eval i ⁻¹' t₁ ⊆ s
i : ι
⊢ ∃ t₁ ∈ f i, eval i ⁻¹' t₁ ⊆ (fun k i => m i (k i)) ⁻¹' s
state_after: case intro.intro
ι : Type u_1
α : ι → Type u_2
f f₁ f₂ : (i : ι) → Filter (α i)
s✝ : (i : ι) → Set (α i)
p : (i : ι) → α i → Prop
β : ι → Type u_3
m : (i : ι) → α i → β i
s : Set ((i : ι) → β i)
h : ∀ (i : ι), ∃ t₁, m i ⁻¹' t₁ ∈ f i ∧ eval i ⁻¹' t₁ ⊆ s
i : ι
t : Set (β i)
H : m i ⁻¹' t ∈ f i
hH : eval i ⁻¹' t ⊆ s
⊢ ∃ t₁ ∈ f i, eval i ⁻¹' t₁ ⊆ (fun k i => m i (k i)) ⁻¹' s

tactic: exact ⟨{ x : α i | m i x ∈ t }, H, fun x hx => hH hx⟩
state_before: case intro.intro
ι : Type u_1
α : ι → Type u_2
f f₁ f₂ : (i : ι) → Filter (α i)
s✝ : (i : ι) → Set (α i)
p : (i : ι) → α i → Prop
β : ι → Type u_3
m : (i : ι) → α i → β i
s : Set ((i : ι) → β i)
h : ∀ (i : ι), ∃ t₁, m i ⁻¹' t₁ ∈ f i ∧ eval i ⁻¹' t₁ ⊆ s
i : ι
t : Set (β i)
H : m i ⁻¹' t ∈ f i
hH : eval i ⁻¹' t ⊆ s
⊢ ∃ t₁ ∈ f i, eval i ⁻¹' t₁ ⊆ (fun k i => m i (k i)) ⁻¹' s
state_after: no goals
Theorem: Batteries.RBNode.foldr_reverse
File: .lake/packages/batteries/Batteries/Data/RBMap/Lemmas.lean

tactic: simp
state_before: α : Type u_1
β : Type u_2
t : RBNode α
f : α → β → β
init : β
⊢ foldl (fun a b => f b a) init t.reverse.reverse = foldl (flip f) init t
state_after: α : Type u_1
β : Type u_2
t : RBNode α
f : α → β → β
init : β
⊢ foldl (fun a b => f b a) init t = foldl (flip f) init t

tactic: rfl
state_before: α : Type u_1
β : Type u_2
t : RBNode α
f : α → β → β
init : β
⊢ foldl (fun a b => f b a) init t = foldl (flip f) init t
state_after: no goals
Theorem: AffineIndependent.card_le_finrank_succ
File: Mathlib/LinearAlgebra/AffineSpace/FiniteDimensional.lean

tactic: cases isEmpty_or_nonempty ι
state_before: k : Type u_1
V : Type u_2
P : Type u_3
ι : Type u_4
inst✝⁴ : DivisionRing k
inst✝³ : AddCommGroup V
inst✝² : Module k V
inst✝¹ : AffineSpace V P
inst✝ : Fintype ι
p : ι → P
hp : AffineIndependent k p
⊢ Fintype.card ι ≤ finrank k ↥(vectorSpan k (Set.range p)) + 1
state_after: case inl
k : Type u_1
V : Type u_2
P : Type u_3
ι : Type u_4
inst✝⁴ : DivisionRing k
inst✝³ : AddCommGroup V
inst✝² : Module k V
inst✝¹ : AffineSpace V P
inst✝ : Fintype ι
p : ι → P
hp : AffineIndependent k p
h✝ : IsEmpty ι
⊢ Fintype.card ι ≤ finrank k ↥(vectorSpan k (Set.range p)) + 1

case inr
k : Type u_1
V : Type u_2
P : Type u_3
ι : Type u_4
inst✝⁴ : DivisionRing k
inst✝³ : AddCommGroup V
inst✝² : Module k V
inst✝¹ : AffineSpace V P
inst✝ : Fintype ι
p : ι → P
hp : AffineIndependent k p
h✝ : Nonempty ι
⊢ Fintype.card ι ≤ finrank k ↥(vectorSpan k (Set.range p)) + 1

tactic: rw [← tsub_le_iff_right]
state_before: case inr
k : Type u_1
V : Type u_2
P : Type u_3
ι : Type u_4
inst✝⁴ : DivisionRing k
inst✝³ : AddCommGroup V
inst✝² : Module k V
inst✝¹ : AffineSpace V P
inst✝ : Fintype ι
p : ι → P
hp : AffineIndependent k p
h✝ : Nonempty ι
⊢ Fintype.card ι ≤ finrank k ↥(vectorSpan k (Set.range p)) + 1
state_after: case inr
k : Type u_1
V : Type u_2
P : Type u_3
ι : Type u_4
inst✝⁴ : DivisionRing k
inst✝³ : AddCommGroup V
inst✝² : Module k V
inst✝¹ : AffineSpace V P
inst✝ : Fintype ι
p : ι → P
hp : AffineIndependent k p
h✝ : Nonempty ι
⊢ Fintype.card ι - 1 ≤ finrank k ↥(vectorSpan k (Set.range p))

tactic: exact (affineIndependent_iff_le_finrank_vectorSpan _ _
  (tsub_add_cancel_of_le <| Nat.one_le_iff_ne_zero.2 Fintype.card_ne_zero).symm).1 hp
state_before: case inr
k : Type u_1
V : Type u_2
P : Type u_3
ι : Type u_4
inst✝⁴ : DivisionRing k
inst✝³ : AddCommGroup V
inst✝² : Module k V
inst✝¹ : AffineSpace V P
inst✝ : Fintype ι
p : ι → P
hp : AffineIndependent k p
h✝ : Nonempty ι
⊢ Fintype.card ι - 1 ≤ finrank k ↥(vectorSpan k (Set.range p))
state_after: no goals

tactic: simp [Fintype.card_eq_zero]
state_before: case inl
k : Type u_1
V : Type u_2
P : Type u_3
ι : Type u_4
inst✝⁴ : DivisionRing k
inst✝³ : AddCommGroup V
inst✝² : Module k V
inst✝¹ : AffineSpace V P
inst✝ : Fintype ι
p : ι → P
hp : AffineIndependent k p
h✝ : IsEmpty ι
⊢ Fintype.card ι ≤ finrank k ↥(vectorSpan k (Set.range p)) + 1
state_after: no goals
Theorem: Finset.mem_compl
File: Mathlib/Data/Fintype/Basic.lean

tactic: simp [compl_eq_univ_sdiff]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : Fintype α
s t : Finset α
inst✝ : DecidableEq α
a : α
⊢ a ∈ sᶜ ↔ a ∉ s
state_after: no goals
Theorem: Complex.linearEquiv_det_conjAe
File: Mathlib/Data/Complex/Determinant.lean

tactic: rw [← Units.eq_iff, LinearEquiv.coe_det, AlgEquiv.toLinearEquiv_toLinearMap, det_conjAe,
  Units.coe_neg_one]
state_before: ⊢ LinearEquiv.det conjAe.toLinearEquiv = -1
state_after: no goals
Theorem: Filter.limsup_const_bot
File: Mathlib/Order/LiminfLimsup.lean

tactic: rw [limsup_eq, eq_bot_iff]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
inst✝ : CompleteLattice α
f : Filter β
⊢ limsup (fun x => ⊥) f = ⊥
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
inst✝ : CompleteLattice α
f : Filter β
⊢ sInf {a | ∀ᶠ (n : β) in f, ⊥ ≤ a} ≤ ⊥

tactic: exact sInf_le (eventually_of_forall fun _ => le_rfl)
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
inst✝ : CompleteLattice α
f : Filter β
⊢ sInf {a | ∀ᶠ (n : β) in f, ⊥ ≤ a} ≤ ⊥
state_after: no goals
Theorem: div_lt_one_iff
File: Mathlib/Algebra/Order/Field/Basic.lean

tactic: rcases lt_trichotomy b 0 with (hb | rfl | hb)
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedField α
a b c d : α
n : ℤ
⊢ a / b < 1 ↔ 0 < b ∧ a < b ∨ b = 0 ∨ b < 0 ∧ b < a
state_after: case inl
ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedField α
a b c d : α
n : ℤ
hb : b < 0
⊢ a / b < 1 ↔ 0 < b ∧ a < b ∨ b = 0 ∨ b < 0 ∧ b < a

case inr.inl
ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedField α
a c d : α
n : ℤ
⊢ a / 0 < 1 ↔ 0 < 0 ∧ a < 0 ∨ 0 = 0 ∨ 0 < 0 ∧ 0 < a

case inr.inr
ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedField α
a b c d : α
n : ℤ
hb : 0 < b
⊢ a / b < 1 ↔ 0 < b ∧ a < b ∨ b = 0 ∨ b < 0 ∧ b < a

tactic: simp [hb, hb.not_lt, hb.ne, div_lt_one_of_neg]
state_before: case inl
ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedField α
a b c d : α
n : ℤ
hb : b < 0
⊢ a / b < 1 ↔ 0 < b ∧ a < b ∨ b = 0 ∨ b < 0 ∧ b < a
state_after: no goals

tactic: simp [zero_lt_one]
state_before: case inr.inl
ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedField α
a c d : α
n : ℤ
⊢ a / 0 < 1 ↔ 0 < 0 ∧ a < 0 ∨ 0 = 0 ∨ 0 < 0 ∧ 0 < a
state_after: no goals

tactic: simp [hb, hb.not_lt, div_lt_one, hb.ne.symm]
state_before: case inr.inr
ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedField α
a b c d : α
n : ℤ
hb : 0 < b
⊢ a / b < 1 ↔ 0 < b ∧ a < b ∨ b = 0 ∨ b < 0 ∧ b < a
state_after: no goals
Theorem: differentiableAt_sub_const_iff
File: Mathlib/Analysis/Calculus/FDeriv/Add.lean

tactic: simp only [sub_eq_add_neg, differentiableAt_add_const_iff]
state_before: 𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type u_4
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type u_5
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
c : F
⊢ DifferentiableAt 𝕜 (fun y => f y - c) x ↔ DifferentiableAt 𝕜 f x
state_after: no goals