tasksource/leandojo huggingface dataset:
Theorem: Filter.HasBasis.uniformEquicontinuous_iff_left
File: Mathlib/Topology/UniformSpace/Equicontinuity.lean

tactic: rw [uniformEquicontinuous_iff_uniformContinuous, UniformContinuous,
  hβ.tendsto_iff (UniformFun.hasBasis_uniformity ι α)]
state_before: ι : Type u_3
κ✝ : Type ?u.125171
X : Type ?u.125174
Y : Type ?u.125177
Z : Type ?u.125180
α : Type u_4
β : Type u_2
γ : Type ?u.125189
𝓕 : Type ?u.125192
inst✝⁵ : TopologicalSpace X
inst✝⁴ : TopologicalSpace Y
inst✝³ : TopologicalSpace Z
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
κ : Type u_1
p : κ → Prop
s : κ → Set (β × β)
F : ι → β → α
hβ : HasBasis (𝓤 β) p s
⊢ UniformEquicontinuous F ↔
    ∀ (U : Set (α × α)), U ∈ 𝓤 α → ∃ k, p k ∧ ∀ (x y : β), (x, y) ∈ s k → ∀ (i : ι), (F i x, F i y) ∈ U

tactic: simp only [Prod.forall, Function.comp_apply, mem_setOf_eq, exists_prop]
state_before: ι : Type u_3
κ✝ : Type ?u.125171
X : Type ?u.125174
Y : Type ?u.125177
Z : Type ?u.125180
α : Type u_4
β : Type u_2
γ : Type ?u.125189
𝓕 : Type ?u.125192
inst✝⁵ : TopologicalSpace X
inst✝⁴ : TopologicalSpace Y
inst✝³ : TopologicalSpace Z
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
κ : Type u_1
p : κ → Prop
s : κ → Set (β × β)
F : ι → β → α
hβ : HasBasis (𝓤 β) p s
⊢ (∀ (ib : Set (α × α)),
      ib ∈ 𝓤 α →
        ∃ ia,
          p ia ∧
            ∀ (x : β × β),
              x ∈ s ia →
                ((↑UniformFun.ofFun ∘ Function.swap F) x.fst, (↑UniformFun.ofFun ∘ Function.swap F) x.snd) ∈
                  UniformFun.gen ι α ib) ↔
    ∀ (U : Set (α × α)), U ∈ 𝓤 α → ∃ k, p k ∧ ∀ (x y : β), (x, y) ∈ s k → ∀ (i : ι), (F i x, F i y) ∈ U

tactic: rfl
state_before: ι : Type u_3
κ✝ : Type ?u.125171
X : Type ?u.125174
Y : Type ?u.125177
Z : Type ?u.125180
α : Type u_4
β : Type u_2
γ : Type ?u.125189
𝓕 : Type ?u.125192
inst✝⁵ : TopologicalSpace X
inst✝⁴ : TopologicalSpace Y
inst✝³ : TopologicalSpace Z
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
κ : Type u_1
p : κ → Prop
s : κ → Set (β × β)
F : ι → β → α
hβ : HasBasis (𝓤 β) p s
⊢ (∀ (ib : Set (α × α)),
      ib ∈ 𝓤 α →
        ∃ ia,
          p ia ∧
            ∀ (a b : β),
              (a, b) ∈ s ia →
                (↑UniformFun.ofFun (Function.swap F a), ↑UniformFun.ofFun (Function.swap F b)) ∈
                  UniformFun.gen ι α ib) ↔
    ∀ (U : Set (α × α)), U ∈ 𝓤 α → ∃ k, p k ∧ ∀ (x y : β), (x, y) ∈ s k → ∀ (i : ι), (F i x, F i y) ∈ U
Theorem: Finset.weightedVSub_vadd_affineCombination
File: Mathlib/LinearAlgebra/AffineSpace/Combination.lean

tactic: rw [← vadd_eq_add, AffineMap.map_vadd, affineCombination_linear]
state_before: k : Type u_4
V : Type u_2
P : Type u_1
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
ι : Type u_3
s : Finset ι
ι₂ : Type ?u.258239
s₂ : Finset ι₂
w₁ w₂ : ι → k
p : ι → P
⊢ ↑(weightedVSub s p) w₁ +ᵥ ↑(affineCombination k s p) w₂ = ↑(affineCombination k s p) (w₁ + w₂)
Theorem: Fin.succAbove_above
File: Mathlib/Data/Fin/Basic.lean

