tasksource/leandojo huggingface dataset:
Theorem: uniformGroup_inf
File: Mathlib/Topology/Algebra/UniformGroup.lean

tactic: rw [inf_eq_iInf]
state_before: α : Type ?u.119171
β : Type u_1
inst✝³ : UniformSpace α
inst✝² : Group α
inst✝¹ : UniformGroup α
inst✝ : Group β
u₁ u₂ : UniformSpace β
h₁ : UniformGroup β
h₂ : UniformGroup β
⊢ UniformGroup β

tactic: refine' uniformGroup_iInf fun b => _
state_before: α : Type ?u.119171
β : Type u_1
inst✝³ : UniformSpace α
inst✝² : Group α
inst✝¹ : UniformGroup α
inst✝ : Group β
u₁ u₂ : UniformSpace β
h₁ : UniformGroup β
h₂ : UniformGroup β
⊢ UniformGroup β

tactic: cases b <;> assumption
state_before: α : Type ?u.119171
β : Type u_1
inst✝³ : UniformSpace α
inst✝² : Group α
inst✝¹ : UniformGroup α
inst✝ : Group β
u₁ u₂ : UniformSpace β
h₁ : UniformGroup β
h₂ : UniformGroup β
b : Bool
⊢ UniformGroup β
Theorem: Cardinal.mk_bool
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: simp
state_before: α β : Type u
⊢ (#Bool) = 2
Theorem: Set.prod_univ
File: Mathlib/Data/Set/Prod.lean

tactic: simp [prod_eq]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.7813
δ : Type ?u.7816
s✝ s₁ s₂ : Set α
t t₁ t₂ : Set β
a : α
b : β
s : Set α
⊢ s ×ˢ univ = Prod.fst ⁻¹' s
Theorem: Multiset.measurable_prod
File: Mathlib/MeasureTheory/Group/Arithmetic.lean

tactic: simpa only [← Pi.multiset_prod_apply] using s.measurable_prod' hs
state_before: M : Type u_1
ι : Type ?u.4458135
α : Type u_2
inst✝² : CommMonoid M
inst✝¹ : MeasurableSpace M
inst✝ : MeasurableMul₂ M
m : MeasurableSpace α
μ : MeasureTheory.Measure α
f : ι → α → M
s : Multiset (α → M)
hs : ∀ (f : α → M), f ∈ s → Measurable f
⊢ Measurable fun x => prod (map (fun f => f x) s)
Theorem: Set.ncard_subtype
File: Mathlib/Data/Set/Ncard.lean

tactic: convert (ncard_image_ofInjective _ (@Subtype.coe_injective _ P)).symm
state_before: α : Type u_1
β : Type ?u.42313
s✝ t : Set α
a b x y : α
f : α → β
P : α → Prop
s : Set α
⊢ ncard {x | ↑x ∈ s} = ncard (s ∩ setOf P)

tactic: ext x
state_before: case h.e'_3.h.e'_2
α : Type u_1
β : Type ?u.42313
s✝ t : Set α
a b x y : α
f : α → β
P : α → Prop
s : Set α
⊢ s ∩ setOf P = (fun a => ↑a) '' {x | ↑x ∈ s}

tactic: simp [←and_assoc, exists_eq_right]
state_before: case h.e'_3.h.e'_2.h
α : Type u_1
β : Type ?u.42313
s✝ t : Set α
a b x✝ y : α
f : α → β
P : α → Prop
s : Set α
x : α
⊢ x ∈ s ∩ setOf P ↔ x ∈ (fun a => ↑a) '' {x | ↑x ∈ s}
Theorem: EuclideanGeometry.angle_eq_right
File: Mathlib/Geometry/Euclidean/Angle/Unoriented/Affine.lean

tactic: rw [angle_comm, angle_eq_left]
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p1 p2 : P
⊢ ∠ p1 p2 p2 = π / 2
Theorem: Pi.lex_lt_of_lt
File: Mathlib/Data/Pi/Lex.lean

tactic: simp_rw [Pi.Lex, le_antisymm_iff]
state_before: ι : Type u_2
β : ι → Type u_1
r✝ : ι → ι → Prop
s : {i : ι} → β i → β i → Prop
inst✝ : (i : ι) → PartialOrder (β i)
r : ι → ι → Prop
hwf : WellFounded r
x y : (i : ι) → β i
hlt : x < y
⊢ Pi.Lex r (fun i x x_1 => x < x_1) x y

tactic: exact lex_lt_of_lt_of_preorder hwf hlt
state_before: ι : Type u_2
β : ι → Type u_1
r✝ : ι → ι → Prop
s : {i : ι} → β i → β i → Prop
inst✝ : (i : ι) → PartialOrder (β i)
r : ι → ι → Prop
hwf : WellFounded r
x y : (i : ι) → β i
hlt : x < y
⊢ ∃ i, (∀ (j : ι), r j i → x j ≤ y j ∧ y j ≤ x j) ∧ x i < y i
Theorem: Nat.bit_eq_zero_iff
File: Mathlib/Data/Nat/Bits.lean

tactic: constructor
state_before: n✝ n : ℕ
b : Bool
⊢ bit b n = 0 ↔ n = 0 ∧ b = false

tactic: cases b <;> simp [Nat.bit, Nat.bit0_eq_zero, Nat.bit1_ne_zero]
state_before: case mp
n✝ n : ℕ
b : Bool
⊢ bit b n = 0 → n = 0 ∧ b = false

tactic: rintro ⟨rfl, rfl⟩
state_before: case mpr
n✝ n : ℕ
b : Bool
⊢ n = 0 ∧ b = false → bit b n = 0

tactic: rfl
state_before: case mpr.intro
n : ℕ
⊢ bit false 0 = 0
Theorem: Ico_ofDual
File: Mathlib/Order/LocallyFinite.lean

tactic: refine' Eq.trans _ map_refl.symm
state_before: α : Type u_1
β : Type ?u.114883
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : LocallyFiniteOrder α
a✝ b✝ : α
a b : αᵒᵈ
⊢ Ico (↑ofDual a) (↑ofDual b) = map (Equiv.toEmbedding ofDual) (Ioc b a)

tactic: ext c
state_before: α : Type u_1
β : Type ?u.114883
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : LocallyFiniteOrder α
a✝ b✝ : α
a b : αᵒᵈ
⊢ Ico (↑ofDual a) (↑ofDual b) = Ioc b a

tactic: rw [mem_Ico, mem_Ioc (α := αᵒᵈ)]
state_before: case a
α : Type u_1
β : Type ?u.114883
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : LocallyFiniteOrder α
a✝ b✝ : α
a b : αᵒᵈ
c : (fun x => α) a
⊢ c ∈ Ico (↑ofDual a) (↑ofDual b) ↔ c ∈ Ioc b a

tactic: exact and_comm
state_before: case a
α : Type u_1
β : Type ?u.114883
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : LocallyFiniteOrder α
a✝ b✝ : α
a b : αᵒᵈ
c : (fun x => α) a
⊢ ↑ofDual a ≤ c ∧ c < ↑ofDual b ↔ b < c ∧ c ≤ a
Theorem: Filter.map_const
File: Mathlib/Order/Filter/Basic.lean

tactic: ext s
state_before: α : Type u
β : Type v
γ : Type w
δ : Type ?u.244483
ι : Sort x
f f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m : α → β
m' : β → γ
s : Set α
t : Set β
inst✝ : NeBot f
c : β
⊢ map (fun x => c) f = pure c

tactic: by_cases h : c ∈ s <;> simp [h]
state_before: case a
α : Type u
β : Type v
γ : Type w
δ : Type ?u.244483
ι : Sort x
f f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m : α → β
m' : β → γ
s✝ : Set α
t : Set β
inst✝ : NeBot f
c : β
s : Set β
⊢ s ∈ map (fun x => c) f ↔ s ∈ pure c
Theorem: LocallyBoundedMap.cancel_left
File: Mathlib/Topology/Bornology/Hom.lean

tactic: rw [← comp_apply, h, comp_apply]
state_before: F : Type ?u.9512
α : Type u_3
β : Type u_1
γ : Type u_2
δ : Type ?u.9524
inst✝³ : Bornology α
inst✝² : Bornology β
inst✝¹ : Bornology γ
inst✝ : Bornology δ
g : LocallyBoundedMap β γ
f₁ f₂ : LocallyBoundedMap α β
hg : Injective ↑g
h : comp g f₁ = comp g f₂
a : α
⊢ ↑g (↑f₁ a) = ↑g (↑f₂ a)
Theorem: Turing.Tape.move_right_n_head
File: Mathlib/Computability/TuringMachine.lean

tactic: induction i generalizing T
state_before: Γ : Type u_1
inst✝ : Inhabited Γ
T : Tape Γ
i : ℕ
⊢ ((move Dir.right^[i]) T).head = nth T ↑i

tactic: rfl
state_before: case zero
Γ : Type u_1
inst✝ : Inhabited Γ
T : Tape Γ
⊢ ((move Dir.right^[Nat.zero]) T).head = nth T ↑Nat.zero

tactic: simp only [*, Tape.move_right_nth, Int.ofNat_succ, iterate_succ, Function.comp_apply]
state_before: case succ
Γ : Type u_1
inst✝ : Inhabited Γ
n✝ : ℕ
n_ih✝ : ∀ (T : Tape Γ), ((move Dir.right^[n✝]) T).head = nth T ↑n✝
T : Tape Γ
⊢ ((move Dir.right^[Nat.succ n✝]) T).head = nth T ↑(Nat.succ n✝)
Theorem: Dfinsupp.liftAddHom_apply_single
File: Mathlib/Data/Dfinsupp/Basic.lean

tactic: simp
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝¹ : (i : ι) → AddZeroClass (β i)
inst✝ : AddCommMonoid γ
f : (i : ι) → β i →+ γ
i : ι
x : β i
⊢ ↑(↑liftAddHom f) (single i x) = ↑(f i) x
Theorem: iUnion_Ico_int_cast
File: Mathlib/Algebra/Order/ToIntervalMod.lean

tactic: simpa only [zero_add] using iUnion_Ico_add_int_cast (0 : α)
state_before: α : Type u_1
inst✝¹ : LinearOrderedRing α
inst✝ : Archimedean α
a : α
⊢ (⋃ (n : ℤ), Ico (↑n) (↑n + 1)) = univ
Theorem: Stream'.WSeq.tail_nil
File: Mathlib/Data/Seq/WSeq.lean

tactic: simp [tail]
state_before: α : Type u
β : Type v
γ : Type w
⊢ tail nil = nil
Theorem: ContDiffWithinAt.sub
File: Mathlib/Analysis/Calculus/ContDiff.lean

tactic: simpa only [sub_eq_add_neg] using hf.add hg.neg
state_before: 𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type ?u.1842691
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s✝ s₁ t u : Set E
f✝ f₁ : E → F
g✝ : F → G
x x₀ : E
c : F
b : E × F → G
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
s : Set E
f g : E → F
hf : ContDiffWithinAt 𝕜 n f s x
hg : ContDiffWithinAt 𝕜 n g s x
⊢ ContDiffWithinAt 𝕜 n (fun x => f x - g x) s x
Theorem: Nat.minFac_le_of_dvd
File: Mathlib/Data/Nat/Prime.lean

tactic: by_cases n1 : n = 1 <;> [exact fun m2 _ => n1.symm ▸ le_trans (by decide) m2;
  apply (minFac_has_prop n1).2.2]
state_before: n : ℕ
⊢ ∀ {m : ℕ}, 2 ≤ m → m ∣ n → minFac n ≤ m

tactic: decide
state_before: n m✝ : ℕ
n1 : n = 1
m2 : 2 ≤ m✝
x✝ : m✝ ∣ n
⊢ minFac 1 ≤ 2
Theorem: Complex.liftAux_apply_I
File: Mathlib/Data/Complex/Module.lean

tactic: simp
state_before: A : Type u_1
inst✝¹ : Ring A
inst✝ : Algebra ℝ A
I' : A
hI' : I' * I' = -1
⊢ ↑(liftAux I' hI') I = I'
Theorem: IsOpen.mul_right
File: Mathlib/Topology/Algebra/Group/Basic.lean

tactic: rw [← iUnion_op_smul_set]
state_before: α : Type u
β : Type v
G : Type w
H : Type x
inst✝² : TopologicalSpace α
inst✝¹ : Group α
inst✝ : ContinuousConstSMul αᵐᵒᵖ α
s t : Set α
hs : IsOpen s
⊢ IsOpen (s * t)

tactic: exact isOpen_biUnion fun a _ => hs.smul _
state_before: α : Type u
β : Type v
G : Type w
H : Type x
inst✝² : TopologicalSpace α
inst✝¹ : Group α
inst✝ : ContinuousConstSMul αᵐᵒᵖ α
s t : Set α
hs : IsOpen s
⊢ IsOpen (⋃ (a : α) (_ : a ∈ t), MulOpposite.op a • s)
Theorem: ENNReal.smul_iSup
File: Mathlib/Topology/Instances/ENNReal.lean

tactic: simp only [← smul_one_mul c (f _), ← smul_one_mul c (iSup f), ENNReal.mul_iSup]
state_before: α : Type ?u.156923
β : Type ?u.156926
γ : Type ?u.156929
a b c✝ d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
ι : Sort u_1
R : Type u_2
inst✝¹ : SMul R ℝ≥0∞
inst✝ : IsScalarTower R ℝ≥0∞ ℝ≥0∞
f : ι → ℝ≥0∞
c : R
⊢ (c • ⨆ (i : ι), f i) = ⨆ (i : ι), c • f i
Theorem: MvPolynomial.map_bind₁
File: Mathlib/Data/MvPolynomial/Monad.lean

tactic: rw [hom_bind₁, map_comp_C, ← eval₂Hom_map_hom]
state_before: σ : Type u_4
τ : Type u_3
R : Type u_1
S : Type u_2
T : Type ?u.836499
inst✝² : CommSemiring R
inst✝¹ : CommSemiring S
inst✝ : CommSemiring T
f✝ : σ → MvPolynomial τ R
f : R →+* S
g : σ → MvPolynomial τ R
φ : MvPolynomial σ R
⊢ ↑(map f) (↑(bind₁ g) φ) = ↑(bind₁ fun i => ↑(map f) (g i)) (↑(map f) φ)

tactic: rfl
state_before: σ : Type u_4
τ : Type u_3
R : Type u_1
S : Type u_2
T : Type ?u.836499
inst✝² : CommSemiring R
inst✝¹ : CommSemiring S
inst✝ : CommSemiring T
f✝ : σ → MvPolynomial τ R
f : R →+* S
g : σ → MvPolynomial τ R
φ : MvPolynomial σ R
⊢ ↑(eval₂Hom C fun i => ↑(map f) (g i)) (↑(map f) φ) = ↑(bind₁ fun i => ↑(map f) (g i)) (↑(map f) φ)
Theorem: Multiset.cons_add
File: Mathlib/Data/Multiset/Basic.lean

tactic: rw [← singleton_add, ← singleton_add, add_assoc]
state_before: α : Type u_1
β : Type ?u.44964
γ : Type ?u.44967
a : α
s t : Multiset α
⊢ a ::ₘ s + t = a ::ₘ (s + t)
Theorem: EuclideanDomain.xgcdAux_rec
File: Mathlib/Algebra/EuclideanDomain/Defs.lean

tactic: conv =>
  lhs
  rw [xgcdAux]
state_before: R : Type u
inst✝¹ : EuclideanDomain R
inst✝ : DecidableEq R
r s t r' s' t' : R
h : r ≠ 0
⊢ xgcdAux r s t r' s' t' = xgcdAux (r' % r) (s' - r' / r * s) (t' - r' / r * t) r s t

