tasksource/leandojo huggingface dataset:
Theorem: ContinuousMap.mem_compactConvergence_nhd_filter
File: Mathlib/Topology/UniformSpace/CompactConvergence.lean

tactic: constructor
state_before: α : Type u₁
β : Type u₂
inst✝¹ : TopologicalSpace α
inst✝ : UniformSpace β
K : Set α
V : Set (β × β)
f : C(α, β)
Y : Set C(α, β)
⊢ Y ∈ FilterBasis.filter (compactConvergenceFilterBasis f) ↔ ∃ K V _hK _hV, compactConvNhd K V f ⊆ Y

tactic: rintro ⟨X, ⟨⟨K, V⟩, ⟨hK, hV⟩, rfl⟩, hY⟩
state_before: case mp
α : Type u₁
β : Type u₂
inst✝¹ : TopologicalSpace α
inst✝ : UniformSpace β
K : Set α
V : Set (β × β)
f : C(α, β)
Y : Set C(α, β)
⊢ Y ∈ FilterBasis.filter (compactConvergenceFilterBasis f) → ∃ K V _hK _hV, compactConvNhd K V f ⊆ Y

tactic: exact ⟨K, V, hK, hV, hY⟩
state_before: case mp.intro.intro.intro.mk.intro.intro
α : Type u₁
β : Type u₂
inst✝¹ : TopologicalSpace α
inst✝ : UniformSpace β
K✝ : Set α
V✝ : Set (β × β)
f : C(α, β)
Y : Set C(α, β)
K : Set α
V : Set (β × β)
hK : IsCompact (K, V).fst
hV : (K, V).snd ∈ 𝓤 β
hY : (fun KV => compactConvNhd KV.fst KV.snd f) (K, V) ⊆ Y
⊢ ∃ K V _hK _hV, compactConvNhd K V f ⊆ Y

tactic: rintro ⟨K, V, hK, hV, hY⟩
state_before: case mpr
α : Type u₁
β : Type u₂
inst✝¹ : TopologicalSpace α
inst✝ : UniformSpace β
K : Set α
V : Set (β × β)
f : C(α, β)
Y : Set C(α, β)
⊢ (∃ K V _hK _hV, compactConvNhd K V f ⊆ Y) → Y ∈ FilterBasis.filter (compactConvergenceFilterBasis f)

tactic: exact ⟨compactConvNhd K V f, ⟨⟨K, V⟩, ⟨hK, hV⟩, rfl⟩, hY⟩
state_before: case mpr.intro.intro.intro.intro
α : Type u₁
β : Type u₂
inst✝¹ : TopologicalSpace α
inst✝ : UniformSpace β
K✝ : Set α
V✝ : Set (β × β)
f : C(α, β)
Y : Set C(α, β)
K : Set α
V : Set (β × β)
hK : IsCompact K
hV : V ∈ 𝓤 β
hY : compactConvNhd K V f ⊆ Y
⊢ Y ∈ FilterBasis.filter (compactConvergenceFilterBasis f)
Theorem: lowerClosure_sUnion
File: Mathlib/Order/UpperLower/Basic.lean

tactic: simp_rw [sUnion_eq_biUnion, lowerClosure_iUnion]
state_before: α : Type u_1
β : Type ?u.163100
γ : Type ?u.163103
ι : Sort ?u.163106
κ : ι → Sort ?u.163111
inst✝¹ : Preorder α
inst✝ : Preorder β
s t : Set α
x : α
S : Set (Set α)
⊢ lowerClosure (⋃₀ S) = ⨆ (s : Set α) (_ : s ∈ S), lowerClosure s
Theorem: Finset.filter_biUnion
File: Mathlib/Data/Finset/Basic.lean

tactic: ext b
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.520534
inst✝¹ : DecidableEq β
s✝ s₁ s₂ : Finset α
t t₁ t₂ : α → Finset β
s : Finset α
f : α → Finset β
p : β → Prop
inst✝ : DecidablePred p
⊢ filter p (Finset.biUnion s f) = Finset.biUnion s fun a => filter p (f a)

