tasksource/leandojo huggingface dataset:
Theorem: List.Nodup.isCycleOn_formPerm
File: Mathlib/GroupTheory/Perm/Cycle/Basic.lean

tactic: refine' ⟨l.formPerm.bijOn fun _ => List.formPerm_mem_iff_mem, fun a ha b hb => _⟩
state_before: ι : Type ?u.3063559
α : Type u_1
β : Type ?u.3063565
inst✝¹ inst✝ : DecidableEq α
l : List α
h : List.Nodup l
⊢ IsCycleOn (List.formPerm l) {a | a ∈ l}

tactic: rw [Set.mem_setOf, ← List.indexOf_lt_length] at ha hb
state_before: ι : Type ?u.3063559
α : Type u_1
β : Type ?u.3063565
inst✝¹ inst✝ : DecidableEq α
l : List α
h : List.Nodup l
a : α
ha : a ∈ {a | a ∈ l}
b : α
hb : b ∈ {a | a ∈ l}
⊢ SameCycle (List.formPerm l) a b

tactic: rw [← List.indexOf_get ha, ← List.indexOf_get hb]
state_before: ι : Type ?u.3063559
α : Type u_1
β : Type ?u.3063565
inst✝¹ inst✝ : DecidableEq α
l : List α
h : List.Nodup l
a : α
ha✝ : a ∈ l
ha : List.indexOf a l < List.length l
b : α
hb✝ : b ∈ l
hb : List.indexOf b l < List.length l
⊢ SameCycle (List.formPerm l) a b

tactic: refine' ⟨l.indexOf b - l.indexOf a, _⟩
state_before: ι : Type ?u.3063559
α : Type u_1
β : Type ?u.3063565
inst✝¹ inst✝ : DecidableEq α
l : List α
h : List.Nodup l
a : α
ha✝ : a ∈ l
ha : List.indexOf a l < List.length l
b : α
hb✝ : b ∈ l
hb : List.indexOf b l < List.length l
⊢ SameCycle (List.formPerm l) (List.get l { val := List.indexOf a l, isLt := ha })
    (List.get l { val := List.indexOf b l, isLt := hb })

tactic: simp only [sub_eq_neg_add, zpow_add, zpow_neg, Equiv.Perm.inv_eq_iff_eq, zpow_ofNat,
  Equiv.Perm.coe_mul, ← List.nthLe_eq, List.formPerm_pow_apply_nthLe _ h, Function.comp]
state_before: ι : Type ?u.3063559
α : Type u_1
β : Type ?u.3063565
inst✝¹ inst✝ : DecidableEq α
l : List α
h : List.Nodup l
a : α
ha✝ : a ∈ l
ha : List.indexOf a l < List.length l
b : α
hb✝ : b ∈ l
hb : List.indexOf b l < List.length l
⊢ ↑(List.formPerm l ^ (↑(List.indexOf b l) - ↑(List.indexOf a l)))
      (List.get l { val := List.indexOf a l, isLt := ha }) =
    List.get l { val := List.indexOf b l, isLt := hb }

tactic: rw [add_comm]
state_before: ι : Type ?u.3063559
α : Type u_1
β : Type ?u.3063565
inst✝¹ inst✝ : DecidableEq α
l : List α
h : List.Nodup l
a : α
ha✝ : a ∈ l
ha : List.indexOf a l < List.length l
b : α
hb✝ : b ∈ l
hb : List.indexOf b l < List.length l
⊢ List.nthLe l ((List.indexOf a l + List.indexOf b l) % List.length l)
      (_ : (List.indexOf a l + List.indexOf b l) % List.length l < List.length l) =
    List.nthLe l ((List.indexOf b l + List.indexOf a l) % List.length l)
      (_ : (List.indexOf b l + List.indexOf a l) % List.length l < List.length l)
Theorem: TypeVec.lastFun_of_subtype
File: Mathlib/Data/TypeVec.lean

tactic: ext i : 2
state_before: n : ℕ
α : TypeVec (n + 1)
p : α ⟹ repeat (n + 1) Prop
⊢ lastFun (ofSubtype p) = _root_.id

tactic: induction i
state_before: case h
n : ℕ
α : TypeVec (n + 1)
p : α ⟹ repeat (n + 1) Prop
i : last (Subtype_ p)
⊢ lastFun (ofSubtype p) i = _root_.id i

tactic: simp [dropFun, *]
state_before: case h.mk
n : ℕ
α : TypeVec (n + 1)
p : α ⟹ repeat (n + 1) Prop
val✝ : α Fin2.fz
property✝ : p Fin2.fz val✝
⊢ lastFun (ofSubtype p) { val := val✝, property := property✝ } = _root_.id { val := val✝, property := property✝ }