tactic: simp [succAbove, h.not_lt]
state_before: n m : ℕ
p : Fin (n + 1)
i : Fin n
h : p ≤ ↑castSucc i
⊢ ↑(succAbove p) i = succ i
Theorem: Subgroup.commutator_eq_bot_iff_le_centralizer
File: Mathlib/GroupTheory/Commutator.lean

tactic: rw [eq_bot_iff, commutator_le]
state_before: G : Type u_1
G' : Type ?u.55266
F : Type ?u.55269
inst✝² : Group G
inst✝¹ : Group G'
inst✝ : MonoidHomClass F G G'
f : F
g₁ g₂ g₃ g : G
H₁ H₂ H₃ K₁ K₂ : Subgroup G
⊢ ⁅H₁, H₂⁆ = ⊥ ↔ H₁ ≤ centralizer H₂

tactic: refine'
  forall_congr' fun p => forall_congr' fun _hp => forall_congr' fun q => forall_congr' fun hq => _
state_before: G : Type u_1
G' : Type ?u.55266
F : Type ?u.55269
inst✝² : Group G
inst✝¹ : Group G'
inst✝ : MonoidHomClass F G G'
f : F
g₁ g₂ g₃ g : G
H₁ H₂ H₃ K₁ K₂ : Subgroup G
⊢ (∀ (g₁ : G), g₁ ∈ H₁ → ∀ (g₂ : G), g₂ ∈ H₂ → ⁅g₁, g₂⁆ ∈ ⊥) ↔ H₁ ≤ centralizer H₂

tactic: rw [mem_bot, commutatorElement_eq_one_iff_mul_comm, eq_comm]
state_before: G : Type u_1
G' : Type ?u.55266
F : Type ?u.55269
inst✝² : Group G
inst✝¹ : Group G'
inst✝ : MonoidHomClass F G G'
f : F
g₁ g₂ g₃ g : G
H₁ H₂ H₃ K₁ K₂ : Subgroup G
p : G
_hp : p ∈ H₁
q : G
hq : q ∈ H₂
⊢ ⁅p, q⁆ ∈ ⊥ ↔ q * p = p * q
Theorem: CategoryTheory.Limits.π_comp_cokernelIsoOfEq_hom
File: Mathlib/CategoryTheory/Limits/Shapes/Kernels.lean

tactic: cases h
state_before: C : Type u
inst✝⁴ : Category C
inst✝³ : HasZeroMorphisms C
X Y : C
f✝ : X ⟶ Y
inst✝² : HasCokernel f✝
f g : X ⟶ Y
inst✝¹ : HasCokernel f
inst✝ : HasCokernel g
h : f = g
⊢ cokernel.π f ≫ (cokernelIsoOfEq h).hom = cokernel.π g

tactic: simp
state_before: case refl
C : Type u
inst✝⁴ : Category C
inst✝³ : HasZeroMorphisms C
X Y : C
f✝ : X ⟶ Y
inst✝² : HasCokernel f✝
f : X ⟶ Y
inst✝¹ inst✝ : HasCokernel f
⊢ cokernel.π f ≫ (cokernelIsoOfEq (_ : f = f)).hom = cokernel.π f
Theorem: ENNReal.add_thirds
File: Mathlib/Data/Real/ENNReal.lean

tactic: rw [div_eq_mul_inv, ← mul_add, ← mul_add, inv_three_add_inv_three, mul_one]
state_before: α : Type ?u.317751
β : Type ?u.317754
a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
a : ℝ≥0∞
⊢ a / 3 + a / 3 + a / 3 = a
Theorem: Ordinal.range_enumOrd
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: rw [range_eq_iff]
state_before: S : Set Ordinal
hS : Unbounded (fun x x_1 => x < x_1) S
⊢ range (enumOrd S) = S

tactic: exact ⟨enumOrd_mem hS, enumOrd_surjective hS⟩
state_before: S : Set Ordinal
hS : Unbounded (fun x x_1 => x < x_1) S
⊢ (∀ (a : Ordinal), enumOrd S a ∈ S) ∧ ∀ (b : Ordinal), b ∈ S → ∃ a, enumOrd S a = b
Theorem: Finmap.union_empty
File: Mathlib/Data/Finmap.lean

tactic: rw [← empty_toFinmap]
state_before: α : Type u
β : α → Type v
inst✝ : DecidableEq α
s₁✝ : Finmap β
s₁ : AList β
⊢ ⟦s₁⟧ ∪ ∅ = ⟦s₁⟧