tactic: simp only [mem_biUnion, exists_prop, mem_filter]
state_before: case a
α : Type u_1
β : Type u_2
γ : Type ?u.520534
inst✝¹ : DecidableEq β
s✝ s₁ s₂ : Finset α
t t₁ t₂ : α → Finset β
s : Finset α
f : α → Finset β
p : β → Prop
inst✝ : DecidablePred p
b : β
⊢ b ∈ filter p (Finset.biUnion s f) ↔ b ∈ Finset.biUnion s fun a => filter p (f a)

tactic: constructor
state_before: case a
α : Type u_1
β : Type u_2
γ : Type ?u.520534
inst✝¹ : DecidableEq β
s✝ s₁ s₂ : Finset α
t t₁ t₂ : α → Finset β
s : Finset α
f : α → Finset β
p : β → Prop
inst✝ : DecidablePred p
b : β
⊢ (∃ a, a ∈ s ∧ b ∈ f a) ∧ p b ↔ ∃ a, a ∈ s ∧ b ∈ f a ∧ p b

tactic: rintro ⟨⟨a, ha, hba⟩, hb⟩
state_before: case a.mp
α : Type u_1
β : Type u_2
γ : Type ?u.520534
inst✝¹ : DecidableEq β
s✝ s₁ s₂ : Finset α
t t₁ t₂ : α → Finset β
s : Finset α
f : α → Finset β
p : β → Prop
inst✝ : DecidablePred p
b : β
⊢ (∃ a, a ∈ s ∧ b ∈ f a) ∧ p b → ∃ a, a ∈ s ∧ b ∈ f a ∧ p b

tactic: exact ⟨a, ha, hba, hb⟩
state_before: case a.mp.intro.intro.intro
α : Type u_1
β : Type u_2
γ : Type ?u.520534
inst✝¹ : DecidableEq β
s✝ s₁ s₂ : Finset α
t t₁ t₂ : α → Finset β
s : Finset α
f : α → Finset β
p : β → Prop
inst✝ : DecidablePred p
b : β
hb : p b
a : α
ha : a ∈ s
hba : b ∈ f a
⊢ ∃ a, a ∈ s ∧ b ∈ f a ∧ p b

tactic: rintro ⟨a, ha, hba, hb⟩
state_before: case a.mpr
α : Type u_1
β : Type u_2
γ : Type ?u.520534
inst✝¹ : DecidableEq β
s✝ s₁ s₂ : Finset α
t t₁ t₂ : α → Finset β
s : Finset α
f : α → Finset β
p : β → Prop
inst✝ : DecidablePred p
b : β
⊢ (∃ a, a ∈ s ∧ b ∈ f a ∧ p b) → (∃ a, a ∈ s ∧ b ∈ f a) ∧ p b

tactic: exact ⟨⟨a, ha, hba⟩, hb⟩
state_before: case a.mpr.intro.intro.intro
α : Type u_1
β : Type u_2
γ : Type ?u.520534
inst✝¹ : DecidableEq β
s✝ s₁ s₂ : Finset α
t t₁ t₂ : α → Finset β
s : Finset α
f : α → Finset β
p : β → Prop
inst✝ : DecidablePred p
b : β
a : α
ha : a ∈ s
hba : b ∈ f a
hb : p b
⊢ (∃ a, a ∈ s ∧ b ∈ f a) ∧ p b
Theorem: IsSubgroup.subset_normalizer
File: Mathlib/Deprecated/Subgroup.lean

tactic: rw [IsSubgroup.mul_mem_cancel_right hs ((IsSubgroup.inv_mem_iff hs).2 hg),
  IsSubgroup.mul_mem_cancel_left hs hg]
state_before: G : Type u_1
H : Type ?u.59591
A : Type ?u.59594
a a₁ a₂ b c : G
inst✝ : Group G
s : Set G
hs : IsSubgroup s
g : G
hg : g ∈ s
n : G
⊢ n ∈ s ↔ g * n * g⁻¹ ∈ s
Theorem: MeasureTheory.IsFundamentalDomain.smul
File: Mathlib/MeasureTheory/Group/FundamentalDomain.lean