tactic: rfl
state_before: case h.mk
n : ℕ
α : TypeVec (n + 1)
p : α ⟹ repeat (n + 1) Prop
val✝ : α Fin2.fz
property✝ : p Fin2.fz val✝
⊢ lastFun (ofSubtype p) { val := val✝, property := property✝ } = { val := val✝, property := property✝ }
Theorem: MeasureTheory.Content.outerMeasure_caratheodory
File: Mathlib/MeasureTheory/Measure/Content.lean

tactic: rw [Opens.forall]
state_before: G : Type w
inst✝¹ : TopologicalSpace G
μ : Content G
inst✝ : T2Space G
A : Set G
⊢ MeasurableSet A ↔
    ∀ (U : Opens G),
      ↑(Content.outerMeasure μ) (↑U ∩ A) + ↑(Content.outerMeasure μ) (↑U \ A) ≤ ↑(Content.outerMeasure μ) ↑U

tactic: apply inducedOuterMeasure_caratheodory
state_before: G : Type w
inst✝¹ : TopologicalSpace G
μ : Content G
inst✝ : T2Space G
A : Set G
⊢ MeasurableSet A ↔
    ∀ (U : Set G) (hU : IsOpen U),
      ↑(Content.outerMeasure μ) (↑{ carrier := U, is_open' := hU } ∩ A) +
          ↑(Content.outerMeasure μ) (↑{ carrier := U, is_open' := hU } \ A) ≤
        ↑(Content.outerMeasure μ) ↑{ carrier := U, is_open' := hU }

tactic: apply innerContent_iUnion_nat
state_before: case msU
G : Type w
inst✝¹ : TopologicalSpace G
μ : Content G
inst✝ : T2Space G
A : Set G
⊢ ∀ ⦃f : ℕ → Set G⦄ (hm : ∀ (i : ℕ), IsOpen (f i)),
    innerContent μ { carrier := ⋃ (i : ℕ), f i, is_open' := (_ : ?P (⋃ (i : ℕ), f i)) } ≤
      ∑' (i : ℕ), innerContent μ { carrier := f i, is_open' := (_ : IsOpen (f i)) }

case m_mono
G : Type w
inst✝¹ : TopologicalSpace G
μ : Content G
inst✝ : T2Space G
A : Set G
⊢ ∀ ⦃s₁ s₂ : Set G⦄ (hs₁ : IsOpen s₁) (hs₂ : IsOpen s₂),
    s₁ ⊆ s₂ → innerContent μ { carrier := s₁, is_open' := hs₁ } ≤ innerContent μ { carrier := s₂, is_open' := hs₂ }

case PU
G : Type w
inst✝¹ : TopologicalSpace G
μ : Content G
inst✝ : T2Space G
A : Set G
⊢ ∀ ⦃f : ℕ → Set G⦄, (∀ (i : ℕ), IsOpen (f i)) → IsOpen (⋃ (i : ℕ), f i)

tactic: apply innerContent_mono'
state_before: case m_mono
G : Type w
inst✝¹ : TopologicalSpace G
μ : Content G
inst✝ : T2Space G
A : Set G
⊢ ∀ ⦃s₁ s₂ : Set G⦄ (hs₁ : IsOpen s₁) (hs₂ : IsOpen s₂),
    s₁ ⊆ s₂ → innerContent μ { carrier := s₁, is_open' := hs₁ } ≤ innerContent μ { carrier := s₂, is_open' := hs₂ }
Theorem: Multiset.lcm_ndinsert
File: Mathlib/Algebra/GCDMonoid/Multiset.lean

tactic: rw [← lcm_dedup, dedup_ext.2, lcm_dedup, lcm_cons]
state_before: α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizedGCDMonoid α
inst✝ : DecidableEq α
a : α
s : Multiset α
⊢ lcm (ndinsert a s) = GCDMonoid.lcm a (lcm s)

tactic: simp
state_before: α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizedGCDMonoid α
inst✝ : DecidableEq α
a : α
s : Multiset α
⊢ ∀ (a_1 : α), a_1 ∈ ndinsert a s ↔ a_1 ∈ a ::ₘ s
Theorem: RatFunc.denom_one
File: Mathlib/FieldTheory/RatFunc.lean

tactic: convert denom_div (1 : K[X]) one_ne_zero <;> simp
state_before: K : Type u
inst✝ : Field K
⊢ denom 1 = 1
Theorem: Complex.ext_iff
File: Mathlib/Data/Complex/Basic.lean

tactic: simp [H]
state_before: z w : ℂ
H : z = w
⊢ z.re = w.re ∧ z.im = w.im
Theorem: Set.preimage_coe_coe_diagonal
File: Mathlib/Data/Set/Prod.lean

tactic: ext ⟨⟨x, hx⟩, ⟨y, hy⟩⟩
state_before: α : Type u_1
s✝ t s : Set α
⊢ (Prod.map (fun x => ↑x) fun x => ↑x) ⁻¹' diagonal α = diagonal ↑s

tactic: simp [Set.diagonal]
state_before: case h.mk.mk.mk
α : Type u_1
s✝ t s : Set α
x : α
hx : x ∈ s
y : α
hy : y ∈ s
⊢ ({ val := x, property := hx }, { val := y, property := hy }) ∈ (Prod.map (fun x => ↑x) fun x => ↑x) ⁻¹' diagonal α ↔
    ({ val := x, property := hx }, { val := y, property := hy }) ∈ diagonal ↑s
Theorem: ContinuousLinearMap.isAdjointPair_inner
File: Mathlib/Analysis/InnerProductSpace/Adjoint.lean

tactic: intro x y
state_before: 𝕜 : Type ?u.1264931
E : Type ?u.1264934
F : Type ?u.1264937
G : Type ?u.1264940
inst✝¹⁵ : IsROrC 𝕜
inst✝¹⁴ : NormedAddCommGroup E
inst✝¹³ : NormedAddCommGroup F
inst✝¹² : NormedAddCommGroup G
inst✝¹¹ : InnerProductSpace 𝕜 E
inst✝¹⁰ : InnerProductSpace 𝕜 F
inst✝⁹ : InnerProductSpace 𝕜 G
inst✝⁸ : CompleteSpace E
inst✝⁷ : CompleteSpace G
inst✝⁶ : CompleteSpace F
E' : Type u_1
F' : Type u_2
inst✝⁵ : NormedAddCommGroup E'
inst✝⁴ : NormedAddCommGroup F'
inst✝³ : InnerProductSpace ℝ E'
inst✝² : InnerProductSpace ℝ F'
inst✝¹ : CompleteSpace E'
inst✝ : CompleteSpace F'
A : E' →L[ℝ] F'
⊢ LinearMap.IsAdjointPair sesqFormOfInner sesqFormOfInner ↑A ↑(↑adjoint A)

tactic: simp only [sesqFormOfInner_apply_apply, adjoint_inner_left, coe_coe]
state_before: 𝕜 : Type ?u.1264931
E : Type ?u.1264934
F : Type ?u.1264937
G : Type ?u.1264940
inst✝¹⁵ : IsROrC 𝕜
inst✝¹⁴ : NormedAddCommGroup E
inst✝¹³ : NormedAddCommGroup F
inst✝¹² : NormedAddCommGroup G
inst✝¹¹ : InnerProductSpace 𝕜 E
inst✝¹⁰ : InnerProductSpace 𝕜 F
inst✝⁹ : InnerProductSpace 𝕜 G
inst✝⁸ : CompleteSpace E
inst✝⁷ : CompleteSpace G
inst✝⁶ : CompleteSpace F
E' : Type u_1
F' : Type u_2
inst✝⁵ : NormedAddCommGroup E'
inst✝⁴ : NormedAddCommGroup F'
inst✝³ : InnerProductSpace ℝ E'
inst✝² : InnerProductSpace ℝ F'
inst✝¹ : CompleteSpace E'
inst✝ : CompleteSpace F'
A : E' →L[ℝ] F'
x : E'
y : F'
⊢ ↑(↑sesqFormOfInner (↑↑A x)) y = ↑(↑sesqFormOfInner x) (↑↑(↑adjoint A) y)
Theorem: Finsupp.mapRange.addEquiv_trans
File: Mathlib/Data/Finsupp/Basic.lean

tactic: simp
state_before: α : Type u_4
β : Type ?u.118278
γ : Type ?u.118281
ι : Type ?u.118284
M : Type u_1
M' : Type ?u.118290
N : Type u_2
P : Type u_3
G : Type ?u.118299
H : Type ?u.118302
R : Type ?u.118305
S : Type ?u.118308
inst✝² : AddCommMonoid M
inst✝¹ : AddCommMonoid N
inst✝ : AddCommMonoid P
f : M ≃+ N
f₂ : N ≃+ P
⊢ (↑f₂ ∘ ↑f) 0 = 0
Theorem: Real.tendsto_euler_sin_prod
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/EulerSineProd.lean

tactic: convert (Complex.continuous_re.tendsto _).comp (Complex.tendsto_euler_sin_prod x) using 1
state_before: x : ℝ
⊢ Tendsto (fun n => π * x * ∏ j in Finset.range n, (1 - x ^ 2 / (↑j + 1) ^ 2)) atTop (𝓝 (sin (π * x)))

tactic: ext1 n
state_before: case h.e'_3
x : ℝ
⊢ (fun n => π * x * ∏ j in Finset.range n, (1 - x ^ 2 / (↑j + 1) ^ 2)) =
    Complex.re ∘ fun n => ↑π * ↑x * ∏ j in Finset.range n, (1 - ↑x ^ 2 / (↑j + 1) ^ 2)

tactic: rw [Function.comp_apply, ← Complex.ofReal_mul, Complex.ofReal_mul_re]
state_before: case h.e'_3.h
x : ℝ
n : ℕ
⊢ π * x * ∏ j in Finset.range n, (1 - x ^ 2 / (↑j + 1) ^ 2) =
    (Complex.re ∘ fun n => ↑π * ↑x * ∏ j in Finset.range n, (1 - ↑x ^ 2 / (↑j + 1) ^ 2)) n

tactic: suffices
  (∏ j : ℕ in Finset.range n, ((1 : ℂ) - (x : ℂ) ^ 2 / ((j : ℂ) + 1) ^ 2)) =
    (∏ j : ℕ in Finset.range n, ((1 : ℝ) - x ^ 2 / ((j : ℝ) + 1) ^ 2) : ℝ) by
  rw [this, Complex.ofReal_re]
state_before: case h.e'_3.h
x : ℝ
n : ℕ
⊢ π * x * ∏ j in Finset.range n, (1 - x ^ 2 / (↑j + 1) ^ 2) =
    π * x * (∏ j in Finset.range n, (1 - ↑x ^ 2 / (↑j + 1) ^ 2)).re

tactic: rw [Complex.ofReal_prod]
state_before: case h.e'_3.h
x : ℝ
n : ℕ
⊢ ∏ j in Finset.range n, (1 - ↑x ^ 2 / (↑j + 1) ^ 2) = ↑(∏ j in Finset.range n, (1 - x ^ 2 / (↑j + 1) ^ 2))

tactic: refine' Finset.prod_congr (by rfl) fun n _ => _
state_before: case h.e'_3.h
x : ℝ
n : ℕ
⊢ ∏ j in Finset.range n, (1 - ↑x ^ 2 / (↑j + 1) ^ 2) = ∏ i in Finset.range n, ↑(1 - x ^ 2 / (↑i + 1) ^ 2)

tactic: norm_cast
state_before: case h.e'_3.h
x : ℝ
n✝ n : ℕ
x✝ : n ∈ Finset.range n✝
⊢ 1 - ↑x ^ 2 / (↑n + 1) ^ 2 = ↑(1 - x ^ 2 / (↑n + 1) ^ 2)

tactic: rw [this, Complex.ofReal_re]
state_before: x : ℝ
n : ℕ
this : ∏ j in Finset.range n, (1 - ↑x ^ 2 / (↑j + 1) ^ 2) = ↑(∏ j in Finset.range n, (1 - x ^ 2 / (↑j + 1) ^ 2))
⊢ π * x * ∏ j in Finset.range n, (1 - x ^ 2 / (↑j + 1) ^ 2) =
    π * x * (∏ j in Finset.range n, (1 - ↑x ^ 2 / (↑j + 1) ^ 2)).re

tactic: rfl
state_before: x : ℝ
n : ℕ
⊢ Finset.range n = Finset.range n

tactic: rw [← Complex.ofReal_mul, ← Complex.ofReal_sin, Complex.ofReal_re]
state_before: case h.e'_5
x : ℝ
⊢ 𝓝 (sin (π * x)) = 𝓝 (Complex.sin (↑π * ↑x)).re
Theorem: uniformity_hasBasis_closed
File: Mathlib/Topology/UniformSpace/Basic.lean

tactic: refine' Filter.hasBasis_self.2 fun t h => _
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.87316
inst✝ : UniformSpace α
⊢ HasBasis (𝓤 α) (fun V => V ∈ 𝓤 α ∧ IsClosed V) id

tactic: rcases comp_comp_symm_mem_uniformity_sets h with ⟨w, w_in, w_symm, r⟩
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.87316
inst✝ : UniformSpace α
t : Set (α × α)
h : t ∈ 𝓤 α
⊢ ∃ r, r ∈ 𝓤 α ∧ IsClosed r ∧ r ⊆ t

tactic: refine' ⟨closure w, mem_of_superset w_in subset_closure, isClosed_closure, _⟩
state_before: case intro.intro.intro
α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.87316
inst✝ : UniformSpace α
t : Set (α × α)
h : t ∈ 𝓤 α
w : Set (α × α)
w_in : w ∈ 𝓤 α
w_symm : SymmetricRel w
r : w ○ w ○ w ⊆ t
⊢ ∃ r, r ∈ 𝓤 α ∧ IsClosed r ∧ r ⊆ t

tactic: refine' Subset.trans _ r
state_before: case intro.intro.intro
α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.87316
inst✝ : UniformSpace α
t : Set (α × α)
h : t ∈ 𝓤 α
w : Set (α × α)
w_in : w ∈ 𝓤 α
w_symm : SymmetricRel w
r : w ○ w ○ w ⊆ t
⊢ closure w ⊆ t

tactic: rw [closure_eq_uniformity]
state_before: case intro.intro.intro
α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.87316
inst✝ : UniformSpace α
t : Set (α × α)
h : t ∈ 𝓤 α
w : Set (α × α)
w_in : w ∈ 𝓤 α
w_symm : SymmetricRel w
r : w ○ w ○ w ⊆ t
⊢ closure w ⊆ w ○ w ○ w

tactic: apply iInter_subset_of_subset
state_before: case intro.intro.intro
α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.87316
inst✝ : UniformSpace α
t : Set (α × α)
h : t ∈ 𝓤 α
w : Set (α × α)
w_in : w ∈ 𝓤 α
w_symm : SymmetricRel w
r : w ○ w ○ w ⊆ t
⊢ (⋂ (V : Set (α × α)) (_ : V ∈ {V | V ∈ 𝓤 α ∧ SymmetricRel V}), V ○ w ○ V) ⊆ w ○ w ○ w

tactic: apply iInter_subset
state_before: case intro.intro.intro.h
α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.87316
inst✝ : UniformSpace α
t : Set (α × α)
h : t ∈ 𝓤 α
w : Set (α × α)
w_in : w ∈ 𝓤 α
w_symm : SymmetricRel w
r : w ○ w ○ w ⊆ t
⊢ (⋂ (_ : ?intro.intro.intro.i ∈ {V | V ∈ 𝓤 α ∧ SymmetricRel V}), ?intro.intro.intro.i ○ w ○ ?intro.intro.intro.i) ⊆
    w ○ w ○ w

case intro.intro.intro.i
α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.87316
inst✝ : UniformSpace α
t : Set (α × α)
h : t ∈ 𝓤 α
w : Set (α × α)
w_in : w ∈ 𝓤 α
w_symm : SymmetricRel w
r : w ○ w ○ w ⊆ t
⊢ Set (α × α)

tactic: exact ⟨w_in, w_symm⟩
state_before: case intro.intro.intro.h.i
α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.87316
inst✝ : UniformSpace α
t : Set (α × α)
h : t ∈ 𝓤 α
w : Set (α × α)
w_in : w ∈ 𝓤 α
w_symm : SymmetricRel w
r : w ○ w ○ w ⊆ t
⊢ w ∈ {V | V ∈ 𝓤 α ∧ SymmetricRel V}
Theorem: Sylow.exists_subgroup_card_pow_prime
File: Mathlib/GroupTheory/Sylow.lean

tactic: simp
state_before: G : Type u
α : Type v
β : Type w
inst✝² : Group G
inst✝¹ : Fintype G
p n : ℕ
inst✝ : Fact (Nat.Prime p)
hdvd : p ^ n ∣ Fintype.card G
⊢ 1 = p ^ 0
Theorem: hammingDist_triangle
File: Mathlib/InformationTheory/Hamming.lean

tactic: classical
  unfold hammingDist
  refine le_trans (card_mono ?_) (card_union_le _ _)
  rw [← filter_or]
  exact monotone_filter_right _ fun i h ↦ (h.ne_or_ne _).imp_right Ne.symm
state_before: α : Type ?u.3412
ι : Type u_1
β : ι → Type u_2
inst✝² : Fintype ι
inst✝¹ : (i : ι) → DecidableEq (β i)
γ : ι → Type ?u.3444
inst✝ : (i : ι) → DecidableEq (γ i)
x y z : (i : ι) → β i
⊢ hammingDist x z ≤ hammingDist x y + hammingDist y z

tactic: unfold hammingDist
state_before: α : Type ?u.3412
ι : Type u_1
β : ι → Type u_2
inst✝² : Fintype ι
inst✝¹ : (i : ι) → DecidableEq (β i)
γ : ι → Type ?u.3444
inst✝ : (i : ι) → DecidableEq (γ i)
x y z : (i : ι) → β i
⊢ hammingDist x z ≤ hammingDist x y + hammingDist y z

tactic: refine le_trans (card_mono ?_) (card_union_le _ _)
state_before: α : Type ?u.3412
ι : Type u_1
β : ι → Type u_2
inst✝² : Fintype ι
inst✝¹ : (i : ι) → DecidableEq (β i)
γ : ι → Type ?u.3444
inst✝ : (i : ι) → DecidableEq (γ i)
x y z : (i : ι) → β i
⊢ card (filter (fun i => x i ≠ z i) univ) ≤
    card (filter (fun i => x i ≠ y i) univ) + card (filter (fun i => y i ≠ z i) univ)

tactic: rw [← filter_or]
state_before: α : Type ?u.3412
ι : Type u_1
β : ι → Type u_2
inst✝² : Fintype ι
inst✝¹ : (i : ι) → DecidableEq (β i)
γ : ι → Type ?u.3444
inst✝ : (i : ι) → DecidableEq (γ i)
x y z : (i : ι) → β i
⊢ filter (fun i => x i ≠ z i) univ ≤ filter (fun i => x i ≠ y i) univ ∪ filter (fun i => y i ≠ z i) univ

tactic: exact monotone_filter_right _ fun i h ↦ (h.ne_or_ne _).imp_right Ne.symm
state_before: α : Type ?u.3412
ι : Type u_1
β : ι → Type u_2
inst✝² : Fintype ι
inst✝¹ : (i : ι) → DecidableEq (β i)
γ : ι → Type ?u.3444
inst✝ : (i : ι) → DecidableEq (γ i)
x y z : (i : ι) → β i
⊢ filter (fun i => x i ≠ z i) univ ≤ filter (fun a => x a ≠ y a ∨ y a ≠ z a) univ
Theorem: AffineIsometryEquiv.vadd_vsub
File: Mathlib/Analysis/NormedSpace/AffineIsometry.lean

tactic: convert (vaddConst 𝕜 (f p)).symm.isometry.comp (hf.comp (vaddConst 𝕜 p).isometry)
state_before: 𝕜 : Type ?u.1931289
V : Type u_4
V₁ : Type ?u.1931295
V₂ : Type u_3
V₃ : Type ?u.1931301
V₄ : Type ?u.1931304
P₁ : Type ?u.1931307
P : Type u_1
P₂ : Type u_2
P₃ : Type ?u.1931316
P₄ : Type ?u.1931319
inst✝²¹ : NormedField 𝕜
inst✝²⁰ : SeminormedAddCommGroup V
inst✝¹⁹ : SeminormedAddCommGroup V₁
inst✝¹⁸ : SeminormedAddCommGroup V₂
inst✝¹⁷ : SeminormedAddCommGroup V₃
inst✝¹⁶ : SeminormedAddCommGroup V₄
inst✝¹⁵ : NormedSpace 𝕜 V
inst✝¹⁴ : NormedSpace 𝕜 V₁
inst✝¹³ : NormedSpace 𝕜 V₂
inst✝¹² : NormedSpace 𝕜 V₃
inst✝¹¹ : NormedSpace 𝕜 V₄
inst✝¹⁰ : PseudoMetricSpace P
inst✝⁹ : MetricSpace P₁
inst✝⁸ : PseudoMetricSpace P₂
inst✝⁷ : PseudoMetricSpace P₃
inst✝⁶ : PseudoMetricSpace P₄
inst✝⁵ : NormedAddTorsor V P
inst✝⁴ : NormedAddTorsor V₁ P₁
inst✝³ : NormedAddTorsor V₂ P₂
inst✝² : NormedAddTorsor V₃ P₃
inst✝¹ : NormedAddTorsor V₄ P₄
e : P ≃ᵃⁱ[𝕜] P₂
α : Type ?u.1931843
inst✝ : TopologicalSpace α
f : P → P₂
hf : Isometry f
p : P
g : V → V₂
hg : ∀ (v : V), g v = f (v +ᵥ p) -ᵥ f p
⊢ Isometry g

tactic: exact funext hg
state_before: case h.e'_5
𝕜 : Type ?u.1931289
V : Type u_4
V₁ : Type ?u.1931295
V₂ : Type u_3
V₃ : Type ?u.1931301
V₄ : Type ?u.1931304
P₁ : Type ?u.1931307
P : Type u_1
P₂ : Type u_2
P₃ : Type ?u.1931316
P₄ : Type ?u.1931319
inst✝²¹ : NormedField 𝕜
inst✝²⁰ : SeminormedAddCommGroup V
inst✝¹⁹ : SeminormedAddCommGroup V₁
inst✝¹⁸ : SeminormedAddCommGroup V₂
inst✝¹⁷ : SeminormedAddCommGroup V₃
inst✝¹⁶ : SeminormedAddCommGroup V₄
inst✝¹⁵ : NormedSpace 𝕜 V
inst✝¹⁴ : NormedSpace 𝕜 V₁
inst✝¹³ : NormedSpace 𝕜 V₂
inst✝¹² : NormedSpace 𝕜 V₃
inst✝¹¹ : NormedSpace 𝕜 V₄
inst✝¹⁰ : PseudoMetricSpace P
inst✝⁹ : MetricSpace P₁
inst✝⁸ : PseudoMetricSpace P₂
inst✝⁷ : PseudoMetricSpace P₃
inst✝⁶ : PseudoMetricSpace P₄
inst✝⁵ : NormedAddTorsor V P
inst✝⁴ : NormedAddTorsor V₁ P₁
inst✝³ : NormedAddTorsor V₂ P₂
inst✝² : NormedAddTorsor V₃ P₃
inst✝¹ : NormedAddTorsor V₄ P₄
e : P ≃ᵃⁱ[𝕜] P₂
α : Type ?u.1931843
inst✝ : TopologicalSpace α
f : P → P₂
hf : Isometry f
p : P
g : V → V₂
hg : ∀ (v : V), g v = f (v +ᵥ p) -ᵥ f p
⊢ g = ↑(symm (vaddConst 𝕜 (f p))) ∘ f ∘ ↑(vaddConst 𝕜 p)
Theorem: MeasureTheory.withDensityᵥ_sub
File: Mathlib/MeasureTheory/Measure/WithDensityVectorMeasure.lean

tactic: rw [sub_eq_add_neg, sub_eq_add_neg, withDensityᵥ_add hf hg.neg, withDensityᵥ_neg]
state_before: α : Type u_2
β : Type ?u.37787
m : MeasurableSpace α
μ ν : Measure α
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
f g : α → E
hf : Integrable f
hg : Integrable g
⊢ withDensityᵥ μ (f - g) = withDensityᵥ μ f - withDensityᵥ μ g
Theorem: Irrational.sub_int
File: Mathlib/Data/Real/Irrational.lean

tactic: simpa only [Rat.cast_coe_int] using h.sub_rat m
state_before: q : ℚ
x y : ℝ
h : Irrational x
m : ℤ
⊢ Irrational (x - ↑m)
Theorem: Cubic.natDegree_of_b_ne_zero
File: Mathlib/Algebra/CubicDiscriminant.lean

tactic: rw [of_a_eq_zero ha, natDegree_quadratic hb]
state_before: R : Type u_1
S : Type ?u.589386
F : Type ?u.589389
K : Type ?u.589392
P Q : Cubic R
a b c d a' b' c' d' : R
inst✝ : Semiring R
ha : P.a = 0
hb : P.b ≠ 0
⊢ natDegree (toPoly P) = 2
Theorem: MeasureTheory.memℒp_indicator_iff_restrict
File: Mathlib/MeasureTheory/Function/LpSpace.lean

tactic: simp [Memℒp, aestronglyMeasurable_indicator_iff hs, snorm_indicator_eq_snorm_restrict hs]
state_before: α : Type u_1
E : Type u_2
F : Type ?u.663273
G : Type ?u.663276
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
s : Set α
hs✝ : MeasurableSet s
c : E
f : α → E
hf : AEStronglyMeasurable f μ
hs : MeasurableSet s
⊢ Memℒp (Set.indicator s f) p ↔ Memℒp f p
Theorem: MeasureTheory.IsFundamentalDomain.set_lintegral_eq_tsum
File: Mathlib/MeasureTheory/Group/FundamentalDomain.lean

tactic: simp only [h.restrict_restrict, inter_comm]
state_before: G : Type u_1
H : Type ?u.196846
α : Type u_2
β : Type ?u.196852
E : Type ?u.196855
inst✝¹⁰ : Group G
inst✝⁹ : Group H
inst✝⁸ : MulAction G α
inst✝⁷ : MeasurableSpace α
inst✝⁶ : MulAction H β
inst✝⁵ : MeasurableSpace β
inst✝⁴ : NormedAddCommGroup E
s t✝ : Set α
μ : Measure α
inst✝³ : MeasurableSpace G
inst✝² : MeasurableSMul G α
inst✝¹ : SMulInvariantMeasure G α μ
inst✝ : Countable G
ν : Measure α
h : IsFundamentalDomain G s
f : α → ℝ≥0∞
t : Set α
⊢ (∑' (g : G), ∫⁻ (x : α) in g • s, f x ∂Measure.restrict μ t) = ∑' (g : G), ∫⁻ (x : α) in t ∩ g • s, f x ∂μ
Theorem: div_div_eq_mul_div
File: Mathlib/Algebra/Group/Basic.lean

tactic: simp
state_before: α : Type u_1
β : Type ?u.27922
G : Type ?u.27925
inst✝ : DivisionMonoid α
a b c : α
⊢ a / (b / c) = a * c / b
Theorem: pathConnectedSpace_iff_eq
File: Mathlib/Topology/PathConnected.lean

tactic: simp [pathConnectedSpace_iff_univ, isPathConnected_iff_eq]
state_before: X : Type u_1
Y : Type ?u.692142
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z : X
ι : Type ?u.692157
F : Set X
⊢ PathConnectedSpace X ↔ ∃ x, pathComponent x = univ
Theorem: NNReal.finset_sup_div
File: Mathlib/Data/Real/NNReal.lean

tactic: simp only [div_eq_inv_mul, mul_finset_sup]
state_before: α : Type u_1
f : α → ℝ≥0
s : Finset α
r : ℝ≥0
⊢ Finset.sup s f / r = Finset.sup s fun a => f a / r
Theorem: openSegment_eq_image₂
File: Mathlib/Analysis/Convex/Segment.lean

tactic: simp only [openSegment, image, Prod.exists, mem_setOf_eq, exists_prop, and_assoc]
state_before: 𝕜 : Type u_2
E : Type u_1
F : Type ?u.15748
G : Type ?u.15751
ι : Type ?u.15754
π : ι → Type ?u.15759
inst✝² : OrderedSemiring 𝕜
inst✝¹ : AddCommMonoid E
inst✝ : SMul 𝕜 E
s : Set E
x✝ y✝ x y : E
⊢ openSegment 𝕜 x y = (fun p => p.fst • x + p.snd • y) '' {p | 0 < p.fst ∧ 0 < p.snd ∧ p.fst + p.snd = 1}
Theorem: Matrix.adjugate_mul
File: Mathlib/LinearAlgebra/Matrix/Adjugate.lean

tactic: rw [← adjugate_transpose, ← transpose_mul, transpose_transpose]
state_before: m : Type u
n : Type v
α : Type w
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
inst✝ : CommRing α
A : Matrix n n α
⊢ adjugate A ⬝ A = (Aᵀ ⬝ adjugate Aᵀ)ᵀ

tactic: rw [mul_adjugate Aᵀ, det_transpose, transpose_smul, transpose_one]
state_before: m : Type u
n : Type v
α : Type w
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
inst✝ : CommRing α
A : Matrix n n α
⊢ (Aᵀ ⬝ adjugate Aᵀ)ᵀ = det A • 1
Theorem: LinearMap.isAdjointPair_zero
File: Mathlib/LinearAlgebra/SesquilinearForm.lean

tactic: simp only [zero_apply, map_zero]
state_before: R : Type u_1
R₁ : Type ?u.296180
R₂ : Type ?u.296183
R₃ : Type ?u.296186
M : Type u_2
M₁ : Type u_3
M₂ : Type ?u.296195
Mₗ₁ : Type ?u.296198
Mₗ₁' : Type ?u.296201
Mₗ₂ : Type ?u.296204
Mₗ₂' : Type ?u.296207
K : Type ?u.296210
K₁ : Type ?u.296213
K₂ : Type ?u.296216
V : Type ?u.296219
V₁ : Type ?u.296222
V₂ : Type ?u.296225
n : Type ?u.296228
inst✝⁶ : CommSemiring R
inst✝⁵ : AddCommMonoid M
inst✝⁴ : Module R M
inst✝³ : AddCommMonoid M₁
inst✝² : Module R M₁
inst✝¹ : AddCommMonoid M₂
inst✝ : Module R M₂
I : R →+* R
B F : M →ₗ[R] M →ₛₗ[I] R
B' : M₁ →ₗ[R] M₁ →ₛₗ[I] R
B'' : M₂ →ₗ[R] M₂ →ₛₗ[I] R
f f' : M →ₗ[R] M₁
g g' : M₁ →ₗ[R] M
x✝¹ : M
x✝ : M₁
⊢ ↑(↑B' (↑0 x✝¹)) x✝ = ↑(↑B x✝¹) (↑0 x✝)
Theorem: DiscreteValuationRing.exists_irreducible
File: Mathlib/RingTheory/DiscreteValuationRing/Basic.lean

tactic: simp_rw [irreducible_iff_uniformizer]
state_before: R : Type u
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : DiscreteValuationRing R
⊢ ∃ ϖ, Irreducible ϖ

tactic: exact (IsPrincipalIdealRing.principal <| maximalIdeal R).principal
state_before: R : Type u
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : DiscreteValuationRing R
⊢ ∃ ϖ, maximalIdeal R = span {ϖ}