tactic: simp [-empty_toFinmap, AList.toFinmap_eq, union_toFinmap, AList.union_assoc]
state_before: α : Type u
β : α → Type v
inst✝ : DecidableEq α
s₁✝ : Finmap β
s₁ : AList β
⊢ ⟦s₁⟧ ∪ ⟦∅⟧ = ⟦s₁⟧
Theorem: MeasureTheory.sub_ae_eq_zero
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: refine' ⟨fun h => h.mono fun x hx => _, fun h => h.mono fun x hx => _⟩
state_before: α : Type u_2
β✝ : Type ?u.585371
γ : Type ?u.585374
δ : Type ?u.585377
ι : Type ?u.585380
R : Type ?u.585383
R' : Type ?u.585386
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β✝
inst✝¹ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
β : Type u_1
inst✝ : AddGroup β
f g : α → β
⊢ f - g =ᶠ[ae μ] 0 ↔ f =ᶠ[ae μ] g

tactic: rwa [Pi.sub_apply, Pi.zero_apply, sub_eq_zero] at hx
state_before: case refine'_1
α : Type u_2
β✝ : Type ?u.585371
γ : Type ?u.585374
δ : Type ?u.585377
ι : Type ?u.585380
R : Type ?u.585383
R' : Type ?u.585386
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β✝
inst✝¹ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
β : Type u_1
inst✝ : AddGroup β
f g : α → β
h : f - g =ᶠ[ae μ] 0
x : α
hx : (f - g) x = OfNat.ofNat 0 x
⊢ f x = g x

tactic: rwa [Pi.sub_apply, Pi.zero_apply, sub_eq_zero]
state_before: case refine'_2
α : Type u_2
β✝ : Type ?u.585371
γ : Type ?u.585374
δ : Type ?u.585377
ι : Type ?u.585380
R : Type ?u.585383
R' : Type ?u.585386
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β✝
inst✝¹ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
β : Type u_1
inst✝ : AddGroup β
f g : α → β
h : f =ᶠ[ae μ] g
x : α
hx : f x = g x
⊢ (f - g) x = OfNat.ofNat 0 x
Theorem: Matrix.invOf_mul_self_assoc
File: Mathlib/LinearAlgebra/Matrix/NonsingularInverse.lean

tactic: rw [← Matrix.mul_assoc, Matrix.invOf_mul_self, Matrix.one_mul]
state_before: l : Type ?u.5121
m : Type u
n : Type u'
α : Type v
inst✝³ : Fintype n
inst✝² : DecidableEq n
inst✝¹ : CommRing α
A : Matrix n n α
B : Matrix n m α
inst✝ : Invertible A
⊢ ⅟A ⬝ (A ⬝ B) = B
Theorem: Matrix.StdBasisMatrix.trace_eq
File: Mathlib/Data/Matrix/Basis.lean

tactic: simp [trace, -diag_apply]
state_before: l : Type ?u.29224
m : Type ?u.29227
n : Type u_2
R : Type ?u.29233
α : Type u_1
inst✝⁴ : DecidableEq l
inst✝³ : DecidableEq m
inst✝² : DecidableEq n
inst✝¹ : Semiring α
i j : n
c : α
i' j' : n
inst✝ : Fintype n
⊢ trace (stdBasisMatrix i i c) = c
Theorem: Equiv.Set.sumCompl_symm_apply
File: Mathlib/Logic/Equiv/Set.lean

tactic: cases' x with x hx
state_before: α✝ : Sort u
β : Sort v
γ : Sort w
α : Type u_1
s : Set α
inst✝ : DecidablePred fun x => x ∈ s
x : ↑s
⊢ ↑(Set.sumCompl s).symm ↑x = Sum.inl x

tactic: exact Set.sumCompl_symm_apply_of_mem hx
state_before: case mk
α✝ : Sort u
β : Sort v
γ : Sort w
α : Type u_1
s : Set α
inst✝ : DecidablePred fun x => x ∈ s
x : α
hx : x ∈ s
⊢ ↑(Set.sumCompl s).symm ↑{ val := x, property := hx } = Sum.inl { val := x, property := hx }
Theorem: CategoryTheory.Limits.WalkingParallelPairHom.assoc
File: Mathlib/CategoryTheory/Limits/Shapes/Equalizers.lean

tactic: cases f <;> cases g <;> cases h <;> rfl
state_before: X Y Z W : WalkingParallelPair
f : WalkingParallelPairHom X Y
g : WalkingParallelPairHom Y Z
h : WalkingParallelPairHom Z W
⊢ comp (comp f g) h = comp f (comp g h)
Theorem: EuclideanGeometry.collinear_iff_eq_or_eq_or_sin_eq_zero
File: Mathlib/Geometry/Euclidean/Angle/Unoriented/Affine.lean

