ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: sbtw_const_vadd_iff
File: Mathlib/Analysis/Convex/Between.lean

Proof steps:
state_before: R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝⁶ : OrderedRing R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
x y z : P
v : V
⊢ Sbtw R (v +ᵥ x) (v +ᵥ y) (v +ᵥ z) ↔ Sbtw R x y z
state_after: no goals
tactic: rw [Sbtw, Sbtw, wbtw_const_vadd_iff, (AddAction.injective v).ne_iff,
    (AddAction.injective v).ne_iff]
Theorem: tsub_eq_zero_iff_le
File: Mathlib/Algebra/Order/Sub/Canonical.lean

Proof steps:
state_before: α : Type u_1
inst✝² : CanonicallyOrderedAddCommMonoid α
inst✝¹ : Sub α
inst✝ : OrderedSub α
a b c d : α
⊢ a - b = 0 ↔ a ≤ b
state_after: no goals
tactic: rw [← nonpos_iff_eq_zero, tsub_le_iff_left, add_zero]
Theorem: addRothNumber_map_add_right
File: Mathlib/Combinatorics/Additive/AP/Three/Defs.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
𝕜 : Type u_4
E : Type u_5
inst✝¹ : DecidableEq α
inst✝ : CancelCommMonoid α
s : Finset α
a : α
⊢ mulRothNumber (map (mulRightEmbedding a) s) = mulRothNumber s
state_after: no goals
tactic: rw [← mulLeftEmbedding_eq_mulRightEmbedding, mulRothNumber_map_mul_left s a]
Theorem: Submodule.equivOpposite_apply
File: Mathlib/Algebra/Algebra/Operations.lean

Proof steps:
state_before: ι : Sort uι
R : Type u
inst✝² : CommSemiring R
A : Type v
inst✝¹ : Semiring A
inst✝ : Algebra R A
S T : Set A
M N P Q : Submodule R A
m n : A
p q : Submodule R Aᵐᵒᵖ
⊢ { toFun := fun p => op (comap (↑(opLinearEquiv R)) p), invFun := fun p => comap (↑(opLinearEquiv R).symm) (unop p),
          left_inv := ⋯, right_inv := ⋯ }.toFun
      (p + q) =
    { toFun := fun p => op (comap (↑(opLinearEquiv R)) p), invFun := fun p => comap (↑(opLinearEquiv R).symm) (unop p),
            left_inv := ⋯, right_inv := ⋯ }.toFun
        p +
      { toFun := fun p => op (comap (↑(opLinearEquiv R)) p),
            invFun := fun p => comap (↑(opLinearEquiv R).symm) (unop p), left_inv := ⋯, right_inv := ⋯ }.toFun
        q
state_after: no goals
tactic: simp [comap_equiv_eq_map_symm, ← op_add]
Theorem: OrthogonalIdempotents.isIdempotentElem_sum
File: Mathlib/RingTheory/Idempotents.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
inst✝² : Ring R
inst✝¹ : Ring S
f : R →+* S
I : Type u_3
e : I → R
he : OrthogonalIdempotents e
inst✝ : Fintype I
⊢ IsIdempotentElem (∑ i : I, e i)
state_after: no goals
tactic: classical
  simp [IsIdempotentElem, Finset.sum_mul, Finset.mul_sum, he.mul_eq]
Theorem: CoxeterSystem.isRightInversion_of_mem_rightInvSeq
File: Mathlib/GroupTheory/Coxeter/Inversion.lean

Proof steps:
state_before: B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
ω : List B
hω : cs.IsReduced ω
t : W
ht : t ∈ cs.rightInvSeq ω
⊢ cs.IsRightInversion (cs.wordProd ω) t
state_after: case left
B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
ω : List B
hω : cs.IsReduced ω
t : W
ht : t ∈ cs.rightInvSeq ω
⊢ cs.IsReflection t

case right
B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
ω : List B
hω : cs.IsReduced ω
t : W
ht : t ∈ cs.rightInvSeq ω
⊢ cs.length (cs.wordProd ω * t) < cs.length (cs.wordProd ω)
tactic: constructor
Theorem: Equiv.Perm.SameCycle.conj
File: Mathlib/GroupTheory/Perm/Cycle/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
f g : Perm α
p : α → Prop
x y z : α
⊢ f.SameCycle x y → (g * f * g⁻¹).SameCycle (g x) (g y)
state_after: no goals
tactic: simp [sameCycle_conj]
Theorem: one_div_ne_zero
File: Mathlib/Algebra/GroupWithZero/Basic.lean