tactic: exact if_neg h
state_before: R : Type u
inst✝¹ : EuclideanDomain R
inst✝ : DecidableEq R
r s t r' s' t' : R
h : r ≠ 0
⊢ (fun s t r' s' t' =>
        if _hr : r = 0 then (r', s', t')
        else
          let q := r' / r;
          xgcdAux (r' % r) (s' - q * s) (t' - q * t) r s t)
      s t r' s' t' =
    xgcdAux (r' % r) (s' - r' / r * s) (t' - r' / r * t) r s t
Theorem: IsUnit.div_mul_left
File: Mathlib/Algebra/Hom/Units.lean

tactic: rw [div_eq_mul_inv, mul_inv_rev, h.mul_inv_cancel_left, one_div]
state_before: F : Type ?u.59663
G : Type ?u.59666
α : Type u_1
M : Type ?u.59672
N : Type ?u.59675
inst✝ : DivisionMonoid α
a b c : α
h : IsUnit b
⊢ b / (a * b) = 1 / a
Theorem: FirstOrder.Language.Term.realize_constantsVarsEquivLeft
File: Mathlib/ModelTheory/Semantics.lean

tactic: simp only [constantsVarsEquivLeft, realize_relabel, Equiv.coe_trans, Function.comp_apply,
  constantsVarsEquiv_apply, relabelEquiv_symm_apply]
state_before: L : Language
L' : Language
M : Type w
N : Type ?u.22479
P : Type ?u.22482
inst✝⁴ : Structure L M
inst✝³ : Structure L N
inst✝² : Structure L P
α : Type u'
β : Type v'
inst✝¹ : Structure (L[[α]]) M
inst✝ : LHom.IsExpansionOn (lhomWithConstants L α) M
n : ℕ
t : Term (L[[α]]) (β ⊕ Fin n)
v : β → M
xs : Fin n → M
⊢ realize (Sum.elim (Sum.elim (fun a => ↑(Language.con L a)) v) xs) (↑constantsVarsEquivLeft t) =
    realize (Sum.elim v xs) t

tactic: refine' _root_.trans _ realize_constantsToVars
state_before: L : Language
L' : Language
M : Type w
N : Type ?u.22479
P : Type ?u.22482
inst✝⁴ : Structure L M
inst✝³ : Structure L N
inst✝² : Structure L P
α : Type u'
β : Type v'
inst✝¹ : Structure (L[[α]]) M
inst✝ : LHom.IsExpansionOn (lhomWithConstants L α) M
n : ℕ
t : Term (L[[α]]) (β ⊕ Fin n)
v : β → M
xs : Fin n → M
⊢ realize (Sum.elim (Sum.elim (fun a => ↑(Language.con L a)) v) xs ∘ ↑(Equiv.sumAssoc α β (Fin n)).symm)
      (constantsToVars t) =
    realize (Sum.elim v xs) t

tactic: rcongr x
state_before: L : Language
L' : Language
M : Type w
N : Type ?u.22479
P : Type ?u.22482
inst✝⁴ : Structure L M
inst✝³ : Structure L N
inst✝² : Structure L P
α : Type u'
β : Type v'
inst✝¹ : Structure (L[[α]]) M
inst✝ : LHom.IsExpansionOn (lhomWithConstants L α) M
n : ℕ
t : Term (L[[α]]) (β ⊕ Fin n)
v : β → M
xs : Fin n → M
⊢ realize (Sum.elim (Sum.elim (fun a => ↑(Language.con L a)) v) xs ∘ ↑(Equiv.sumAssoc α β (Fin n)).symm)
      (constantsToVars t) =
    realize (Sum.elim (fun a => ↑(Language.con L a)) (Sum.elim v xs)) (constantsToVars t)

tactic: rcases x with (a | (b | i)) <;> simp
state_before: case e_v.h
L : Language
L' : Language
M : Type w
N : Type ?u.22479
P : Type ?u.22482
inst✝⁴ : Structure L M
inst✝³ : Structure L N
inst✝² : Structure L P
α : Type u'
β : Type v'
inst✝¹ : Structure (L[[α]]) M
inst✝ : LHom.IsExpansionOn (lhomWithConstants L α) M
n : ℕ
t : Term (L[[α]]) (β ⊕ Fin n)
v : β → M
xs : Fin n → M
x : α ⊕ β ⊕ Fin n
⊢ (Sum.elim (Sum.elim (fun a => ↑(Language.con L a)) v) xs ∘ ↑(Equiv.sumAssoc α β (Fin n)).symm) x =
    Sum.elim (fun a => ↑(Language.con L a)) (Sum.elim v xs) x
Theorem: ENNReal.ofReal_rpow_of_nonneg
File: Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean

tactic: by_cases hp0 : p = 0
state_before: x p : ℝ
hx_nonneg : 0 ≤ x
hp_nonneg : 0 ≤ p
⊢ ENNReal.ofReal x ^ p = ENNReal.ofReal (x ^ p)

tactic: by_cases hx0 : x = 0
state_before: case neg
x p : ℝ
hx_nonneg : 0 ≤ x
hp_nonneg : 0 ≤ p
hp0 : ¬p = 0
⊢ ENNReal.ofReal x ^ p = ENNReal.ofReal (x ^ p)

tactic: rw [← Ne.def] at hx0
state_before: case neg
x p : ℝ
hx_nonneg : 0 ≤ x
hp_nonneg : 0 ≤ p
hp0 : ¬p = 0
hx0 : ¬x = 0
⊢ ENNReal.ofReal x ^ p = ENNReal.ofReal (x ^ p)

tactic: exact ofReal_rpow_of_pos (hx_nonneg.lt_of_ne hx0.symm)
state_before: case neg
x p : ℝ
hx_nonneg : 0 ≤ x
hp_nonneg : 0 ≤ p
hp0 : ¬p = 0
hx0 : x ≠ 0
⊢ ENNReal.ofReal x ^ p = ENNReal.ofReal (x ^ p)

tactic: simp [hp0]
state_before: case pos
x p : ℝ
hx_nonneg : 0 ≤ x
hp_nonneg : 0 ≤ p
hp0 : p = 0
⊢ ENNReal.ofReal x ^ p = ENNReal.ofReal (x ^ p)

tactic: rw [← Ne.def] at hp0
state_before: case pos
x p : ℝ
hx_nonneg : 0 ≤ x
hp_nonneg : 0 ≤ p
hp0 : ¬p = 0
hx0 : x = 0
⊢ ENNReal.ofReal x ^ p = ENNReal.ofReal (x ^ p)

tactic: have hp_pos : 0 < p := lt_of_le_of_ne hp_nonneg hp0.symm
state_before: case pos
x p : ℝ
hx_nonneg : 0 ≤ x
hp_nonneg : 0 ≤ p
hp0 : p ≠ 0
hx0 : x = 0
⊢ ENNReal.ofReal x ^ p = ENNReal.ofReal (x ^ p)

tactic: simp [hx0, hp_pos, hp_pos.ne.symm]
state_before: case pos
x p : ℝ
hx_nonneg : 0 ≤ x
hp_nonneg : 0 ≤ p
hp0 : p ≠ 0
hx0 : x = 0
hp_pos : 0 < p
⊢ ENNReal.ofReal x ^ p = ENNReal.ofReal (x ^ p)
Theorem: Real.vector_fourierIntegral_eq_integral_exp_smul
File: Mathlib/Analysis/Fourier/FourierTransform.lean

tactic: simp_rw [VectorFourier.fourierIntegral, Real.fourierChar_apply, mul_neg, neg_mul]
state_before: E : Type u_3
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : CompleteSpace E
inst✝⁵ : NormedSpace ℂ E
V : Type u_1
inst✝⁴ : AddCommGroup V
inst✝³ : Module ℝ V
inst✝² : MeasurableSpace V
W : Type u_2
inst✝¹ : AddCommGroup W
inst✝ : Module ℝ W
L : V →ₗ[ℝ] W →ₗ[ℝ] ℝ
μ : MeasureTheory.Measure V
f : V → E
w : W
⊢ VectorFourier.fourierIntegral fourierChar μ L f w =
    ∫ (v : V), Complex.exp (↑(-2 * π * ↑(↑L v) w) * Complex.I) • f v ∂μ
Theorem: Sym2.fromRel_irreflexive
File: Mathlib/Data/Sym/Sym2.lean

tactic: intro h
state_before: α : Type u_1
β : Type ?u.46398
γ : Type ?u.46401
r : α → α → Prop
sym : Symmetric r
⊢ Irreflexive r → ∀ {z : Sym2 α}, z ∈ fromRel sym → ¬IsDiag z

tactic: apply Sym2.ind
state_before: α : Type u_1
β : Type ?u.46398
γ : Type ?u.46401
r : α → α → Prop
sym : Symmetric r
h : Irreflexive r
⊢ ∀ {z : Sym2 α}, z ∈ fromRel sym → ¬IsDiag z

tactic: aesop
state_before: case h
α : Type u_1
β : Type ?u.46398
γ : Type ?u.46401
r : α → α → Prop
sym : Symmetric r
h : Irreflexive r
⊢ ∀ (x y : α), Quotient.mk (Rel.setoid α) (x, y) ∈ fromRel sym → ¬IsDiag (Quotient.mk (Rel.setoid α) (x, y))
Theorem: OrthonormalBasis.det_adjustToOrientation
File: Mathlib/Analysis/InnerProductSpace/Orientation.lean

tactic: simpa using e.toBasis.det_adjustToOrientation x
state_before: E : Type u_1
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace ℝ E
ι : Type u_2
inst✝¹ : Fintype ι
inst✝ : DecidableEq ι
ne : Nonempty ι
e f : OrthonormalBasis ι ℝ E
x : Orientation ℝ E ι
⊢ Basis.det (OrthonormalBasis.toBasis (adjustToOrientation e x)) = Basis.det (OrthonormalBasis.toBasis e) ∨
    Basis.det (OrthonormalBasis.toBasis (adjustToOrientation e x)) = -Basis.det (OrthonormalBasis.toBasis e)
Theorem: Finset.sym_nonempty
File: Mathlib/Data/Finset/Sym.lean

tactic: simp_rw [nonempty_iff_ne_empty, Ne.def]
state_before: α : Type u_1
inst✝ : DecidableEq α
s t : Finset α
a b : α
n : ℕ
m : Sym α n
⊢ Finset.Nonempty (Finset.sym s n) ↔ n = 0 ∨ Finset.Nonempty s

tactic: rwa [sym_eq_empty, not_and_or, not_ne_iff]
state_before: α : Type u_1
inst✝ : DecidableEq α
s t : Finset α
a b : α
n : ℕ
m : Sym α n
⊢ ¬Finset.sym s n = ∅ ↔ n = 0 ∨ ¬s = ∅
Theorem: IsROrC.add_conj
File: Mathlib/Data/IsROrC/Basic.lean

tactic: rw [re_add_im, conj_eq_re_sub_im]
state_before: K : Type u_1
E : Type ?u.3261129
inst✝ : IsROrC K
z : K
⊢ z + ↑(starRingEnd K) z = ↑(↑re z) + ↑(↑im z) * I + (↑(↑re z) - ↑(↑im z) * I)

tactic: rw [add_add_sub_cancel, two_mul]
state_before: K : Type u_1
E : Type ?u.3261129
inst✝ : IsROrC K
z : K
⊢ ↑(↑re z) + ↑(↑im z) * I + (↑(↑re z) - ↑(↑im z) * I) = 2 * ↑(↑re z)
Theorem: IsFractional.nsmul
File: Mathlib/RingTheory/FractionalIdeal.lean

tactic: rw [zero_smul]
state_before: R : Type u_1
inst✝² : CommRing R
S : Submonoid R
P : Type u_2
inst✝¹ : CommRing P
inst✝ : Algebra R P
loc : IsLocalization S P
I : Submodule R P
x✝ : IsFractional S I
⊢ IsFractional S (0 • I)

tactic: convert((0 : Ideal R) : FractionalIdeal S P).isFractional
state_before: R : Type u_1
inst✝² : CommRing R
S : Submonoid R
P : Type u_2
inst✝¹ : CommRing P
inst✝ : Algebra R P
loc : IsLocalization S P
I : Submodule R P
x✝ : IsFractional S I
⊢ IsFractional S 0

tactic: simp
state_before: case h.e'_7
R : Type u_1
inst✝² : CommRing R
S : Submonoid R
P : Type u_2
inst✝¹ : CommRing P
inst✝ : Algebra R P
loc : IsLocalization S P
I : Submodule R P
x✝ : IsFractional S I
⊢ 0 = ↑↑0

tactic: rw [succ_nsmul]
state_before: R : Type u_1
inst✝² : CommRing R
S : Submonoid R
P : Type u_2
inst✝¹ : CommRing P
inst✝ : Algebra R P
loc : IsLocalization S P
I : Submodule R P
n : ℕ
h : IsFractional S I
⊢ IsFractional S ((n + 1) • I)

tactic: exact h.sup (IsFractional.nsmul n h)
state_before: R : Type u_1
inst✝² : CommRing R
S : Submonoid R
P : Type u_2
inst✝¹ : CommRing P
inst✝ : Algebra R P
loc : IsLocalization S P
I : Submodule R P
n : ℕ
h : IsFractional S I
⊢ IsFractional S (I + n • I)
Theorem: LucasLehmer.X.ω_mul_ωb
File: Mathlib/NumberTheory/LucasLehmer.lean

tactic: dsimp [ω, ωb]
state_before: q✝ q : ℕ+
⊢ ω * ωb = 1

tactic: ext <;> simp
state_before: q✝ q : ℕ+
⊢ (2, 1) * (2, -1) = 1

tactic: ring
state_before: case h₁
q✝ q : ℕ+
⊢ 2 * 2 + -3 = 1
Theorem: Zsqrtd.coe_int_inj
File: Mathlib/NumberTheory/Zsqrtd/Basic.lean

tactic: simpa using congr_arg re h
state_before: d m n : ℤ
h : ↑m = ↑n
⊢ m = n
Theorem: SimpleGraph.adj_of_mem_incidenceSet
File: Mathlib/Combinatorics/SimpleGraph/Basic.lean

tactic: rwa [← mk'_mem_incidenceSet_left_iff, ←
  Set.mem_singleton_iff.1 <| G.incidenceSet_inter_incidenceSet_subset h ⟨ha, hb⟩]
state_before: ι : Sort ?u.101184
𝕜 : Type ?u.101187
V : Type u
W : Type v
X : Type w
G : SimpleGraph V
G' : SimpleGraph W
a b c u v w : V
e : Sym2 V
h : a ≠ b
ha : e ∈ incidenceSet G a
hb : e ∈ incidenceSet G b
⊢ Adj G a b
Theorem: zpow_induction_right
File: Mathlib/Algebra/GroupPower/Lemmas.lean

tactic: induction' n using Int.induction_on with n ih n ih
state_before: α : Type ?u.153793
M : Type u
N : Type v
G : Type w
H : Type x
A : Type y
B : Type z
R : Type u₁
S : Type u₂
inst✝ : Group G
g : G
P : G → Prop
h_one : P 1
h_mul : ∀ (a : G), P a → P (a * g)
h_inv : ∀ (a : G), P a → P (a * g⁻¹)
n : ℤ
⊢ P (g ^ n)

tactic: rwa [zpow_zero]
state_before: case hz
α : Type ?u.153793
M : Type u
N : Type v
G : Type w
H : Type x
A : Type y
B : Type z
R : Type u₁
S : Type u₂
inst✝ : Group G
g : G
P : G → Prop
h_one : P 1
h_mul : ∀ (a : G), P a → P (a * g)
h_inv : ∀ (a : G), P a → P (a * g⁻¹)
⊢ P (g ^ 0)

tactic: rw [zpow_add_one]
state_before: case hp
α : Type ?u.153793
M : Type u
N : Type v
G : Type w
H : Type x
A : Type y
B : Type z
R : Type u₁
S : Type u₂
inst✝ : Group G
g : G
P : G → Prop
h_one : P 1
h_mul : ∀ (a : G), P a → P (a * g)
h_inv : ∀ (a : G), P a → P (a * g⁻¹)
n : ℕ
ih : P (g ^ ↑n)
⊢ P (g ^ (↑n + 1))

tactic: exact h_mul _ ih
state_before: case hp
α : Type ?u.153793
M : Type u
N : Type v
G : Type w
H : Type x
A : Type y
B : Type z
R : Type u₁
S : Type u₂
inst✝ : Group G
g : G
P : G → Prop
h_one : P 1
h_mul : ∀ (a : G), P a → P (a * g)
h_inv : ∀ (a : G), P a → P (a * g⁻¹)
n : ℕ
ih : P (g ^ ↑n)
⊢ P (g ^ ↑n * g)

tactic: rw [zpow_sub_one]
state_before: case hn
α : Type ?u.153793
M : Type u
N : Type v
G : Type w
H : Type x
A : Type y
B : Type z
R : Type u₁
S : Type u₂
inst✝ : Group G
g : G
P : G → Prop
h_one : P 1
h_mul : ∀ (a : G), P a → P (a * g)
h_inv : ∀ (a : G), P a → P (a * g⁻¹)
n : ℕ
ih : P (g ^ (-↑n))
⊢ P (g ^ (-↑n - 1))

tactic: exact h_inv _ ih
state_before: case hn
α : Type ?u.153793
M : Type u
N : Type v
G : Type w
H : Type x
A : Type y
B : Type z
R : Type u₁
S : Type u₂
inst✝ : Group G
g : G
P : G → Prop
h_one : P 1
h_mul : ∀ (a : G), P a → P (a * g)
h_inv : ∀ (a : G), P a → P (a * g⁻¹)
n : ℕ
ih : P (g ^ (-↑n))
⊢ P (g ^ (-↑n) * g⁻¹)
Theorem: SeparationQuotient.isClosedMap_mk
File: Mathlib/Topology/Inseparable.lean

tactic: rw [range_mk]
state_before: X : Type u_1
Y : Type ?u.58987
Z : Type ?u.58990
α : Type ?u.58993
ι : Type ?u.58996
π : ι → Type ?u.59001
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : TopologicalSpace Z
inst✝ : (i : ι) → TopologicalSpace (π i)
x y z : X
s : Set X
f : X → Y
t : Set (SeparationQuotient X)
⊢ IsClosed (Set.range mk)

tactic: exact isClosed_univ
state_before: X : Type u_1
Y : Type ?u.58987
Z : Type ?u.58990
α : Type ?u.58993
ι : Type ?u.58996
π : ι → Type ?u.59001
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : TopologicalSpace Z
inst✝ : (i : ι) → TopologicalSpace (π i)
x y z : X
s : Set X
f : X → Y
t : Set (SeparationQuotient X)
⊢ IsClosed univ
Theorem: Submodule.map_unop_one
File: Mathlib/Algebra/Algebra/Operations.lean

tactic: rw [← comap_equiv_eq_map_symm, comap_op_one]
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
⊢ map (↑(LinearEquiv.symm (opLinearEquiv R))) 1 = 1
Theorem: List.ofFn_eq_map
File: Mathlib/Data/List/FinRange.lean

tactic: rw [← ofFn_id, map_ofFn, Function.right_id]
state_before: α✝ : Type u
α : Type u_1
n : ℕ
f : Fin n → α
⊢ ofFn f = map f (finRange n)