tactic: rw [sin_eq_zero_iff_angle_eq_zero_or_angle_eq_pi,
  collinear_iff_eq_or_eq_or_angle_eq_zero_or_angle_eq_pi]
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
⊢ Collinear ℝ {p₁, p₂, p₃} ↔ p₁ = p₂ ∨ p₃ = p₂ ∨ sin (∠ p₁ p₂ p₃) = 0
Theorem: Finset.sum_smul_vsub_eq_weightedVSubOfPoint_sub
File: Mathlib/LinearAlgebra/AffineSpace/Combination.lean

tactic: simp_rw [weightedVSubOfPoint_apply, ← sum_sub_distrib, ← smul_sub, vsub_sub_vsub_cancel_right]
state_before: k : Type u_3
V : Type u_1
P : Type u_4
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
ι : Type u_2
s : Finset ι
ι₂ : Type ?u.94059
s₂ : Finset ι₂
w : ι → k
p₁ p₂ : ι → P
b : P
⊢ ∑ i in s, w i • (p₁ i -ᵥ p₂ i) = ↑(weightedVSubOfPoint s p₁ b) w - ↑(weightedVSubOfPoint s p₂ b) w
Theorem: PythagoreanTriple.mul_isClassified
File: Mathlib/NumberTheory/PythagoreanTriples.lean

tactic: obtain ⟨l, m, n, ⟨⟨rfl, rfl⟩ | ⟨rfl, rfl⟩, co⟩⟩ := hc
state_before: x y z : ℤ
h : PythagoreanTriple x y z
k : ℤ
hc : IsClassified h
⊢ IsClassified (_ : PythagoreanTriple (k * x) (k * y) (k * z))

tactic: use k * l, m, n
state_before: case intro.intro.intro.intro.inl.intro
z k l m n : ℤ
co : Int.gcd m n = 1
h : PythagoreanTriple (l * (m ^ 2 - n ^ 2)) (l * (2 * m * n)) z
⊢ IsClassified (_ : PythagoreanTriple (k * (l * (m ^ 2 - n ^ 2))) (k * (l * (2 * m * n))) (k * z))

tactic: apply And.intro _ co
state_before: case intro.intro.intro.intro.inl.intro
z k l m n : ℤ
co : Int.gcd m n = 1
h : PythagoreanTriple (l * (m ^ 2 - n ^ 2)) (l * (2 * m * n)) z
⊢ (k * (l * (m ^ 2 - n ^ 2)) = k * l * (m ^ 2 - n ^ 2) ∧ k * (l * (2 * m * n)) = k * l * (2 * m * n) ∨
      k * (l * (m ^ 2 - n ^ 2)) = k * l * (2 * m * n) ∧ k * (l * (2 * m * n)) = k * l * (m ^ 2 - n ^ 2)) ∧
    Int.gcd m n = 1

tactic: left
state_before: z k l m n : ℤ
co : Int.gcd m n = 1
h : PythagoreanTriple (l * (m ^ 2 - n ^ 2)) (l * (2 * m * n)) z
⊢ k * (l * (m ^ 2 - n ^ 2)) = k * l * (m ^ 2 - n ^ 2) ∧ k * (l * (2 * m * n)) = k * l * (2 * m * n) ∨
    k * (l * (m ^ 2 - n ^ 2)) = k * l * (2 * m * n) ∧ k * (l * (2 * m * n)) = k * l * (m ^ 2 - n ^ 2)

tactic: constructor <;> ring
state_before: case h
z k l m n : ℤ
co : Int.gcd m n = 1
h : PythagoreanTriple (l * (m ^ 2 - n ^ 2)) (l * (2 * m * n)) z
⊢ k * (l * (m ^ 2 - n ^ 2)) = k * l * (m ^ 2 - n ^ 2) ∧ k * (l * (2 * m * n)) = k * l * (2 * m * n)

tactic: use k * l, m, n
state_before: case intro.intro.intro.intro.inr.intro
z k l m n : ℤ
co : Int.gcd m n = 1
h : PythagoreanTriple (l * (2 * m * n)) (l * (m ^ 2 - n ^ 2)) z
⊢ IsClassified (_ : PythagoreanTriple (k * (l * (2 * m * n))) (k * (l * (m ^ 2 - n ^ 2))) (k * z))

tactic: apply And.intro _ co
state_before: case intro.intro.intro.intro.inr.intro
z k l m n : ℤ
co : Int.gcd m n = 1
h : PythagoreanTriple (l * (2 * m * n)) (l * (m ^ 2 - n ^ 2)) z
⊢ (k * (l * (2 * m * n)) = k * l * (m ^ 2 - n ^ 2) ∧ k * (l * (m ^ 2 - n ^ 2)) = k * l * (2 * m * n) ∨
      k * (l * (2 * m * n)) = k * l * (2 * m * n) ∧ k * (l * (m ^ 2 - n ^ 2)) = k * l * (m ^ 2 - n ^ 2)) ∧
    Int.gcd m n = 1