tactic: simp [mul_assoc]
state_before: G : Type u_1
H : Type ?u.119421
α : Type u_2
β : Type ?u.119427
E : Type ?u.119430
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 α μ
h : IsFundamentalDomain G s
g g' : G
⊢ (fun g' => g * g' * g⁻¹) ((fun g' => g⁻¹ * g' * g) g') = g'

tactic: simp [mul_assoc]
state_before: G : Type u_1
H : Type ?u.119421
α : Type u_2
β : Type ?u.119427
E : Type ?u.119430
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 α μ
h : IsFundamentalDomain G s
g g' : G
⊢ (fun g' => g⁻¹ * g' * g) ((fun g' => g * g' * g⁻¹) g') = g'

tactic: simp [smul_smul, mul_assoc]
state_before: G : Type u_1
H : Type ?u.119421
α : Type u_2
β : Type ?u.119427
E : Type ?u.119430
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 α μ
h : IsFundamentalDomain G s
g g' : G
x : α
⊢ ↑(MulAction.toPerm g)
      ((fun x =>
          ↑{ toFun := fun g' => g⁻¹ * g' * g, invFun := fun g' => g * g' * g⁻¹,
                  left_inv := (_ : ∀ (g' : G), g * (g⁻¹ * g' * g) * g⁻¹ = g'),
                  right_inv := (_ : ∀ (g' : G), g⁻¹ * (g * g' * g⁻¹) * g = g') }
              g' •
            x)
        x) =
    (fun x => g' • x) (↑(MulAction.toPerm g) x)
Theorem: Nat.Prime.factors_pow
File: Mathlib/Data/Nat/Factors.lean

tactic: symm
state_before: p : ℕ
hp : Prime p
n : ℕ
⊢ factors (p ^ n) = replicate n p

tactic: rw [← List.replicate_perm]
state_before: p : ℕ
hp : Prime p
n : ℕ
⊢ replicate n p = factors (p ^ n)

tactic: apply Nat.factors_unique (List.prod_replicate n p)
state_before: p : ℕ
hp : Prime p
n : ℕ
⊢ replicate n p ~ factors (p ^ n)

tactic: intro q hq
state_before: p : ℕ
hp : Prime p
n : ℕ
⊢ ∀ (p_1 : ℕ), p_1 ∈ replicate n p → Prime p_1

tactic: rwa [eq_of_mem_replicate hq]
state_before: p : ℕ
hp : Prime p
n q : ℕ
hq : q ∈ replicate n p
⊢ Prime q
Theorem: Stream'.WSeq.head_think
File: Mathlib/Data/Seq/WSeq.lean

tactic: simp [head]
state_before: α : Type u
β : Type v
γ : Type w
s : WSeq α
⊢ head (think s) = Computation.think (head s)
Theorem: CategoryTheory.Limits.colimit.desc_extend
File: Mathlib/CategoryTheory/Limits/HasLimits.lean

tactic: ext1
state_before: J : Type u₁
inst✝³ : Category J
K : Type u₂
inst✝² : Category K
C : Type u
inst✝¹ : Category C
F✝ F : J ⥤ C
inst✝ : HasColimit F
c : Cocone F
X : C
f : c.pt ⟶ X
⊢ desc F (Cocone.extend c f) = desc F c ≫ f

tactic: rw [← Category.assoc]
state_before: case w
J : Type u₁
inst✝³ : Category J
K : Type u₂
inst✝² : Category K
C : Type u
inst✝¹ : Category C
F✝ F : J ⥤ C
inst✝ : HasColimit F
c : Cocone F
X : C
f : c.pt ⟶ X
j✝ : J
⊢ ι F j✝ ≫ desc F (Cocone.extend c f) = ι F j✝ ≫ desc F c ≫ f

tactic: simp
state_before: case w
J : Type u₁
inst✝³ : Category J
K : Type u₂
inst✝² : Category K
C : Type u
inst✝¹ : Category C
F✝ F : J ⥤ C
inst✝ : HasColimit F
c : Cocone F
X : C
f : c.pt ⟶ X
j✝ : J
⊢ ι F j✝ ≫ desc F (Cocone.extend c f) = (ι F j✝ ≫ desc F c) ≫ f
Theorem: Nat.ofDigits_eq_sum_map_with_index_aux
File: Mathlib/Data/Nat/Digits.lean

tactic: suffices
  (List.range l.length).zipWith ((fun i a : ℕ => a * b ^ i) ∘ succ) l =
    (List.range l.length).zipWith (fun i a => b * (a * b ^ i)) l
  by simp [this]
state_before: n b : ℕ
l : List ℕ
⊢ List.sum (List.zipWith ((fun i a => a * b ^ i) ∘ succ) (List.range (List.length l)) l) =
    b * List.sum (List.zipWith (fun i a => a * b ^ i) (List.range (List.length l)) l)

tactic: congr
state_before: n b : ℕ
l : List ℕ
⊢ List.zipWith ((fun i a => a * b ^ i) ∘ succ) (List.range (List.length l)) l =
    List.zipWith (fun i a => b * (a * b ^ i)) (List.range (List.length l)) l

tactic: ext
state_before: case e_f
n b : ℕ
l : List ℕ
⊢ (fun i a => a * b ^ i) ∘ succ = fun i a => b * (a * b ^ i)

tactic: simp [pow_succ]
state_before: case e_f.h.h
n b : ℕ
l : List ℕ
x✝¹ x✝ : ℕ
⊢ ((fun i a => a * b ^ i) ∘ succ) x✝¹ x✝ = b * (x✝ * b ^ x✝¹)

tactic: ring
state_before: case e_f.h.h
n b : ℕ
l : List ℕ
x✝¹ x✝ : ℕ
⊢ x✝ * (b ^ x✝¹ * b) = b * (x✝ * b ^ x✝¹)

tactic: simp [this]
state_before: n b : ℕ
l : List ℕ
this :
  List.zipWith ((fun i a => a * b ^ i) ∘ succ) (List.range (List.length l)) l =
    List.zipWith (fun i a => b * (a * b ^ i)) (List.range (List.length l)) l
⊢ List.sum (List.zipWith ((fun i a => a * b ^ i) ∘ succ) (List.range (List.length l)) l) =
    b * List.sum (List.zipWith (fun i a => a * b ^ i) (List.range (List.length l)) l)
Theorem: Set.ncard_eq_two
File: Mathlib/Data/Set/Ncard.lean

tactic: refine' ⟨fun h ↦ _, _⟩
state_before: α : Type u_1
β : Type ?u.162338
s t : Set α
a b x y : α
f : α → β
⊢ ncard s = 2 ↔ ∃ x y, x ≠ y ∧ s = {x, y}

tactic: rintro ⟨x, y, hxy, rfl⟩
state_before: case refine'_2
α : Type u_1
β : Type ?u.162338
s t : Set α
a b x y : α
f : α → β
⊢ (∃ x y, x ≠ y ∧ s = {x, y}) → ncard s = 2

tactic: rw [ncard_eq_toFinset_card _, Finset.card_eq_two]
state_before: case refine'_2.intro.intro.intro
α : Type u_1
β : Type ?u.162338
t : Set α
a b x✝ y✝ : α
f : α → β
x y : α
hxy : x ≠ y
⊢ ncard {x, y} = 2

tactic: exact ⟨x, y, hxy, by ext; simp⟩
state_before: case refine'_2.intro.intro.intro
α : Type u_1
β : Type ?u.162338
t : Set α
a b x✝ y✝ : α
f : α → β
x y : α
hxy : x ≠ y
⊢ ∃ x_1 y_1, x_1 ≠ y_1 ∧ Finite.toFinset (_ : Set.Finite {x, y}) = {x_1, y_1}

tactic: obtain ⟨x, t, hxt, rfl, ht⟩ := eq_insert_of_ncard_eq_succ h
state_before: case refine'_1
α : Type u_1
β : Type ?u.162338
s t : Set α
a b x y : α
f : α → β
h : ncard s = 2
⊢ ∃ x y, x ≠ y ∧ s = {x, y}

tactic: obtain ⟨y, rfl⟩ := ncard_eq_one.mp ht
state_before: case refine'_1.intro.intro.intro.intro
α : Type u_1
β : Type ?u.162338
t✝ : Set α
a b x✝ y : α
f : α → β
x : α
t : Set α
hxt : ¬x ∈ t
ht : ncard t = 1
h : ncard (insert x t) = 2
⊢ ∃ x_1 y, x_1 ≠ y ∧ insert x t = {x_1, y}

tactic: rw [mem_singleton_iff] at hxt
state_before: case refine'_1.intro.intro.intro.intro.intro
α : Type u_1
β : Type ?u.162338
t : Set α
a b x✝ y✝ : α
f : α → β
x y : α
hxt : ¬x ∈ {y}
ht : ncard {y} = 1
h : ncard {x, y} = 2
⊢ ∃ x_1 y_1, x_1 ≠ y_1 ∧ {x, y} = {x_1, y_1}

tactic: exact ⟨_, _, hxt, rfl⟩
state_before: case refine'_1.intro.intro.intro.intro.intro
α : Type u_1
β : Type ?u.162338
t : Set α
a b x✝ y✝ : α
f : α → β
x y : α
hxt : ¬x = y
ht : ncard {y} = 1
h : ncard {x, y} = 2
⊢ ∃ x_1 y_1, x_1 ≠ y_1 ∧ {x, y} = {x_1, y_1}

tactic: ext
state_before: α : Type u_1
β : Type ?u.162338
t : Set α
a b x✝ y✝ : α
f : α → β
x y : α
hxy : x ≠ y
⊢ Finite.toFinset (_ : Set.Finite {x, y}) = {x, y}

tactic: simp
state_before: case a
α : Type u_1
β : Type ?u.162338
t : Set α
a b x✝ y✝ : α
f : α → β
x y : α
hxy : x ≠ y
a✝ : α
⊢ a✝ ∈ Finite.toFinset (_ : Set.Finite {x, y}) ↔ a✝ ∈ {x, y}
Theorem: Nat.min_comm
File: Std/Data/Nat/Lemmas.lean

tactic: simp [Nat.min_def]
state_before: a b : Nat
⊢ min a b = min b a

tactic: split <;> split <;> simp [*]
state_before: a b : Nat
⊢ (if a ≤ b then a else b) = if b ≤ a then b else a

tactic: next h₁ h₂ => exact Nat.le_antisymm h₁ h₂
state_before: case inl.inl
a b : Nat
h✝¹ : a ≤ b
h✝ : b ≤ a
⊢ a = b

tactic: exact Nat.le_antisymm h₁ h₂
state_before: a b : Nat
h₁ : a ≤ b
h₂ : b ≤ a
⊢ a = b

tactic: next h₁ h₂ => cases not_or_intro h₁ h₂ <| Nat.le_total ..
state_before: case inr.inr
a b : Nat
h✝¹ : ¬a ≤ b
h✝ : ¬b ≤ a
⊢ b = a

tactic: cases not_or_intro h₁ h₂ <| Nat.le_total ..
state_before: a b : Nat
h₁ : ¬a ≤ b
h₂ : ¬b ≤ a
⊢ b = a
Theorem: Multiset.disjoint_cons_left
File: Mathlib/Data/Multiset/Basic.lean

tactic: rw [singleton_disjoint]
state_before: α : Type u_1
β : Type ?u.492391
γ : Type ?u.492394
a : α
s t : Multiset α
⊢ Disjoint {a} t ∧ Disjoint s t ↔ ¬a ∈ t ∧ Disjoint s t
Theorem: Filter.tendsto_finset_image_atTop_atTop
File: Mathlib/Order/Filter/AtTopBot.lean

tactic: simp only [Finset.image_singleton, h a, Finset.mem_singleton]
state_before: ι : Type ?u.269970
ι' : Type ?u.269973
α : Type ?u.269976
β : Type u_1
γ : Type u_2
inst✝ : DecidableEq β
i : β → γ
j : γ → β
h : Function.LeftInverse j i
a : β
⊢ a ∈ Finset.image j {i a}
Theorem: MeasureTheory.Measure.prod_apply
File: Mathlib/MeasureTheory/Constructions/Prod/Basic.lean

tactic: simp_rw [Measure.prod, bind_apply hs (Measurable.map_prod_mk_left (ν := ν)),
  map_apply measurable_prod_mk_left hs]
state_before: α : Type u_2
α' : Type ?u.4425879
β : Type u_1
β' : Type ?u.4425885
γ : Type ?u.4425888
E : Type ?u.4425891
inst✝⁶ : MeasurableSpace α
inst✝⁵ : MeasurableSpace α'
inst✝⁴ : MeasurableSpace β
inst✝³ : MeasurableSpace β'
inst✝² : MeasurableSpace γ
μ μ' : Measure α
ν ν' : Measure β
τ : Measure γ
inst✝¹ : NormedAddCommGroup E
inst✝ : SigmaFinite ν
s : Set (α × β)
hs : MeasurableSet s
⊢ ↑↑(Measure.prod μ ν) s = ∫⁻ (x : α), ↑↑ν (Prod.mk x ⁻¹' s) ∂μ
Theorem: Equiv.prodCongrRight_trans_prodComm
File: Mathlib/Logic/Equiv/Basic.lean

tactic: ext ⟨a, b⟩ : 1
state_before: α₁ : Type u_3
β₁ : Type u_2
β₂ : Type u_1
e : α₁ → β₁ ≃ β₂
⊢ (prodCongrRight e).trans (prodComm α₁ β₂) = (prodComm α₁ β₁).trans (prodCongrLeft e)

tactic: simp
state_before: case H.mk
α₁ : Type u_3
β₁ : Type u_2
β₂ : Type u_1
e : α₁ → β₁ ≃ β₂
a : α₁
b : β₁
⊢ ↑((prodCongrRight e).trans (prodComm α₁ β₂)) (a, b) = ↑((prodComm α₁ β₁).trans (prodCongrLeft e)) (a, b)
Theorem: covby_iff_coatom_Iic
File: Mathlib/Order/Atoms.lean

tactic: simp
state_before: α : Type u_1
β : Type ?u.8894
inst✝ : PartialOrder α
a b : α
h : a ≤ b
⊢ a ⋖ b ↔ IsCoatom { val := a, property := h }
Theorem: IsLprojection.join
File: Mathlib/Analysis/NormedSpace/MStructure.lean

tactic: convert (Lcomplement_iff _).mp (h₁.Lcomplement.mul h₂.Lcomplement) using 1
state_before: X : Type u_2
inst✝³ : NormedAddCommGroup X
M : Type u_1
inst✝² : Ring M
inst✝¹ : Module M X
inst✝ : FaithfulSMul M X
P Q : M
h₁ : IsLprojection X P
h₂ : IsLprojection X Q
⊢ IsLprojection X (P + Q - P * Q)

tactic: noncomm_ring
state_before: case h.e'_6
X : Type u_2
inst✝³ : NormedAddCommGroup X
M : Type u_1
inst✝² : Ring M
inst✝¹ : Module M X
inst✝ : FaithfulSMul M X
P Q : M
h₁ : IsLprojection X P
h₂ : IsLprojection X Q
⊢ P + Q - P * Q = 1 - (1 - P) * (1 - Q)
Theorem: Real.arcsin_eq_iff_eq_sin
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Inverse.lean

tactic: simp only [le_antisymm_iff, arcsin_le_iff_le_sin' (mem_Ico_of_Ioo hy),
  le_arcsin_iff_sin_le' (mem_Ioc_of_Ioo hy)]
state_before: x y : ℝ
hy : y ∈ Ioo (-(π / 2)) (π / 2)
⊢ arcsin x = y ↔ x = sin y
Theorem: MeasureTheory.VectorMeasure.restrict_empty
File: Mathlib/MeasureTheory/Measure/VectorMeasure.lean

tactic: rw [restrict_apply v MeasurableSet.empty hi, Set.inter_empty, v.empty, zero_apply]
state_before: α : Type u_1
β : Type ?u.473672
m inst✝³ : MeasurableSpace α
inst✝² : MeasurableSpace β
M : Type u_2
inst✝¹ : AddCommMonoid M
inst✝ : TopologicalSpace M
v : VectorMeasure α M
i : Set α
hi : MeasurableSet i
⊢ ↑(restrict v ∅) i = ↑0 i
Theorem: Rack.left_cancel
File: Mathlib/Algebra/Quandle.lean

tactic: constructor
state_before: R : Type u_1
inst✝ : Rack R
x y y' : R
⊢ x ◃ y = x ◃ y' ↔ y = y'

tactic: apply (act' x).injective
state_before: case mp
R : Type u_1
inst✝ : Rack R
x y y' : R
⊢ x ◃ y = x ◃ y' → y = y'

case mpr
R : Type u_1
inst✝ : Rack R
x y y' : R
⊢ y = y' → x ◃ y = x ◃ y'

tactic: rintro rfl
state_before: case mpr
R : Type u_1
inst✝ : Rack R
x y y' : R
⊢ y = y' → x ◃ y = x ◃ y'

tactic: rfl
state_before: case mpr
R : Type u_1
inst✝ : Rack R
x y : R
⊢ x ◃ y = x ◃ y
Theorem: finprod_mem_eq_toFinset_prod
File: Mathlib/Algebra/BigOperators/Finprod.lean

tactic: simp_rw [coe_toFinset s]
state_before: α : Type u_1
β : Type ?u.201320
ι : Type ?u.201323
G : Type ?u.201326
M : Type u_2
N : Type ?u.201332
inst✝² : CommMonoid M
inst✝¹ : CommMonoid N
f : α → M
s : Set α
inst✝ : Fintype ↑s
⊢ (s ∩ mulSupport fun i => f i) = ↑(toFinset s) ∩ mulSupport fun i => f i
Theorem: sdiff_right_comm
File: Mathlib/Order/Heyting/Basic.lean

tactic: simp_rw [sdiff_sdiff, sup_comm]
state_before: ι : Type ?u.135344
α : Type u_1
β : Type ?u.135350
inst✝ : GeneralizedCoheytingAlgebra α
a✝ b✝ c✝ d a b c : α
⊢ (a \ b) \ c = (a \ c) \ b
Theorem: norm_inner_symm
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

tactic: rw [← inner_conj_symm, norm_conj]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.1721983
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
dec_E : DecidableEq E
x y : E
⊢ ‖inner x y‖ = ‖inner y x‖
Theorem: disjoint_compl_left_iff
File: Mathlib/Order/BooleanAlgebra.lean

tactic: rw [← le_compl_iff_disjoint_left, compl_compl]
state_before: α : Type u
β : Type ?u.59824
w x y z : α
inst✝ : BooleanAlgebra α
⊢ Disjoint (xᶜ) y ↔ y ≤ x
Theorem: Fintype.card_le_card_of_leftTotal_unique
File: Mathlib/Combinatorics/DoubleCounting.lean

tactic: simpa using h₁
state_before: α : Type u_1
β : Type u_2
inst✝¹ : Fintype α
inst✝ : Fintype β
r : α → β → Prop
h₁ : LeftTotal r
h₂ : LeftUnique r
⊢ ∀ (a : α), a ∈ univ → ∃ b, b ∈ univ ∧ r a b
Theorem: UniqueFactorizationMonoid.factors_one
File: Mathlib/RingTheory/UniqueFactorizationDomain.lean

tactic: nontriviality α using factors
state_before: α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : DecidableEq α
inst✝ : UniqueFactorizationMonoid α
⊢ factors 1 = 0

tactic: rw [← Multiset.rel_zero_right]
state_before: α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : DecidableEq α
inst✝ : UniqueFactorizationMonoid α
✝ : Nontrivial α
⊢ factors 1 = 0

tactic: refine' factors_unique irreducible_of_factor (fun x hx => (Multiset.not_mem_zero x hx).elim) _
state_before: α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : DecidableEq α
inst✝ : UniqueFactorizationMonoid α
✝ : Nontrivial α
⊢ Multiset.Rel ?m.393736 (factors 1) 0

α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : DecidableEq α
inst✝ : UniqueFactorizationMonoid α
✝ : Nontrivial α
⊢ Type ?u.393733

α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : DecidableEq α
inst✝ : UniqueFactorizationMonoid α
✝ : Nontrivial α
⊢ α → ?m.393735 → Prop

tactic: rw [Multiset.prod_zero]
state_before: α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : DecidableEq α
inst✝ : UniqueFactorizationMonoid α
✝ : Nontrivial α
⊢ Multiset.prod (factors 1) ~ᵤ Multiset.prod 0

tactic: exact factors_prod one_ne_zero
state_before: α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : DecidableEq α
inst✝ : UniqueFactorizationMonoid α
✝ : Nontrivial α
⊢ Multiset.prod (factors 1) ~ᵤ 1
Theorem: Associates.factors_self
File: Mathlib/RingTheory/UniqueFactorizationDomain.lean

tactic: rw [factors_prod, FactorSet.prod]
state_before: α : Type u_1
inst✝² : CancelCommMonoidWithZero α
dec_irr : (p : Associates α) → Decidable (Irreducible p)
inst✝¹ : UniqueFactorizationMonoid α
dec : DecidableEq α
dec' : DecidableEq (Associates α)
inst✝ : Nontrivial α
p : Associates α
hp : Irreducible p
⊢ FactorSet.prod (factors p) = FactorSet.prod (some {{ val := p, property := hp }})

tactic: dsimp
state_before: α : Type u_1
inst✝² : CancelCommMonoidWithZero α
dec_irr : (p : Associates α) → Decidable (Irreducible p)
inst✝¹ : UniqueFactorizationMonoid α
dec : DecidableEq α
dec' : DecidableEq (Associates α)
inst✝ : Nontrivial α
p : Associates α
hp : Irreducible p
⊢ p =
    match some {{ val := p, property := hp }} with
    | none => 0
    | some s => prod (map Subtype.val s)

tactic: rw [prod_singleton]
state_before: α : Type u_1
inst✝² : CancelCommMonoidWithZero α
dec_irr : (p : Associates α) → Decidable (Irreducible p)
inst✝¹ : UniqueFactorizationMonoid α
dec : DecidableEq α
dec' : DecidableEq (Associates α)
inst✝ : Nontrivial α
p : Associates α
hp : Irreducible p
⊢ p = prod {p}
Theorem: Ordinal.IsNormal.fp_iff_deriv
File: Mathlib/SetTheory/Ordinal/FixedPoint.lean

tactic: rw [← H.le_iff_eq, H.le_iff_deriv]
state_before: f✝ : Ordinal → Ordinal
f : Ordinal → Ordinal
H : IsNormal f
a : Ordinal
⊢ f a = a ↔ ∃ o, deriv f o = a
Theorem: PEquiv.mem_ofSet_self_iff
File: Mathlib/Data/PEquiv.lean

tactic: dsimp [ofSet]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type x
s✝ : Set α
inst✝¹ : DecidablePred fun x => x ∈ s✝
s : Set α
inst✝ : DecidablePred fun x => x ∈ s
a : α
⊢ a ∈ ↑(ofSet s) a ↔ a ∈ s

tactic: split_ifs <;> simp [*]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type x
s✝ : Set α
inst✝¹ : DecidablePred fun x => x ∈ s✝
s : Set α
inst✝ : DecidablePred fun x => x ∈ s
a : α
⊢ (a ∈ if a ∈ s then some a else none) ↔ a ∈ s
Theorem: Matrix.diagonal_dotProduct
File: Mathlib/Data/Matrix/Basic.lean

tactic: have : ∀ (j) (_ : j ≠ i), diagonal v i j * w j = 0 := fun j hij => by
  simp [diagonal_apply_ne' _ hij]
state_before: l : Type ?u.150094
m : Type u_1
n : Type ?u.150100
o : Type ?u.150103
m' : o → Type ?u.150108
n' : o → Type ?u.150113
R : Type ?u.150116
S : Type ?u.150119
α : Type v
β : Type w
γ : Type ?u.150126
inst✝³ : Fintype m
inst✝² : Fintype n
inst✝¹ : DecidableEq m
inst✝ : NonUnitalNonAssocSemiring α
u v w : m → α
i : m
⊢ diagonal v i ⬝ᵥ w = v i * w i

tactic: convert Finset.sum_eq_single i (fun j _ => this j) _ using 1 <;> simp
state_before: l : Type ?u.150094
m : Type u_1
n : Type ?u.150100
o : Type ?u.150103
m' : o → Type ?u.150108
n' : o → Type ?u.150113
R : Type ?u.150116
S : Type ?u.150119
α : Type v
β : Type w
γ : Type ?u.150126
inst✝³ : Fintype m
inst✝² : Fintype n
inst✝¹ : DecidableEq m
inst✝ : NonUnitalNonAssocSemiring α
u v w : m → α
i : m
this : ∀ (j : m), j ≠ i → diagonal v i j * w j = 0
⊢ diagonal v i ⬝ᵥ w = v i * w i

tactic: simp [diagonal_apply_ne' _ hij]
state_before: l : Type ?u.150094
m : Type u_1
n : Type ?u.150100
o : Type ?u.150103
m' : o → Type ?u.150108
n' : o → Type ?u.150113
R : Type ?u.150116
S : Type ?u.150119
α : Type v
β : Type w
γ : Type ?u.150126
inst✝³ : Fintype m
inst✝² : Fintype n
inst✝¹ : DecidableEq m
inst✝ : NonUnitalNonAssocSemiring α
u v w : m → α
i j : m
hij : j ≠ i
⊢ diagonal v i j * w j = 0