Proof steps:
state_before: α : Type u_1
M₀ : Type u_2
G₀ : Type u_3
M₀' : Type u_4
G₀' : Type u_5
F : Type u_6
F' : Type u_7
inst✝ : GroupWithZero G₀
a✝ b c a : G₀
h : a ≠ 0
⊢ 1 / a ≠ 0
state_after: no goals
tactic: simpa only [one_div] using inv_ne_zero h
Theorem: IsAddGroupHom.image_addSubgroup
File: Mathlib/Deprecated/Subgroup.lean

Proof steps:
state_before: G : Type u_1
H : Type u_2
A : Type u_3
a a₁✝ a₂✝ b c : G
inst✝¹ : Group G
inst✝ : Group H
f : G → H
hf : IsGroupHom f
s : Set G
hs : IsSubgroup s
a₁ a₂ : H
x✝¹ : a₁ ∈ f '' s
x✝ : a₂ ∈ f '' s
b₁ : G
hb₁ : b₁ ∈ s
eq₁ : f b₁ = a₁
b₂ : G
hb₂ : b₂ ∈ s
eq₂ : f b₂ = a₂
⊢ f (b₁ * b₂) = a₁ * a₂
state_after: no goals
tactic: simp [eq₁, eq₂, hf.map_mul]
state_before: G : Type u_1
H : Type u_2
A : Type u_3
a✝ a₁ a₂ b✝ c : G
inst✝¹ : Group G
inst✝ : Group H
f : G → H
hf : IsGroupHom f
s : Set G
hs : IsSubgroup s
a : H
x✝ : a ∈ f '' s
b : G
hb : b ∈ s
Eq : f b = a
⊢ f b⁻¹ = a⁻¹
state_after: G : Type u_1
H : Type u_2
A : Type u_3
a✝ a₁ a₂ b✝ c : G
inst✝¹ : Group G
inst✝ : Group H
f : G → H
hf : IsGroupHom f
s : Set G
hs : IsSubgroup s
a : H
x✝ : a ∈ f '' s
b : G
hb : b ∈ s
Eq : f b = a
⊢ (f b)⁻¹ = a⁻¹
tactic: rw [hf.map_inv]
state_before: G : Type u_1
H : Type u_2
A : Type u_3
a✝ a₁ a₂ b✝ c : G
inst✝¹ : Group G
inst✝ : Group H
f : G → H
hf : IsGroupHom f
s : Set G
hs : IsSubgroup s
a : H
x✝ : a ∈ f '' s
b : G
hb : b ∈ s
Eq : f b = a
⊢ (f b)⁻¹ = a⁻¹
state_after: no goals
tactic: simp [*]
Theorem: Rat.div_lt_div_iff_mul_lt_mul
File: Mathlib/Algebra/Order/Ring/Rat.lean

Proof steps:
state_before: a✝ b✝ c✝ p q : ℚ
a b c d : ℤ
b_pos : 0 < b
d_pos : 0 < d
⊢ ↑a / ↑b < ↑c / ↑d ↔ a * d < c * b
state_after: a✝ b✝ c✝ p q : ℚ
a b c d : ℤ
b_pos : 0 < b
d_pos : 0 < d
⊢ ↑a / ↑b ≤ ↑c / ↑d ∧ ¬↑c / ↑d ≤ ↑a / ↑b ↔ a * d ≤ c * b ∧ ¬c * b ≤ a * d
tactic: simp only [lt_iff_le_not_le]
state_before: a✝ b✝ c✝ p q : ℚ
a b c d : ℤ
b_pos : 0 < b
d_pos : 0 < d
⊢ ↑a / ↑b ≤ ↑c / ↑d ∧ ¬↑c / ↑d ≤ ↑a / ↑b ↔ a * d ≤ c * b ∧ ¬c * b ≤ a * d
state_after: case h₁
a✝ b✝ c✝ p q : ℚ
a b c d : ℤ
b_pos : 0 < b
d_pos : 0 < d
⊢ ↑a / ↑b ≤ ↑c / ↑d ↔ a * d ≤ c * b

case h₂
a✝ b✝ c✝ p q : ℚ
a b c d : ℤ
b_pos : 0 < b
d_pos : 0 < d
⊢ ¬↑c / ↑d ≤ ↑a / ↑b ↔ ¬c * b ≤ a * d
tactic: apply and_congr
Theorem: Subring.coe_iInf
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
ι : Sort u_1
S : ι → Subring R
⊢ ↑(⨅ i, S i) = ⋂ i, ↑(S i)
state_after: no goals
tactic: simp only [iInf, coe_sInf, Set.biInter_range]
Theorem: CategoryTheory.OplaxNatTrans.associator_hom_app
File: Mathlib/CategoryTheory/Bicategory/FunctorBicategory.lean