tactic: right
state_before: z k l m n : ℤ
co : Int.gcd m n = 1
h : PythagoreanTriple (l * (2 * m * n)) (l * (m ^ 2 - n ^ 2)) z
⊢ k * (l * (2 * m * n)) = k * l * (m ^ 2 - n ^ 2) ∧ k * (l * (m ^ 2 - n ^ 2)) = k * l * (2 * m * n) ∨
    k * (l * (2 * m * n)) = k * l * (2 * m * n) ∧ k * (l * (m ^ 2 - n ^ 2)) = k * l * (m ^ 2 - n ^ 2)

tactic: constructor <;> ring
state_before: case h
z k l m n : ℤ
co : Int.gcd m n = 1
h : PythagoreanTriple (l * (2 * m * n)) (l * (m ^ 2 - n ^ 2)) z
⊢ k * (l * (2 * m * n)) = k * l * (2 * m * n) ∧ k * (l * (m ^ 2 - n ^ 2)) = k * l * (m ^ 2 - n ^ 2)
Theorem: Multiset.cons_sigma
File: Mathlib/Data/Multiset/Bind.lean

tactic: simp [Multiset.sigma]
state_before: α : Type u_1
β : Type ?u.69645
γ : Type ?u.69648
δ : Type ?u.69651
σ : α → Type u_2
a : α
s : Multiset α
t : (a : α) → Multiset (σ a)
⊢ Multiset.sigma (a ::ₘ s) t = map (Sigma.mk a) (t a) + Multiset.sigma s t
Theorem: DFA.evalFrom_append_singleton
File: Mathlib/Computability/DFA.lean

tactic: simp only [evalFrom, List.foldl_append, List.foldl_cons, List.foldl_nil]
state_before: α : Type u
σ : Type v
M : DFA α σ
s : σ
x : List α
a : α
⊢ evalFrom M s (x ++ [a]) = step M (evalFrom M s x) a
Theorem: Rat.cast_sub_of_ne_zero
File: Mathlib/Data/Rat/Cast.lean

tactic: have : ((-n).den : α) ≠ 0 := by cases n ; exact n0
state_before: F : Type ?u.21767
ι : Type ?u.21770
α : Type u_1
β : Type ?u.21776
inst✝ : DivisionRing α
m n : ℚ
m0 : ↑m.den ≠ 0
n0 : ↑n.den ≠ 0
⊢ ↑(m - n) = ↑m - ↑n

tactic: simp [sub_eq_add_neg, cast_add_of_ne_zero m0 this]
state_before: F : Type ?u.21767
ι : Type ?u.21770
α : Type u_1
β : Type ?u.21776
inst✝ : DivisionRing α
m n : ℚ
m0 : ↑m.den ≠ 0
n0 : ↑n.den ≠ 0
this : ↑(-n).den ≠ 0
⊢ ↑(m - n) = ↑m - ↑n

tactic: cases n
state_before: F : Type ?u.21767
ι : Type ?u.21770
α : Type u_1
β : Type ?u.21776
inst✝ : DivisionRing α
m n : ℚ
m0 : ↑m.den ≠ 0
n0 : ↑n.den ≠ 0
⊢ ↑(-n).den ≠ 0

tactic: exact n0
state_before: case mk'
F : Type ?u.21767
ι : Type ?u.21770
α : Type u_1
β : Type ?u.21776
inst✝ : DivisionRing α
m : ℚ
m0 : ↑m.den ≠ 0
num✝ : ℤ
den✝ : ℕ
den_nz✝ : den✝ ≠ 0
reduced✝ : Nat.coprime (Int.natAbs num✝) den✝
n0 : ↑(mk' num✝ den✝).den ≠ 0
⊢ ↑(-mk' num✝ den✝).den ≠ 0
Theorem: piiUnionInter_singleton_left
File: Mathlib/MeasureTheory/PiSystem.lean

tactic: ext1 s'
state_before: α : Type u_1
ι : Type u_2
s : ι → Set α
S : Set ι
⊢ piiUnionInter (fun i => {s i}) S = {s' | ∃ t x, s' = ⋂ (i : ι) (_ : i ∈ t), s i}

tactic: simp_rw [piiUnionInter, Set.mem_singleton_iff, exists_prop, Set.mem_setOf_eq]
state_before: case h
α : Type u_1
ι : Type u_2
s : ι → Set α
S : Set ι
s' : Set α
⊢ s' ∈ piiUnionInter (fun i => {s i}) S ↔ s' ∈ {s' | ∃ t x, s' = ⋂ (i : ι) (_ : i ∈ t), s i}

tactic: refine' ⟨fun h => _, fun ⟨t, htS, h_eq⟩ => ⟨t, htS, s, fun _ _ => rfl, h_eq⟩⟩
state_before: case h
α : Type u_1
ι : Type u_2
s : ι → Set α
S : Set ι
s' : Set α
⊢ (∃ t, ↑t ⊆ S ∧ ∃ f, (∀ (x : ι), x ∈ t → f x = s x) ∧ s' = ⋂ (x : ι) (_ : x ∈ t), f x) ↔
    ∃ t, ↑t ⊆ S ∧ s' = ⋂ (i : ι) (_ : i ∈ t), s i

tactic: obtain ⟨t, htS, f, hft_eq, rfl⟩ := h
state_before: case h
α : Type u_1
ι : Type u_2
s : ι → Set α
S : Set ι
s' : Set α
h : ∃ t, ↑t ⊆ S ∧ ∃ f, (∀ (x : ι), x ∈ t → f x = s x) ∧ s' = ⋂ (x : ι) (_ : x ∈ t), f x
⊢ ∃ t, ↑t ⊆ S ∧ s' = ⋂ (i : ι) (_ : i ∈ t), s i

tactic: refine' ⟨t, htS, _⟩
state_before: case h.intro.intro.intro.intro
α : Type u_1
ι : Type u_2
s : ι → Set α
S : Set ι
t : Finset ι
htS : ↑t ⊆ S
f : ι → Set α
hft_eq : ∀ (x : ι), x ∈ t → f x = s x
⊢ ∃ t_1, ↑t_1 ⊆ S ∧ (⋂ (x : ι) (_ : x ∈ t), f x) = ⋂ (i : ι) (_ : i ∈ t_1), s i

tactic: congr! 3
state_before: case h.intro.intro.intro.intro
α : Type u_1
ι : Type u_2
s : ι → Set α
S : Set ι
t : Finset ι
htS : ↑t ⊆ S
f : ι → Set α
hft_eq : ∀ (x : ι), x ∈ t → f x = s x
⊢ (⋂ (x : ι) (_ : x ∈ t), f x) = ⋂ (i : ι) (_ : i ∈ t), s i

tactic: apply hft_eq
state_before: case h.intro.intro.intro.intro.h.e'_3.h.f
α : Type u_1
ι : Type u_2
s : ι → Set α
S : Set ι
t : Finset ι
htS : ↑t ⊆ S
f : ι → Set α
hft_eq : ∀ (x : ι), x ∈ t → f x = s x
x✝¹ : ι
x✝ : x✝¹ ∈ t
⊢ f x✝¹ = s x✝¹

tactic: assumption
state_before: case h.intro.intro.intro.intro.h.e'_3.h.f.a
α : Type u_1
ι : Type u_2
s : ι → Set α
S : Set ι
t : Finset ι
htS : ↑t ⊆ S
f : ι → Set α
hft_eq : ∀ (x : ι), x ∈ t → f x = s x
x✝¹ : ι
x✝ : x✝¹ ∈ t
⊢ x✝¹ ∈ t
Theorem: Basis.mk_coord_apply_eq
File: Mathlib/LinearAlgebra/Basis.lean

tactic: simp [hli.repr_eq_single i]
state_before: ι : Type u_3
ι' : Type ?u.836112
R : Type u_1
R₂ : Type ?u.836118
K : Type ?u.836121
M : Type u_2
M' : Type ?u.836127
M'' : Type ?u.836130
V : Type u
V' : Type ?u.836135
v : ι → M
inst✝⁸ : Ring R
inst✝⁷ : CommRing R₂
inst✝⁶ : AddCommGroup M
inst✝⁵ : AddCommGroup M'
inst✝⁴ : AddCommGroup M''
inst✝³ : Module R M
inst✝² : Module R₂ M
inst✝¹ : Module R M'
inst✝ : Module R M''
c d : R
x y : M
b : Basis ι R M
hli : LinearIndependent R v
hsp : ⊤ ≤ span R (Set.range v)
i : ι
⊢ ↑(↑(LinearIndependent.repr hli) { val := v i, property := (_ : v i ∈ ↑(span R (Set.range v))) }) i = 1
Theorem: tsum_eq_add_tsum_ite'
File: Mathlib/Topology/Algebra/InfiniteSum/Basic.lean

tactic: split_ifs with h <;> simp [update_apply, h]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.347788
δ : Type ?u.347791
inst✝³ : AddCommMonoid α
inst✝² : TopologicalSpace α
inst✝¹ : T2Space α
f✝ g : β → α
a a₁ a₂ : α
inst✝ : ContinuousAdd α
f : β → α
b : β
hf : Summable (update f b 0)
n : β
⊢ f n = (if n = b then f n else 0) + update f b 0 n

tactic: congr
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.347788
δ : Type ?u.347791
inst✝³ : AddCommMonoid α
inst✝² : TopologicalSpace α
inst✝¹ : T2Space α
f✝ g : β → α
a a₁ a₂ : α
inst✝ : ContinuousAdd α
f : β → α
b : β
hf : Summable (update f b 0)
⊢ ((∑' (x : β), if x = b then f x else 0) + ∑' (x : β), update f b 0 x) =
    (if b = b then f b else 0) + ∑' (x : β), update f b 0 x

tactic: exact tsum_eq_single b fun b' hb' => if_neg hb'
state_before: case e_a
α : Type u_1
β : Type u_2
γ : Type ?u.347788
δ : Type ?u.347791
inst✝³ : AddCommMonoid α
inst✝² : TopologicalSpace α
inst✝¹ : T2Space α
f✝ g : β → α
a a₁ a₂ : α
inst✝ : ContinuousAdd α
f : β → α
b : β
hf : Summable (update f b 0)
⊢ (∑' (x : β), if x = b then f x else 0) = if b = b then f b else 0

tactic: simp only [update, eq_self_iff_true, if_true, eq_rec_constant, dite_eq_ite]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.347788
δ : Type ?u.347791
inst✝³ : AddCommMonoid α
inst✝² : TopologicalSpace α
inst✝¹ : T2Space α
f✝ g : β → α
a a₁ a₂ : α
inst✝ : ContinuousAdd α
f : β → α
b : β
hf : Summable (update f b 0)
⊢ ((if b = b then f b else 0) + ∑' (x : β), update f b 0 x) = f b + ∑' (x : β), if x = b then 0 else f x
Theorem: List.Perm.countp_eq
File: Mathlib/Data/List/Perm.lean

tactic: rw [countp_eq_length_filter, countp_eq_length_filter]
state_before: α : Type uu
β : Type vv
l₁✝ l₂✝ : List α
p : α → Bool
l₁ l₂ : List α
s : l₁ ~ l₂
⊢ countp p l₁ = countp p l₂

tactic: exact (s.filter _).length_eq
state_before: α : Type uu
β : Type vv
l₁✝ l₂✝ : List α
p : α → Bool
l₁ l₂ : List α
s : l₁ ~ l₂
⊢ length (List.filter p l₁) = length (List.filter p l₂)
Theorem: MeasureTheory.AEEqFun.le_sup_left
File: Mathlib/MeasureTheory/Function/AEEqFun.lean

tactic: rw [← coeFn_le]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.453529
δ : Type ?u.453532
inst✝⁵ : MeasurableSpace α
μ ν : Measure α
inst✝⁴ : TopologicalSpace β
inst✝³ : TopologicalSpace γ
inst✝² : TopologicalSpace δ
inst✝¹ : SemilatticeSup β
inst✝ : ContinuousSup β
f g : α →ₘ[μ] β
⊢ f ≤ f ⊔ g

tactic: filter_upwards [coeFn_sup f g] with _ ha
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.453529
δ : Type ?u.453532
inst✝⁵ : MeasurableSpace α
μ ν : Measure α
inst✝⁴ : TopologicalSpace β
inst✝³ : TopologicalSpace γ
inst✝² : TopologicalSpace δ
inst✝¹ : SemilatticeSup β
inst✝ : ContinuousSup β
f g : α →ₘ[μ] β
⊢ ↑f ≤ᵐ[μ] ↑(f ⊔ g)

tactic: rw [ha]
state_before: case h
α : Type u_1
β : Type u_2
γ : Type ?u.453529
δ : Type ?u.453532
inst✝⁵ : MeasurableSpace α
μ ν : Measure α
inst✝⁴ : TopologicalSpace β
inst✝³ : TopologicalSpace γ
inst✝² : TopologicalSpace δ
inst✝¹ : SemilatticeSup β
inst✝ : ContinuousSup β
f g : α →ₘ[μ] β
a✝ : α
ha : ↑(f ⊔ g) a✝ = ↑f a✝ ⊔ ↑g a✝
⊢ ↑f a✝ ≤ ↑(f ⊔ g) a✝

tactic: exact le_sup_left
state_before: case h
α : Type u_1
β : Type u_2
γ : Type ?u.453529
δ : Type ?u.453532
inst✝⁵ : MeasurableSpace α
μ ν : Measure α
inst✝⁴ : TopologicalSpace β
inst✝³ : TopologicalSpace γ
inst✝² : TopologicalSpace δ
inst✝¹ : SemilatticeSup β
inst✝ : ContinuousSup β
f g : α →ₘ[μ] β
a✝ : α
ha : ↑(f ⊔ g) a✝ = ↑f a✝ ⊔ ↑g a✝
⊢ ↑f a✝ ≤ ↑f a✝ ⊔ ↑g a✝
Theorem: kstar_eq_self
File: Mathlib/Algebra/Order/Kleene.lean

tactic: rw [← h, kstar_mul_kstar]
state_before: α : Type u_1
β : Type ?u.48091
ι : Type ?u.48094
π : ι → Type ?u.48099
inst✝ : KleeneAlgebra α
a b c : α
h : a∗ = a
⊢ a * a = a
Theorem: LinearMap.range_comp_of_range_eq_top
File: Mathlib/LinearAlgebra/Basic.lean

tactic: rw [range_comp, hf, Submodule.map_top]
state_before: R : Type u_1
R₁ : Type ?u.1578452
R₂ : Type u_2
R₃ : Type u_3
R₄ : Type ?u.1578461
S : Type ?u.1578464
K : Type ?u.1578467
K₂ : Type ?u.1578470
M : Type u_4
M' : Type ?u.1578476
M₁ : Type ?u.1578479
M₂ : Type u_5
M₃ : Type u_6
M₄ : Type ?u.1578488
N : Type ?u.1578491
N₂ : Type ?u.1578494
ι : Type ?u.1578497
V : Type ?u.1578500
V₂ : Type ?u.1578503
inst✝¹² : Semiring R
inst✝¹¹ : Semiring R₂
inst✝¹⁰ : Semiring R₃
inst✝⁹ : AddCommMonoid M
inst✝⁸ : AddCommMonoid M₂
inst✝⁷ : AddCommMonoid M₃
inst✝⁶ : Module R M
inst✝⁵ : Module R₂ M₂
inst✝⁴ : Module R₃ M₃
τ₁₂ : R →+* R₂
τ₂₃ : R₂ →+* R₃
τ₁₃ : R →+* R₃
inst✝³ : RingHomCompTriple τ₁₂ τ₂₃ τ₁₃
inst✝² : RingHomSurjective τ₁₂
inst✝¹ : RingHomSurjective τ₂₃
inst✝ : RingHomSurjective τ₁₃
f : M →ₛₗ[τ₁₂] M₂
g : M₂ →ₛₗ[τ₂₃] M₃
hf : range f = ⊤
⊢ range (comp g f) = range g
Theorem: Metric.Bounded.left_of_prod
File: Mathlib/Topology/MetricSpace/Lipschitz.lean

tactic: simpa only [fst_image_prod s ht] using (@LipschitzWith.prod_fst α β _ _).bounded_image h
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
s : Set α
t : Set β
h : Bounded (s ×ˢ t)
ht : Set.Nonempty t
⊢ Bounded s
Theorem: Std.AssocList.toList_eq_toListTR
File: Std/Data/AssocList.lean

tactic: funext α β as
state_before: ⊢ @toList = @toListTR

tactic: simp [toListTR]
state_before: case h.h.h
α : Type u_2
β : Type u_1
as : AssocList α β
⊢ toList as = toListTR as

tactic: exact .symm <| (Array.foldl_data_eq_map (toList as) _ id).trans (List.map_id _)
state_before: case h.h.h
α : Type u_2
β : Type u_1
as : AssocList α β
⊢ toList as = (List.foldl (fun d x => Array.push d (x.fst, x.snd)) #[] (toList as)).data
Theorem: List.enum_append
File: Mathlib/Data/List/Basic.lean

tactic: simp [enum, enumFrom_append]
state_before: ι : Type ?u.448772
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ xs ys : List α
⊢ enum (xs ++ ys) = enum xs ++ enumFrom (length xs) ys
Theorem: LeftOrdContinuous.map_sSup
File: Mathlib/Order/OrdContinuous.lean

tactic: rw [hf.map_sSup', sSup_image]
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝¹ : CompleteLattice α
inst✝ : CompleteLattice β
f : α → β
hf : LeftOrdContinuous f
s : Set α
⊢ f (sSup s) = ⨆ (x : α) (_ : x ∈ s), f x