Proof steps:
state_before: B : Type u₁
inst✝¹ : Bicategory B
C : Type u₂
inst✝ : Bicategory C
F G H I : OplaxFunctor B C
η : F ⟶ G
θ : G ⟶ H
ι : H ⟶ I
⊢ ∀ {a b : B} (f : a ⟶ b),
    F.map f ◁ ((fun a => α_ (η.app a) (θ.app a) (ι.app a)) b).hom ≫ (η ≫ θ ≫ ι).naturality f =
      ((η ≫ θ) ≫ ι).naturality f ≫ ((fun a => α_ (η.app a) (θ.app a) (ι.app a)) a).hom ▷ I.map f
state_after: no goals
tactic: aesop_cat
Theorem: real_inner_self_eq_norm_sq
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
x : F
⊢ ⟪x, x⟫_ℝ = ‖x‖ ^ 2
state_after: no goals
tactic: rw [pow_two, real_inner_self_eq_norm_mul_norm]
Theorem: legendreSym.at_zero
File: Mathlib/NumberTheory/LegendreSymbol/Basic.lean

Proof steps:
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
⊢ legendreSym p 0 = 0
state_after: no goals
tactic: rw [legendreSym, Int.cast_zero, MulChar.map_zero]
Theorem: CategoryTheory.Limits.limit.isoLimitCone_inv_π
File: Mathlib/CategoryTheory/Limits/HasLimits.lean

Proof steps:
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✝ F : J ⥤ C
inst✝ : HasLimit F
t : LimitCone F
j : J
⊢ (isoLimitCone t).inv ≫ π F j = t.cone.π.app j
state_after: 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✝ F : J ⥤ C
inst✝ : HasLimit F
t : LimitCone F
j : J
⊢ lift F t.cone ≫ π F j = t.cone.π.app j
tactic: dsimp [limit.isoLimitCone, IsLimit.conePointUniqueUpToIso]
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✝ F : J ⥤ C
inst✝ : HasLimit F
t : LimitCone F
j : J
⊢ lift F t.cone ≫ π F j = t.cone.π.app j
state_after: no goals
tactic: aesop_cat
Theorem: measurable_deriv
File: Mathlib/Analysis/Calculus/FDeriv/Measurable.lean

Proof steps:
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
f✝ : E → F
K : Set (E →L[𝕜] F)
inst✝⁶ : MeasurableSpace E
inst✝⁵ : OpensMeasurableSpace E
inst✝⁴ : CompleteSpace F
inst✝³ : MeasurableSpace 𝕜
inst✝² : OpensMeasurableSpace 𝕜
inst✝¹ : MeasurableSpace F
inst✝ : BorelSpace F
f : 𝕜 → F
⊢ Measurable (deriv f)
state_after: no goals
tactic: simpa only [fderiv_deriv] using measurable_fderiv_apply_const 𝕜 f 1
Theorem: CategoryTheory.strict_initial
File: Mathlib/CategoryTheory/Closed/Cartesian.lean

Proof steps:
state_before: C : Type u
inst✝² : Category.{v, u} C
A B X X' Y Y' Z : C
inst✝¹ : HasFiniteProducts C
inst✝ : Exponentiable A
I : C
t : IsInitial I
f : A ⟶ I
⊢ IsIso f
state_after: C : Type u
inst✝² : Category.{v, u} C
A B X X' Y Y' Z : C
inst✝¹ : HasFiniteProducts C
inst✝ : Exponentiable A
I : C
t : IsInitial I
f : A ⟶ I
this : Mono (prod.lift (𝟙 A) f ≫ (zeroMul t).hom)
⊢ IsIso f
tactic: haveI : Mono (prod.lift (𝟙 A) f ≫ (zeroMul t).hom) := mono_comp _ _
state_before: C : Type u
inst✝² : Category.{v, u} C
A B X X' Y Y' Z : C
inst✝¹ : HasFiniteProducts C
inst✝ : Exponentiable A
I : C
t : IsInitial I
f : A ⟶ I
this : Mono (prod.lift (𝟙 A) f ≫ (zeroMul t).hom)
⊢ IsIso f
state_after: C : Type u
inst✝² : Category.{v, u} C
A B X X' Y Y' Z : C
inst✝¹ : HasFiniteProducts C
inst✝ : Exponentiable A
I : C
t : IsInitial I
f : A ⟶ I
this : Mono f
⊢ IsIso f
tactic: rw [zeroMul_hom, prod.lift_snd] at this
state_before: C : Type u
inst✝² : Category.{v, u} C
A B X X' Y Y' Z : C
inst✝¹ : HasFiniteProducts C
inst✝ : Exponentiable A
I : C
t : IsInitial I
f : A ⟶ I
this : Mono f
⊢ IsIso f
state_after: C : Type u
inst✝² : Category.{v, u} C
A B X X' Y Y' Z : C
inst✝¹ : HasFiniteProducts C
inst✝ : Exponentiable A
I : C
t : IsInitial I
f : A ⟶ I
this✝ : Mono f
this : IsSplitEpi f
⊢ IsIso f
tactic: haveI : IsSplitEpi f := IsSplitEpi.mk' ⟨t.to _, t.hom_ext _ _⟩
state_before: C : Type u
inst✝² : Category.{v, u} C
A B X X' Y Y' Z : C
inst✝¹ : HasFiniteProducts C
inst✝ : Exponentiable A
I : C
t : IsInitial I
f : A ⟶ I
this✝ : Mono f
this : IsSplitEpi f
⊢ IsIso f
state_after: no goals
tactic: apply isIso_of_mono_of_isSplitEpi
Theorem: IsLocalization.AtPrime.to_map_mem_maximal_iff
File: Mathlib/RingTheory/Localization/AtPrime.lean

Proof steps:
state_before: R : Type u_1
inst✝⁶ : CommSemiring R
M : Submonoid R
S : Type u_2
inst✝⁵ : CommSemiring S
inst✝⁴ : Algebra R S
P : Type u_3
inst✝³ : CommSemiring P
A : Type u_4
inst✝² : CommRing A
inst✝¹ : IsDomain A
I : Ideal R
hI : I.IsPrime
inst✝ : IsLocalization.AtPrime S I
x : R
h : optParam (LocalRing S) ⋯
⊢ (algebraMap R S) x ∉ LocalRing.maximalIdeal S ↔ x ∉ I
state_after: no goals
tactic: simpa only [LocalRing.mem_maximalIdeal, mem_nonunits_iff, Classical.not_not] using
      isUnit_to_map_iff S I x
Theorem: Finset.ruzsa_triangle_inequality_sub_sub_sub
File: Mathlib/Combinatorics/Additive/PluenneckeRuzsa.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : CommGroup α
inst✝ : DecidableEq α
A✝ B✝ C✝ A B C : Finset α
⊢ (A / C).card * B.card ≤ (A / B).card * (B / C).card
state_after: α : Type u_1
inst✝¹ : CommGroup α
inst✝ : DecidableEq α
A✝ B✝ C✝ A B C : Finset α
⊢ (A / C).card * B.card ≤ ((A / B) ×ˢ (B / C)).card * 1
tactic: rw [← card_product (A / B), ← mul_one ((A / B) ×ˢ (B / C)).card]
state_before: α : Type u_1
inst✝¹ : CommGroup α
inst✝ : DecidableEq α
A✝ B✝ C✝ A B C : Finset α
⊢ (A / C).card * B.card ≤ ((A / B) ×ˢ (B / C)).card * 1
state_after: case refine_1
α : Type u_1
inst✝¹ : CommGroup α
inst✝ : DecidableEq α
A✝ B✝ C✝ A B C : Finset α
x : α
hx : x ∈ A / C
⊢ B.card ≤ (bipartiteAbove (fun b ac => ac.1 * ac.2 = b) ((A / B) ×ˢ (B / C)) x).card

case refine_2
α : Type u_1
inst✝¹ : CommGroup α
inst✝ : DecidableEq α
A✝ B✝ C✝ A B C : Finset α
x : α × α
x✝ : x ∈ (A / B) ×ˢ (B / C)
a✝ b✝ : α
hu : a✝ ∈ bipartiteBelow (fun b ac => ac.1 * ac.2 = b) (A / C) x
hv : b✝ ∈ bipartiteBelow (fun b ac => ac.1 * ac.2 = b) (A / C) x
⊢ x.1 * x.2 = b✝
tactic: refine card_mul_le_card_mul (fun b ac ↦ ac.1 * ac.2 = b) (fun x hx ↦ ?_)
    fun x _ ↦ card_le_one_iff.2 fun hu hv ↦
      ((mem_bipartiteBelow _).1 hu).2.symm.trans ?_
Theorem: Filter.HasBasis.equicontinuousWithinAt_iff_left
File: Mathlib/Topology/UniformSpace/Equicontinuity.lean

Proof steps:
state_before: ι : Type u_1
κ : Type u_2
X : Type u_3
X' : Type u_4
Y : Type u_5
Z : Type u_6
α : Type u_7
α' : Type u_8
β : Type u_9
β' : Type u_10
γ : Type u_11
𝓕 : Type u_12
tX : TopologicalSpace X
tY : TopologicalSpace Y
tZ : TopologicalSpace Z
uα : UniformSpace α
uβ : UniformSpace β
uγ : UniformSpace γ
p : κ → Prop
s : κ → Set X
F : ι → X → α
S : Set X
x₀ : X
hX : (𝓝[S] x₀).HasBasis p s
⊢ EquicontinuousWithinAt F S x₀ ↔ ∀ U ∈ 𝓤 α, ∃ k, p k ∧ ∀ x ∈ s k, ∀ (i : ι), (F i x₀, F i x) ∈ U
state_after: ι : Type u_1
κ : Type u_2
X : Type u_3
X' : Type u_4
Y : Type u_5
Z : Type u_6
α : Type u_7
α' : Type u_8
β : Type u_9
β' : Type u_10
γ : Type u_11
𝓕 : Type u_12
tX : TopologicalSpace X
tY : TopologicalSpace Y
tZ : TopologicalSpace Z
uα : UniformSpace α
uβ : UniformSpace β
uγ : UniformSpace γ
p : κ → Prop
s : κ → Set X
F : ι → X → α
S : Set X
x₀ : X
hX : (𝓝[S] x₀).HasBasis p s
⊢ (∀ ib ∈ 𝓤 α,
      ∃ ia,
        p ia ∧
          ∀ x ∈ s ia,
            (⇑UniformFun.ofFun ∘ swap F) x ∈ {g | ((⇑UniformFun.ofFun ∘ swap F) x₀, g) ∈ UniformFun.gen ι α ib}) ↔
    ∀ U ∈ 𝓤 α, ∃ k, p k ∧ ∀ x ∈ s k, ∀ (i : ι), (F i x₀, F i x) ∈ U
tactic: rw [equicontinuousWithinAt_iff_continuousWithinAt, ContinuousWithinAt,
    hX.tendsto_iff (UniformFun.hasBasis_nhds ι α _)]
state_before: ι : Type u_1
κ : Type u_2
X : Type u_3
X' : Type u_4
Y : Type u_5
Z : Type u_6
α : Type u_7
α' : Type u_8
β : Type u_9
β' : Type u_10
γ : Type u_11
𝓕 : Type u_12
tX : TopologicalSpace X
tY : TopologicalSpace Y
tZ : TopologicalSpace Z
uα : UniformSpace α
uβ : UniformSpace β
uγ : UniformSpace γ
p : κ → Prop
s : κ → Set X
F : ι → X → α
S : Set X
x₀ : X
hX : (𝓝[S] x₀).HasBasis p s
⊢ (∀ ib ∈ 𝓤 α,
      ∃ ia,
        p ia ∧
          ∀ x ∈ s ia,
            (⇑UniformFun.ofFun ∘ swap F) x ∈ {g | ((⇑UniformFun.ofFun ∘ swap F) x₀, g) ∈ UniformFun.gen ι α ib}) ↔
    ∀ U ∈ 𝓤 α, ∃ k, p k ∧ ∀ x ∈ s k, ∀ (i : ι), (F i x₀, F i x) ∈ U
state_after: no goals
tactic: rfl
Theorem: Filter.ptendsto'_of_ptendsto
File: Mathlib/Order/Filter/Partial.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
f : α →. β
l₁ : Filter α
l₂ : Filter β
h : f.Dom ∈ l₁
⊢ PTendsto f l₁ l₂ → PTendsto' f l₁ l₂
state_after: α : Type u
β : Type v
γ : Type w
f : α →. β
l₁ : Filter α
l₂ : Filter β
h : f.Dom ∈ l₁
⊢ (∀ s ∈ l₂, f.core s ∈ l₁) → ∀ s ∈ l₂, f.preimage s ∈ l₁
tactic: rw [ptendsto_def, ptendsto'_def]
state_before: α : Type u
β : Type v
γ : Type w
f : α →. β
l₁ : Filter α
l₂ : Filter β
h : f.Dom ∈ l₁
⊢ (∀ s ∈ l₂, f.core s ∈ l₁) → ∀ s ∈ l₂, f.preimage s ∈ l₁
state_after: α : Type u
β : Type v
γ : Type w
f : α →. β
l₁ : Filter α
l₂ : Filter β
h : f.Dom ∈ l₁
h' : ∀ s ∈ l₂, f.core s ∈ l₁
s : Set β
sl₂ : s ∈ l₂
⊢ f.preimage s ∈ l₁
tactic: intro h' s sl₂
state_before: α : Type u
β : Type v
γ : Type w
f : α →. β
l₁ : Filter α
l₂ : Filter β
h : f.Dom ∈ l₁
h' : ∀ s ∈ l₂, f.core s ∈ l₁
s : Set β
sl₂ : s ∈ l₂
⊢ f.preimage s ∈ l₁
state_after: α : Type u
β : Type v
γ : Type w
f : α →. β
l₁ : Filter α
l₂ : Filter β
h : f.Dom ∈ l₁
h' : ∀ s ∈ l₂, f.core s ∈ l₁
s : Set β
sl₂ : s ∈ l₂
⊢ f.core s ∩ f.Dom ∈ l₁
tactic: rw [PFun.preimage_eq]
state_before: α : Type u
β : Type v
γ : Type w
f : α →. β
l₁ : Filter α
l₂ : Filter β
h : f.Dom ∈ l₁
h' : ∀ s ∈ l₂, f.core s ∈ l₁
s : Set β
sl₂ : s ∈ l₂
⊢ f.core s ∩ f.Dom ∈ l₁
state_after: no goals
tactic: exact inter_mem (h' s sl₂) h
Theorem: HahnSeries.orderTop_le_of_coeff_ne_zero
File: Mathlib/RingTheory/HahnSeries/Basic.lean

Proof steps:
state_before: Γ✝ : Type u_1
R : Type u_2
inst✝² : PartialOrder Γ✝
inst✝¹ : Zero R
a b : Γ✝
r : R
Γ : Type u_3
inst✝ : LinearOrder Γ
x : HahnSeries Γ R
g : Γ
h : x.coeff g ≠ 0
⊢ x.orderTop ≤ ↑g
state_after: Γ✝ : Type u_1
R : Type u_2
inst✝² : PartialOrder Γ✝
inst✝¹ : Zero R
a b : Γ✝
r : R
Γ : Type u_3
inst✝ : LinearOrder Γ
x : HahnSeries Γ R
g : Γ
h : x.coeff g ≠ 0
⊢ ⋯.min ⋯ ≤ g
tactic: rw [orderTop_of_ne (ne_zero_of_coeff_ne_zero h), WithTop.coe_le_coe]
state_before: Γ✝ : Type u_1
R : Type u_2
inst✝² : PartialOrder Γ✝
inst✝¹ : Zero R
a b : Γ✝
r : R
Γ : Type u_3
inst✝ : LinearOrder Γ
x : HahnSeries Γ R
g : Γ
h : x.coeff g ≠ 0
⊢ ⋯.min ⋯ ≤ g
state_after: no goals
tactic: exact Set.IsWF.min_le _ _ ((mem_support _ _).2 h)
Theorem: orthogonalProjection_bot
File: Mathlib/Analysis/InnerProductSpace/Projection.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁵ : _root_.RCLike 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedAddCommGroup F
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : InnerProductSpace ℝ F
K : Submodule 𝕜 E
inst✝ : HasOrthogonalProjection K
⊢ orthogonalProjection ⊥ = 0
state_after: no goals
tactic: ext
Theorem: Equiv.swap_bijOn_exchange
File: Mathlib/Logic/Equiv/Set.lean

Proof steps:
state_before: α✝ : Sort u
β : Sort v
γ : Sort w
α : Type u_1
inst✝ : DecidableEq α
a b : α
s : Set α
ha : a ∈ s
hb : b ∉ s
⊢ BijOn (⇑(swap a b)) s (insert b (s \ {a}))
state_after: case refine_1
α✝ : Sort u
β : Sort v
γ : Sort w
α : Type u_1
inst✝ : DecidableEq α
a b : α
s : Set α
ha : a ∈ s
hb : b ∉ s
x : α
hx : x ∈ s
⊢ (swap a b) x ∈ insert b (s \ {a})

case refine_2
α✝ : Sort u
β : Sort v
γ : Sort w
α : Type u_1
inst✝ : DecidableEq α
a b : α
s : Set α
ha : a ∈ s
hb : b ∉ s
x : α
hx : x ∈ insert b (s \ {a})
⊢ x ∈ ⇑(swap a b) '' s
tactic: refine ⟨fun x hx ↦ ?_, (Equiv.injective _).injOn, fun x hx ↦ ?_⟩
state_before: case refine_2
α✝ : Sort u
β : Sort v
γ : Sort w
α : Type u_1
inst✝ : DecidableEq α
a b : α
s : Set α
ha : a ∈ s
hb : b ∉ s
x : α
hx : x ∈ insert b (s \ {a})
⊢ x ∈ ⇑(swap a b) '' s
state_after: case refine_2.inl
α✝ : Sort u
β : Sort v
γ : Sort w
α : Type u_1
inst✝ : DecidableEq α
a : α
s : Set α
ha : a ∈ s
x : α
hb : x ∉ s
hx : x ∈ insert x (s \ {a})
⊢ x ∈ ⇑(swap a x) '' s

case refine_2.inr
α✝ : Sort u
β : Sort v
γ : Sort w
α : Type u_1
inst✝ : DecidableEq α
a b : α
s : Set α
ha : a ∈ s
hb : b ∉ s
x : α
hx : x ∈ insert b (s \ {a})
hxb : x ≠ b
⊢ x ∈ ⇑(swap a b) '' s
tactic: obtain (rfl | hxb) := eq_or_ne x b
state_before: case refine_2.inr
α✝ : Sort u
β : Sort v
γ : Sort w
α : Type u_1
inst✝ : DecidableEq α
a b : α
s : Set α
ha : a ∈ s
hb : b ∉ s
x : α
hx : x ∈ insert b (s \ {a})
hxb : x ≠ b
⊢ x ∈ ⇑(swap a b) '' s
state_after: case refine_2.inr
α✝ : Sort u
β : Sort v
γ : Sort w
α : Type u_1
inst✝ : DecidableEq α
a b : α
s : Set α
ha : a ∈ s
hb : b ∉ s
x : α
hxb : x ≠ b
hx : x ∈ s ∧ ¬x = a
⊢ x ∈ ⇑(swap a b) '' s
tactic: simp only [mem_insert_iff, mem_diff, mem_singleton_iff, or_iff_right hxb] at hx
state_before: case refine_2.inr
α✝ : Sort u
β : Sort v
γ : Sort w
α : Type u_1
inst✝ : DecidableEq α
a b : α
s : Set α
ha : a ∈ s
hb : b ∉ s
x : α
hxb : x ≠ b
hx : x ∈ s ∧ ¬x = a
⊢ x ∈ ⇑(swap a b) '' s
state_after: no goals
tactic: exact ⟨x, hx.1, swap_apply_of_ne_of_ne hx.2 hxb⟩
Theorem: SameRay.map
File: Mathlib/LinearAlgebra/Ray.lean

Proof steps:
state_before: R : Type u_1
inst✝¹⁰ : StrictOrderedCommSemiring R
M : Type u_2
inst✝⁹ : AddCommMonoid M
inst✝⁸ : Module R M
N : Type u_3
inst✝⁷ : AddCommMonoid N
inst✝⁶ : Module R N
ι : Type u_4
inst✝⁵ : DecidableEq ι
x y z : M
S : Type u_5
inst✝⁴ : OrderedCommSemiring S
inst✝³ : Algebra S R
inst✝² : Module S M
inst✝¹ : SMulPosMono S R
inst✝ : IsScalarTower S R M
a : S
f : M →ₗ[R] N
h : SameRay R x y
hx : x = 0
⊢ f x = 0
state_after: no goals
tactic: rw [hx, map_zero]
state_before: R : Type u_1
inst✝¹⁰ : StrictOrderedCommSemiring R
M : Type u_2
inst✝⁹ : AddCommMonoid M
inst✝⁸ : Module R M
N : Type u_3
inst✝⁷ : AddCommMonoid N
inst✝⁶ : Module R N
ι : Type u_4
inst✝⁵ : DecidableEq ι
x y z : M
S : Type u_5
inst✝⁴ : OrderedCommSemiring S
inst✝³ : Algebra S R
inst✝² : Module S M
inst✝¹ : SMulPosMono S R
inst✝ : IsScalarTower S R M
a : S
f : M →ₗ[R] N
h : SameRay R x y
hy : y = 0
⊢ f y = 0
state_after: no goals
tactic: rw [hy, map_zero]
state_before: R : Type u_1
inst✝¹⁰ : StrictOrderedCommSemiring R
M : Type u_2
inst✝⁹ : AddCommMonoid M
inst✝⁸ : Module R M
N : Type u_3
inst✝⁷ : AddCommMonoid N
inst✝⁶ : Module R N
ι : Type u_4
inst✝⁵ : DecidableEq ι
x y z : M
S : Type u_5
inst✝⁴ : OrderedCommSemiring S
inst✝³ : Algebra S R
inst✝² : Module S M
inst✝¹ : SMulPosMono S R
inst✝ : IsScalarTower S R M
a : S
f : M →ₗ[R] N
h✝ : SameRay R x y
x✝ : ∃ r₁ r₂, 0 < r₁ ∧ 0 < r₂ ∧ r₁ • x = r₂ • y
r₁ r₂ : R
hr₁ : 0 < r₁
hr₂ : 0 < r₂
h : r₁ • x = r₂ • y
⊢ r₁ • f x = r₂ • f y
state_after: no goals
tactic: rw [← f.map_smul, ← f.map_smul, h]
Theorem: AffineBasis.basisOf_reindex
File: Mathlib/LinearAlgebra/AffineSpace/Basis.lean

Proof steps:
state_before: ι : Type u_1
ι' : Type u_2
k : Type u_3
V : Type u_4
P : Type u_5
inst✝³ : AddCommGroup V
inst✝² : AffineSpace V P
inst✝¹ : Ring k
inst✝ : Module k V
b : AffineBasis ι k P
s : Finset ι
i✝ j : ι
e : ι ≃ ι'
i : ι'
⊢ (b.reindex e).basisOf i = (b.basisOf (e.symm i)).reindex (e.subtypeEquiv ⋯)
state_after: case a
ι : Type u_1
ι' : Type u_2
k : Type u_3
V : Type u_4
P : Type u_5
inst✝³ : AddCommGroup V
inst✝² : AffineSpace V P
inst✝¹ : Ring k
inst✝ : Module k V
b : AffineBasis ι k P
s : Finset ι
i✝ j✝ : ι
e : ι ≃ ι'
i : ι'
j : { j // j ≠ i }
⊢ ((b.reindex e).basisOf i) j = ((b.basisOf (e.symm i)).reindex (e.subtypeEquiv ⋯)) j
tactic: ext j
state_before: case a
ι : Type u_1
ι' : Type u_2
k : Type u_3
V : Type u_4
P : Type u_5
inst✝³ : AddCommGroup V
inst✝² : AffineSpace V P
inst✝¹ : Ring k
inst✝ : Module k V
b : AffineBasis ι k P
s : Finset ι
i✝ j✝ : ι
e : ι ≃ ι'
i : ι'
j : { j // j ≠ i }
⊢ ((b.reindex e).basisOf i) j = ((b.basisOf (e.symm i)).reindex (e.subtypeEquiv ⋯)) j
state_after: no goals
tactic: simp
Theorem: edist_eq_coe_nnnorm'
File: Mathlib/Analysis/Normed/Group/Basic.lean

Proof steps:
state_before: 𝓕 : Type u_1
𝕜 : Type u_2
α : Type u_3
ι : Type u_4
κ : Type u_5
E : Type u_6
F : Type u_7
G : Type u_8
inst✝³ : SeminormedGroup E
inst✝² : SeminormedGroup F
inst✝¹ : SeminormedGroup G
s : Set E
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
inst✝ : FunLike 𝓕 E F
x : E
⊢ edist x 1 = ↑‖x‖₊
state_after: no goals
tactic: rw [edist_eq_coe_nnnorm_div, div_one]
Theorem: MeasureTheory.Measure.snd_prod
File: Mathlib/MeasureTheory/Constructions/Prod/Basic.lean

Proof steps:
state_before: α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
E : Type u_6
inst✝⁷ : MeasurableSpace α
inst✝⁶ : MeasurableSpace α'
inst✝⁵ : MeasurableSpace β
inst✝⁴ : MeasurableSpace β'
inst✝³ : MeasurableSpace γ
μ μ' : Measure α
ν ν' : Measure β
τ : Measure γ
inst✝² : NormedAddCommGroup E
inst✝¹ : SFinite ν
ρ : Measure (α × β)
inst✝ : IsProbabilityMeasure μ
⊢ (μ.prod ν).snd = ν
state_after: case h
α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
E : Type u_6
inst✝⁷ : MeasurableSpace α
inst✝⁶ : MeasurableSpace α'
inst✝⁵ : MeasurableSpace β
inst✝⁴ : MeasurableSpace β'
inst✝³ : MeasurableSpace γ
μ μ' : Measure α
ν ν' : Measure β
τ : Measure γ
inst✝² : NormedAddCommGroup E
inst✝¹ : SFinite ν
ρ : Measure (α × β)
inst✝ : IsProbabilityMeasure μ
s : Set β
hs : MeasurableSet s
⊢ (μ.prod ν).snd s = ν s
tactic: ext1 s hs
state_before: case h
α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
E : Type u_6
inst✝⁷ : MeasurableSpace α
inst✝⁶ : MeasurableSpace α'
inst✝⁵ : MeasurableSpace β
inst✝⁴ : MeasurableSpace β'
inst✝³ : MeasurableSpace γ
μ μ' : Measure α
ν ν' : Measure β
τ : Measure γ
inst✝² : NormedAddCommGroup E
inst✝¹ : SFinite ν
ρ : Measure (α × β)
inst✝ : IsProbabilityMeasure μ
s : Set β
hs : MeasurableSet s
⊢ (μ.prod ν).snd s = ν s
state_after: no goals
tactic: rw [snd_apply hs, ← univ_prod, prod_prod, measure_univ, one_mul]