tasksource/leandojo huggingface dataset:
Theorem: RingSeminorm.seminorm_one_eq_one_iff_ne_zero
File: Mathlib/Analysis/Normed/Ring/Seminorm.lean

tactic: refine'
  ⟨fun h =>
    ne_zero_iff.mpr
      ⟨1, by
        rw [h]
        exact one_ne_zero⟩,
    fun h => ?_⟩
state_before: F : Type ?u.32745
R : Type u_1
S : Type ?u.32751
x y : R
r : ℝ
inst✝ : Ring R
p : RingSeminorm R
hp : ↑p 1 ≤ 1
⊢ ↑p 1 = 1 ↔ p ≠ 0

tactic: obtain hp0 | hp0 := (map_nonneg p (1 : R)).eq_or_gt
state_before: F : Type ?u.32745
R : Type u_1
S : Type ?u.32751
x y : R
r : ℝ
inst✝ : Ring R
p : RingSeminorm R
hp : ↑p 1 ≤ 1
h : p ≠ 0
⊢ ↑p 1 = 1

tactic: rw [h]
state_before: F : Type ?u.32745
R : Type u_1
S : Type ?u.32751
x y : R
r : ℝ
inst✝ : Ring R
p : RingSeminorm R
hp : ↑p 1 ≤ 1
h : ↑p 1 = 1
⊢ ↑p 1 ≠ 0

tactic: exact one_ne_zero
state_before: F : Type ?u.32745
R : Type u_1
S : Type ?u.32751
x y : R
r : ℝ
inst✝ : Ring R
p : RingSeminorm R
hp : ↑p 1 ≤ 1
h : ↑p 1 = 1
⊢ 1 ≠ 0

tactic: exfalso
state_before: case inl
F : Type ?u.32745
R : Type u_1
S : Type ?u.32751
x y : R
r : ℝ
inst✝ : Ring R
p : RingSeminorm R
hp : ↑p 1 ≤ 1
h : p ≠ 0
hp0 : ↑p 1 = 0
⊢ ↑p 1 = 1

tactic: refine h (ext fun x => (map_nonneg _ _).antisymm' ?_)
state_before: case inl.h
F : Type ?u.32745
R : Type u_1
S : Type ?u.32751
x y : R
r : ℝ
inst✝ : Ring R
p : RingSeminorm R
hp : ↑p 1 ≤ 1
h : p ≠ 0
hp0 : ↑p 1 = 0
⊢ False

tactic: simpa only [hp0, mul_one, MulZeroClass.mul_zero] using map_mul_le_mul p x 1
state_before: case inl.h
F : Type ?u.32745
R : Type u_1
S : Type ?u.32751
x✝ y : R
r : ℝ
inst✝ : Ring R
p : RingSeminorm R
hp : ↑p 1 ≤ 1
h : p ≠ 0
hp0 : ↑p 1 = 0
x : R
⊢ ↑p x ≤ 0

tactic: refine' hp.antisymm ((le_mul_iff_one_le_left hp0).1 _)
state_before: case inr
F : Type ?u.32745
R : Type u_1
S : Type ?u.32751
x y : R
r : ℝ
inst✝ : Ring R
p : RingSeminorm R
hp : ↑p 1 ≤ 1
h : p ≠ 0
hp0 : 0 < ↑p 1
⊢ ↑p 1 = 1

tactic: simpa only [one_mul] using map_mul_le_mul p (1 : R) _
state_before: case inr
F : Type ?u.32745
R : Type u_1
S : Type ?u.32751
x y : R
r : ℝ
inst✝ : Ring R
p : RingSeminorm R
hp : ↑p 1 ≤ 1
h : p ≠ 0
hp0 : 0 < ↑p 1
⊢ ↑p 1 ≤ ↑p 1 * ↑p 1
Theorem: Nat.div_eq_iff_eq_mul_left
File: Mathlib/Data/Nat/Basic.lean

tactic: rw [mul_comm]
state_before: m n k a b c : ℕ
H : 0 < b
H' : b ∣ a
⊢ a / b = c ↔ a = c * b

tactic: exact Nat.div_eq_iff_eq_mul_right H H'
state_before: m n k a b c : ℕ
H : 0 < b
H' : b ∣ a
⊢ a / b = c ↔ a = b * c
Theorem: Polynomial.aeval_algebraMap_eq_zero_iff_of_injective
File: Mathlib/RingTheory/Polynomial/Tower.lean

tactic: rw [aeval_algebraMap_apply, ← (algebraMap A B).map_zero, h.eq_iff]
state_before: R : Type u_1
A : Type u_2
B : Type u_3
inst✝⁶ : CommSemiring R
inst✝⁵ : CommSemiring A
inst✝⁴ : Semiring B
inst✝³ : Algebra R A
inst✝² : Algebra A B
inst✝¹ : Algebra R B
inst✝ : IsScalarTower R A B
x : A
p : R[X]
h : Function.Injective ↑(algebraMap A B)
⊢ ↑(aeval (↑(algebraMap A B) x)) p = 0 ↔ ↑(aeval x) p = 0
Theorem: MvPolynomial.coeff_X_pow
File: Mathlib/Data/MvPolynomial/Basic.lean

tactic: have := coeff_monomial m (Finsupp.single i k) (1 : R)
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m✝ : σ
s : σ →₀ ℕ
inst✝² : CommSemiring R
inst✝¹ : CommSemiring S₁
p q : MvPolynomial σ R
inst✝ : DecidableEq σ
i : σ
m : σ →₀ ℕ
k : ℕ
⊢ coeff m (X i ^ k) = if Finsupp.single i k = m then 1 else 0

tactic: rwa [@monomial_eq _ _ (1 : R) (Finsupp.single i k) _, C_1, one_mul, Finsupp.prod_single_index]
  at this
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m✝ : σ
s : σ →₀ ℕ
inst✝² : CommSemiring R
inst✝¹ : CommSemiring S₁
p q : MvPolynomial σ R
inst✝ : DecidableEq σ
i : σ
m : σ →₀ ℕ
k : ℕ
this : coeff m (↑(monomial (Finsupp.single i k)) 1) = if Finsupp.single i k = m then 1 else 0
⊢ coeff m (X i ^ k) = if Finsupp.single i k = m then 1 else 0

tactic: exact pow_zero _
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m✝ : σ
s : σ →₀ ℕ
inst✝² : CommSemiring R
inst✝¹ : CommSemiring S₁
p q : MvPolynomial σ R
inst✝ : DecidableEq σ
i : σ
m : σ →₀ ℕ
k : ℕ
this : coeff m (Finsupp.prod (Finsupp.single i k) fun n e => X n ^ e) = if Finsupp.single i k = m then 1 else 0
⊢ X i ^ 0 = 1
Theorem: FractionalIdeal.coe_ideal_span_singleton_div_self
File: Mathlib/RingTheory/DedekindDomain/Ideal.lean

tactic: rw [coeIdeal_span_singleton,
  spanSingleton_div_self K <|
    (map_ne_zero_iff _ <| NoZeroSMulDivisors.algebraMap_injective R₁ K).mpr hx]
state_before: R : Type ?u.48171
A : Type ?u.48174
K : Type u_2
inst✝¹⁰ : CommRing R
inst✝⁹ : CommRing A
inst✝⁸ : Field K
inst✝⁷ : IsDomain A
R₁ : Type u_1
inst✝⁶ : CommRing R₁
inst✝⁵ : IsDomain R₁
inst✝⁴ : Algebra R₁ K
inst✝³ : IsFractionRing R₁ K
I J : FractionalIdeal R₁⁰ K
K' : Type ?u.49185
inst✝² : Field K'
inst✝¹ : Algebra R₁ K'
inst✝ : IsFractionRing R₁ K'
x : R₁
hx : x ≠ 0
⊢ ↑(Ideal.span {x}) / ↑(Ideal.span {x}) = 1
Theorem: Homotopy.comp_nullHomotopicMap
File: Mathlib/Algebra/Homology/Homotopy.lean

tactic: ext n
state_before: ι : Type u_1
V : Type u
inst✝¹ : Category V
inst✝ : Preadditive V
c : ComplexShape ι
C D E : HomologicalComplex V c
f✝ g : C ⟶ D
h k : D ⟶ E
i : ι
f : C ⟶ D
hom : (i j : ι) → X D i ⟶ X E j
⊢ f ≫ nullHomotopicMap hom = nullHomotopicMap fun i j => Hom.f f i ≫ hom i j

tactic: dsimp [nullHomotopicMap, fromNext, toPrev, AddMonoidHom.mk'_apply]
state_before: case h
ι : Type u_1
V : Type u
inst✝¹ : Category V
inst✝ : Preadditive V
c : ComplexShape ι
C D E : HomologicalComplex V c
f✝ g : C ⟶ D
h k : D ⟶ E
i : ι
f : C ⟶ D
hom : (i j : ι) → X D i ⟶ X E j
n : ι
⊢ Hom.f (f ≫ nullHomotopicMap hom) n = Hom.f (nullHomotopicMap fun i j => Hom.f f i ≫ hom i j) n

tactic: simp only [Preadditive.comp_add, Category.assoc, f.comm_assoc]
state_before: case h
ι : Type u_1
V : Type u
inst✝¹ : Category V
inst✝ : Preadditive V
c : ComplexShape ι
C D E : HomologicalComplex V c
f✝ g : C ⟶ D
h k : D ⟶ E
i : ι
f : C ⟶ D
hom : (i j : ι) → X D i ⟶ X E j
n : ι
⊢ Hom.f f n ≫ (dFrom D n ≫ hom (ComplexShape.next c n) n + hom n (ComplexShape.prev c n) ≫ dTo E n) =
    dFrom C n ≫ Hom.f f (ComplexShape.next c n) ≫ hom (ComplexShape.next c n) n +
      (Hom.f f n ≫ hom n (ComplexShape.prev c n)) ≫ dTo E n
Theorem: Function.Periodic.mul_const'
File: Mathlib/Algebra/Periodic.lean

tactic: simpa only [div_eq_mul_inv] using h.mul_const a
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.70814
f g : α → β
c c₁ c₂ x : α
inst✝ : DivisionSemiring α
h : Periodic f c
a : α
⊢ Periodic (fun x => f (x * a)) (c / a)
Theorem: CategoryTheory.MonoidalCategory.prodMonoidal_rightUnitor_inv_fst
File: Mathlib/CategoryTheory/Monoidal/Category.lean

tactic: cases X
state_before: C : Type u
𝒞 : Category C
inst✝⁴ : MonoidalCategory C
C₁ : Type u₁
inst✝³ : Category C₁
inst✝² : MonoidalCategory C₁
C₂ : Type u₂
inst✝¹ : Category C₂
inst✝ : MonoidalCategory C₂
X : C₁ × C₂
⊢ (ρ_ X).inv.fst = (ρ_ X.fst).inv

tactic: rfl
state_before: case mk
C : Type u
𝒞 : Category C
inst✝⁴ : MonoidalCategory C
C₁ : Type u₁
inst✝³ : Category C₁
inst✝² : MonoidalCategory C₁
C₂ : Type u₂
inst✝¹ : Category C₂
inst✝ : MonoidalCategory C₂
fst✝ : C₁
snd✝ : C₂
⊢ (ρ_ (fst✝, snd✝)).inv.fst = (ρ_ (fst✝, snd✝).fst).inv
Theorem: Set.star_mem_centralizer
File: Mathlib/Algebra/Star/Subalgebra.lean

tactic: simpa using congr_arg star (ha _ (h _ hy)).symm
state_before: F : Type ?u.378119
R : Type ?u.378122
A : Type u_1
B : Type ?u.378128
C : Type ?u.378131
inst✝¹³ : CommSemiring R
inst✝¹² : StarRing R
inst✝¹¹ : Semiring A
inst✝¹⁰ : StarRing A
inst✝⁹ : Algebra R A
inst✝⁸ : StarModule R A
inst✝⁷ : Semiring B
inst✝⁶ : StarRing B
inst✝⁵ : Algebra R B
inst✝⁴ : StarModule R B
inst✝³ : Semiring C
inst✝² : StarRing C
inst✝¹ : Algebra R C
inst✝ : StarModule R C
S : StarSubalgebra R A
a : A
s : Set A
h : ∀ (a : A), a ∈ s → star a ∈ s
ha : a ∈ Set.centralizer s
y : A
hy : y ∈ s
⊢ y * star a = star a * y
Theorem: normalize_eq_zero
File: Mathlib/Algebra/GCDMonoid/Basic.lean

tactic: rintro rfl
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : NormalizationMonoid α
x : α
⊢ x = 0 → ↑normalize x = 0

tactic: exact normalize_zero
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : NormalizationMonoid α
⊢ ↑normalize 0 = 0
Theorem: Real.cos_antiperiodic
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

tactic: simp [cos_add]
state_before: ⊢ Function.Antiperiodic cos π
Theorem: acc_principal_iff_cluster
File: Mathlib/Topology/Basic.lean

tactic: rw [acc_iff_cluster, inf_principal, inter_comm]
state_before: α : Type u
β : Type v
ι : Sort w
a : α
s s₁ s₂ t : Set α
p p₁ p₂ : α → Prop
inst✝ : TopologicalSpace α
x : α
C : Set α
⊢ AccPt x (𝓟 C) ↔ ClusterPt x (𝓟 (C \ {x}))

tactic: rfl
state_before: α : Type u
β : Type v
ι : Sort w
a : α
s s₁ s₂ t : Set α
p p₁ p₂ : α → Prop
inst✝ : TopologicalSpace α
x : α
C : Set α
⊢ ClusterPt x (𝓟 (C ∩ {x}ᶜ)) ↔ ClusterPt x (𝓟 (C \ {x}))
Theorem: Complex.exp_antiperiodic
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

tactic: simp [exp_add, exp_mul_I]
state_before: ⊢ Function.Antiperiodic exp (↑π * I)
Theorem: Function.support_const_smul_of_ne_zero
File: Mathlib/Algebra/Support.lean

tactic: simp only [hc, mem_support, Pi.smul_apply, Ne.def, smul_eq_zero, false_or_iff]
state_before: α : Type u_3
β : Type ?u.91934
A : Type ?u.91937
B : Type ?u.91940
M : Type u_2
N : Type ?u.91946
P : Type ?u.91949
R : Type u_1
S : Type ?u.91955
G : Type ?u.91958
M₀ : Type ?u.91961
G₀ : Type ?u.91964
ι : Sort ?u.91967
inst✝³ : Semiring R
inst✝² : AddCommMonoid M
inst✝¹ : Module R M
inst✝ : NoZeroSMulDivisors R M
c : R
g : α → M
hc : c ≠ 0
x : α
⊢ x ∈ support (c • g) ↔ x ∈ support g
Theorem: Set.surjOn_iff_exists_bijOn_subset
File: Mathlib/Data/Set/Function.lean

tactic: constructor
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.68088
ι : Sort ?u.68091
π : α → Type ?u.68096
s s₁ s₂ : Set α
t : Set β
f : α → β
⊢ SurjOn f s t ↔ ∃ s' x, BijOn f s' t

tactic: rcases eq_empty_or_nonempty t with (rfl | ht)
state_before: case mp
α : Type u_1
β : Type u_2
γ : Type ?u.68088
ι : Sort ?u.68091
π : α → Type ?u.68096
s s₁ s₂ : Set α
t : Set β
f : α → β
⊢ SurjOn f s t → ∃ s' x, BijOn f s' t

tactic: exact fun _ => ⟨∅, empty_subset _, bijOn_empty f⟩
state_before: case mp.inl
α : Type u_1
β : Type u_2
γ : Type ?u.68088
ι : Sort ?u.68091
π : α → Type ?u.68096
s s₁ s₂ : Set α
f : α → β
⊢ SurjOn f s ∅ → ∃ s' x, BijOn f s' ∅

tactic: intro h
state_before: case mp.inr
α : Type u_1
β : Type u_2
γ : Type ?u.68088
ι : Sort ?u.68091
π : α → Type ?u.68096
s s₁ s₂ : Set α
t : Set β
f : α → β
ht : Set.Nonempty t
⊢ SurjOn f s t → ∃ s' x, BijOn f s' t

tactic: haveI : Nonempty α := ⟨Classical.choose (h.comap_nonempty ht)⟩
state_before: case mp.inr
α : Type u_1
β : Type u_2
γ : Type ?u.68088
ι : Sort ?u.68091
π : α → Type ?u.68096
s s₁ s₂ : Set α
t : Set β
f : α → β
ht : Set.Nonempty t
h : SurjOn f s t
⊢ ∃ s' x, BijOn f s' t

tactic: exact ⟨_, h.mapsTo_invFunOn.image_subset, h.bijOn_subset⟩
state_before: case mp.inr
α : Type u_1
β : Type u_2
γ : Type ?u.68088
ι : Sort ?u.68091
π : α → Type ?u.68096
s s₁ s₂ : Set α
t : Set β
f : α → β
ht : Set.Nonempty t
h : SurjOn f s t
this : Nonempty α
⊢ ∃ s' x, BijOn f s' t

tactic: rintro ⟨s', hs', hfs'⟩
state_before: case mpr
α : Type u_1
β : Type u_2
γ : Type ?u.68088
ι : Sort ?u.68091
π : α → Type ?u.68096
s s₁ s₂ : Set α
t : Set β
f : α → β
⊢ (∃ s' x, BijOn f s' t) → SurjOn f s t

tactic: exact hfs'.surjOn.mono hs' (Subset.refl _)
state_before: case mpr.intro.intro
α : Type u_1
β : Type u_2
γ : Type ?u.68088
ι : Sort ?u.68091
π : α → Type ?u.68096
s s₁ s₂ : Set α
t : Set β
f : α → β
s' : Set α
hs' : s' ⊆ s
hfs' : BijOn f s' t
⊢ SurjOn f s t
Theorem: List.TProd.elim_of_mem
File: Mathlib/Data/Prod/TProd.lean

tactic: apply elim_of_ne
state_before: ι : Type u
α : ι → Type v
i j : ι
l : List ι
f : (i : ι) → α i
inst✝ : DecidableEq ι
hl : Nodup (i :: l)
hj : j ∈ l
v : TProd α (i :: l)
⊢ TProd.elim v (_ : j ∈ i :: l) = TProd.elim v.snd hj

tactic: rintro rfl
state_before: case hji
ι : Type u
α : ι → Type v
i j : ι
l : List ι
f : (i : ι) → α i
inst✝ : DecidableEq ι
hl : Nodup (i :: l)
hj : j ∈ l
v : TProd α (i :: l)
⊢ j ≠ i

tactic: exact hl.not_mem hj
state_before: case hji
ι : Type u
α : ι → Type v
j : ι
l : List ι
f : (i : ι) → α i
inst✝ : DecidableEq ι
hj : j ∈ l
hl : Nodup (j :: l)
v : TProd α (j :: l)
⊢ False
Theorem: Filter.frequently_false
File: Mathlib/Order/Filter/Basic.lean

tactic: simp
state_before: α : Type u
β : Type v
γ : Type w
δ : Type ?u.162368
ι : Sort x
f : Filter α
⊢ ¬∃ᶠ (x : α) in f, False
Theorem: UniformOnFun.gen_eq_preimage_restrict
File: Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean

tactic: ext uv
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.53041
ι : Type ?u.53044
s s' : Set α
x : α
p : Filter ι
g : ι → α
𝔖 : Set (Set α)
S : Set α
V : Set (β × β)
⊢ UniformOnFun.gen 𝔖 S V =
    Prod.map (restrict S ∘ ↑UniformFun.toFun) (restrict S ∘ ↑UniformFun.toFun) ⁻¹' UniformFun.gen (↑S) β V

tactic: exact ⟨fun h ⟨x, hx⟩ => h x hx, fun h x hx => h ⟨x, hx⟩⟩
state_before: case h
α : Type u_1
β : Type u_2
γ : Type ?u.53041
ι : Type ?u.53044
s s' : Set α
x : α
p : Filter ι
g : ι → α
𝔖 : Set (Set α)
S : Set α
V : Set (β × β)
uv : (α →ᵤ[𝔖] β) × (α →ᵤ[𝔖] β)
⊢ uv ∈ UniformOnFun.gen 𝔖 S V ↔
    uv ∈ Prod.map (restrict S ∘ ↑UniformFun.toFun) (restrict S ∘ ↑UniformFun.toFun) ⁻¹' UniformFun.gen (↑S) β V
Theorem: SimpleGraph.fromEdgeSet_sup
File: Mathlib/Combinatorics/SimpleGraph/Basic.lean

tactic: ext (v w)
state_before: ι : Sort ?u.85886
𝕜 : Type ?u.85889
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
s✝ s t : Set (Sym2 V)
⊢ fromEdgeSet s ⊔ fromEdgeSet t = fromEdgeSet (s ∪ t)

tactic: simp [Set.mem_union, or_and_right]
state_before: case Adj.h.h.a
ι : Sort ?u.85886
𝕜 : Type ?u.85889
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
s✝ s t : Set (Sym2 V)
v w : V
⊢ Adj (fromEdgeSet s ⊔ fromEdgeSet t) v w ↔ Adj (fromEdgeSet (s ∪ t)) v w
Theorem: geom_sum_neg_iff
File: Mathlib/Algebra/GeomSum.lean

tactic: rw [← not_iff_not, not_lt, le_iff_lt_or_eq, eq_comm,
  or_congr (geom_sum_pos_iff hn) (geom_sum_eq_zero_iff_neg_one hn), Nat.odd_iff_not_even, ←
  add_eq_zero_iff_eq_neg, not_and, not_lt, le_iff_lt_or_eq, eq_comm, ← imp_iff_not_or, or_comm,
  and_comm, Decidable.and_or_imp, or_comm]
state_before: α : Type u
β : Type ?u.255021
n : ℕ
x : α
inst✝ : LinearOrderedRing α
hn : n ≠ 0
⊢ ∑ i in range n, x ^ i < 0 ↔ Even n ∧ x + 1 < 0
Theorem: OrthogonalFamily.inner_right_fintype
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

tactic: classical!
state_before: 𝕜 : Type u_2
E : Type u_3
F : Type ?u.3639502
inst✝⁷ : IsROrC 𝕜
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : InnerProductSpace 𝕜 E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : InnerProductSpace ℝ F
dec_E : DecidableEq E
ι : Type u_1
dec_ι : DecidableEq ι
G : ι → Type u_4
inst✝² : (i : ι) → NormedAddCommGroup (G i)
inst✝¹ : (i : ι) → InnerProductSpace 𝕜 (G i)
V : (i : ι) → G i →ₗᵢ[𝕜] E
hV : OrthogonalFamily 𝕜 G V
dec_V : (i : ι) → (x : G i) → Decidable (x ≠ 0)
inst✝ : Fintype ι
l : (i : ι) → G i
i : ι
v : G i
⊢ inner (↑(V i) v) (∑ j : ι, ↑(V j) (l j)) = inner v (l i)

tactic: calc
  ⟪V i v, ∑ j : ι, V j (l j)⟫ = ∑ j : ι, ⟪V i v, V j (l j)⟫ := by rw [inner_sum]
  _ = ∑ j, ite (i = j) ⟪V i v, V j (l j)⟫ 0 :=
    (congr_arg (Finset.sum Finset.univ) <| funext fun j => hV.eq_ite v (l j))
  _ = ⟪v, l i⟫ := by
    simp only [Finset.sum_ite_eq, Finset.mem_univ, (V i).inner_map_map, if_true]
state_before: 𝕜 : Type u_2
E : Type u_3
F : Type ?u.3639502
inst✝⁷ : IsROrC 𝕜
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : InnerProductSpace 𝕜 E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : InnerProductSpace ℝ F
dec_E : DecidableEq E
ι : Type u_1
dec_ι : DecidableEq ι
G : ι → Type u_4
inst✝² : (i : ι) → NormedAddCommGroup (G i)
inst✝¹ : (i : ι) → InnerProductSpace 𝕜 (G i)
V : (i : ι) → G i →ₗᵢ[𝕜] E
hV : OrthogonalFamily 𝕜 G V
dec_V : (i : ι) → (x : G i) → Decidable (x ≠ 0)
inst✝ : Fintype ι
l : (i : ι) → G i
i : ι
v : G i
em✝ : (a : Prop) → Decidable a
⊢ inner (↑(V i) v) (∑ j : ι, ↑(V j) (l j)) = inner v (l i)

tactic: rw [inner_sum]
state_before: 𝕜 : Type u_2
E : Type u_3
F : Type ?u.3639502
inst✝⁷ : IsROrC 𝕜
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : InnerProductSpace 𝕜 E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : InnerProductSpace ℝ F
dec_E : DecidableEq E
ι : Type u_1
dec_ι : DecidableEq ι
G : ι → Type u_4
inst✝² : (i : ι) → NormedAddCommGroup (G i)
inst✝¹ : (i : ι) → InnerProductSpace 𝕜 (G i)
V : (i : ι) → G i →ₗᵢ[𝕜] E
hV : OrthogonalFamily 𝕜 G V
dec_V : (i : ι) → (x : G i) → Decidable (x ≠ 0)
inst✝ : Fintype ι
l : (i : ι) → G i
i : ι
v : G i
em✝ : (a : Prop) → Decidable a
⊢ inner (↑(V i) v) (∑ j : ι, ↑(V j) (l j)) = ∑ j : ι, inner (↑(V i) v) (↑(V j) (l j))

tactic: simp only [Finset.sum_ite_eq, Finset.mem_univ, (V i).inner_map_map, if_true]
state_before: 𝕜 : Type u_2
E : Type u_3
F : Type ?u.3639502
inst✝⁷ : IsROrC 𝕜
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : InnerProductSpace 𝕜 E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : InnerProductSpace ℝ F
dec_E : DecidableEq E
ι : Type u_1
dec_ι : DecidableEq ι
G : ι → Type u_4
inst✝² : (i : ι) → NormedAddCommGroup (G i)
inst✝¹ : (i : ι) → InnerProductSpace 𝕜 (G i)
V : (i : ι) → G i →ₗᵢ[𝕜] E
hV : OrthogonalFamily 𝕜 G V
dec_V : (i : ι) → (x : G i) → Decidable (x ≠ 0)
inst✝ : Fintype ι
l : (i : ι) → G i
i : ι
v : G i
em✝ : (a : Prop) → Decidable a
⊢ (∑ j : ι, if i = j then inner (↑(V i) v) (↑(V j) (l j)) else 0) = inner v (l i)
Theorem: Sum.elim_const_const
File: Mathlib/Data/Sum/Basic.lean

tactic: ext x
state_before: α : Type u
α' : Type w
β : Type v
β' : Type x
γ : Type u_1
δ : Type ?u.36468
c : γ
⊢ Sum.elim (const α c) (const β c) = const (α ⊕ β) c

tactic: cases x <;> rfl
state_before: case h
α : Type u
α' : Type w
β : Type v
β' : Type x
γ : Type u_1
δ : Type ?u.36468
c : γ
x : α ⊕ β
⊢ Sum.elim (const α c) (const β c) x = const (α ⊕ β) c x
Theorem: Set.mapsTo_iff_exists_map_subtype
File: Mathlib/Data/Set/Function.lean

tactic: erw [hg ⟨x, hx⟩]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.15625
ι : Sort ?u.15628
π : α → Type ?u.15633
s s₁ s₂ : Set α
t t₁ t₂ : Set β
p : Set γ
f f₁ f₂ f₃ : α → β
g✝ g₁ g₂ : β → γ
f' f₁' f₂' : β → α
g' : γ → β
a : α
b : β
x✝ : ∃ g, ∀ (x : ↑s), f ↑x = ↑(g x)
x : α
hx : x ∈ s
g : ↑s → ↑t
hg : ∀ (x : ↑s), f ↑x = ↑(g x)
⊢ f x ∈ t

tactic: apply Subtype.coe_prop
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.15625
ι : Sort ?u.15628
π : α → Type ?u.15633
s s₁ s₂ : Set α
t t₁ t₂ : Set β
p : Set γ
f f₁ f₂ f₃ : α → β
g✝ g₁ g₂ : β → γ
f' f₁' f₂' : β → α
g' : γ → β
a : α
b : β
x✝ : ∃ g, ∀ (x : ↑s), f ↑x = ↑(g x)
x : α
hx : x ∈ s
g : ↑s → ↑t
hg : ∀ (x : ↑s), f ↑x = ↑(g x)
⊢ ↑(g { val := x, property := hx }) ∈ t
Theorem: OrthonormalBasis.det_to_matrix_orthonormalBasis
File: Mathlib/Analysis/InnerProductSpace/PiL2.lean

tactic: have : (normSq (a.toBasis.det b) : 𝕜) = 1 := by
  simpa [IsROrC.mul_conj] using
    (Matrix.det_of_mem_unitary (a.toMatrix_orthonormalBasis_mem_unitary b)).2
state_before: ι : Type u_3
ι' : Type ?u.1468229
𝕜 : Type u_1
inst✝¹⁰ : IsROrC 𝕜
E : Type u_2
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : InnerProductSpace 𝕜 E
E' : Type ?u.1468258
inst✝⁷ : NormedAddCommGroup E'
inst✝⁶ : InnerProductSpace 𝕜 E'
F : Type ?u.1468276
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : InnerProductSpace ℝ F
F' : Type ?u.1468296
inst✝³ : NormedAddCommGroup F'
inst✝² : InnerProductSpace ℝ F'
inst✝¹ : Fintype ι
inst✝ : DecidableEq ι
a b : OrthonormalBasis ι 𝕜 E
⊢ ‖↑(Basis.det (OrthonormalBasis.toBasis a)) ↑b‖ = 1

tactic: norm_cast at this
state_before: ι : Type u_3
ι' : Type ?u.1468229
𝕜 : Type u_1
inst✝¹⁰ : IsROrC 𝕜
E : Type u_2
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : InnerProductSpace 𝕜 E
E' : Type ?u.1468258
inst✝⁷ : NormedAddCommGroup E'
inst✝⁶ : InnerProductSpace 𝕜 E'
F : Type ?u.1468276
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : InnerProductSpace ℝ F
F' : Type ?u.1468296
inst✝³ : NormedAddCommGroup F'
inst✝² : InnerProductSpace ℝ F'
inst✝¹ : Fintype ι
inst✝ : DecidableEq ι
a b : OrthonormalBasis ι 𝕜 E
this : ↑(↑normSq (↑(Basis.det (OrthonormalBasis.toBasis a)) ↑b)) = 1
⊢ ‖↑(Basis.det (OrthonormalBasis.toBasis a)) ↑b‖ = 1

tactic: rwa [← sqrt_normSq_eq_norm, sqrt_eq_one]
state_before: ι : Type u_3
ι' : Type ?u.1468229
𝕜 : Type u_1
inst✝¹⁰ : IsROrC 𝕜
E : Type u_2
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : InnerProductSpace 𝕜 E
E' : Type ?u.1468258
inst✝⁷ : NormedAddCommGroup E'
inst✝⁶ : InnerProductSpace 𝕜 E'
F : Type ?u.1468276
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : InnerProductSpace ℝ F
F' : Type ?u.1468296
inst✝³ : NormedAddCommGroup F'
inst✝² : InnerProductSpace ℝ F'
inst✝¹ : Fintype ι
inst✝ : DecidableEq ι
a b : OrthonormalBasis ι 𝕜 E
this : ↑normSq (↑(Basis.det (OrthonormalBasis.toBasis a)) ↑b) = 1
⊢ ‖↑(Basis.det (OrthonormalBasis.toBasis a)) ↑b‖ = 1

tactic: simpa [IsROrC.mul_conj] using
  (Matrix.det_of_mem_unitary (a.toMatrix_orthonormalBasis_mem_unitary b)).2
state_before: ι : Type u_3
ι' : Type ?u.1468229
𝕜 : Type u_1
inst✝¹⁰ : IsROrC 𝕜
E : Type u_2
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : InnerProductSpace 𝕜 E
E' : Type ?u.1468258
inst✝⁷ : NormedAddCommGroup E'
inst✝⁶ : InnerProductSpace 𝕜 E'
F : Type ?u.1468276
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : InnerProductSpace ℝ F
F' : Type ?u.1468296
inst✝³ : NormedAddCommGroup F'
inst✝² : InnerProductSpace ℝ F'
inst✝¹ : Fintype ι
inst✝ : DecidableEq ι
a b : OrthonormalBasis ι 𝕜 E
⊢ ↑(↑normSq (↑(Basis.det (OrthonormalBasis.toBasis a)) ↑b)) = 1
Theorem: List.new_def_eq_old_def
File: Mathlib/Data/List/Indexes.lean

tactic: intro f
state_before: α : Type u
β : Type v
⊢ ∀ (f : ℕ → α → β) (l : List α), mapIdx f l = List.oldMapIdx f l

tactic: apply list_reverse_induction
state_before: α : Type u
β : Type v
f : ℕ → α → β
⊢ ∀ (l : List α), mapIdx f l = List.oldMapIdx f l

tactic: rfl
state_before: case base
α : Type u
β : Type v
f : ℕ → α → β
⊢ mapIdx f [] = List.oldMapIdx f []

tactic: intro l e h
state_before: case ind
α : Type u
β : Type v
f : ℕ → α → β
⊢ ∀ (l : List α) (e : α), mapIdx f l = List.oldMapIdx f l → mapIdx f (l ++ [e]) = List.oldMapIdx f (l ++ [e])

tactic: rw [List.oldMapIdx_append, mapIdx_append_one, h]
state_before: case ind
α : Type u
β : Type v
f : ℕ → α → β
l : List α
e : α
h : mapIdx f l = List.oldMapIdx f l
⊢ mapIdx f (l ++ [e]) = List.oldMapIdx f (l ++ [e])
Theorem: LinearPMap.right_le_sup
File: Mathlib/LinearAlgebra/LinearPMap.lean

tactic: refine' ⟨le_sup_right, fun z₁ z₂ hz => _⟩
state_before: R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type ?u.203526
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f g : E →ₗ.[R] F
h : ∀ (x : { x // x ∈ f.domain }) (y : { x // x ∈ g.domain }), ↑x = ↑y → ↑f x = ↑g y
⊢ g ≤ LinearPMap.sup f g h

tactic: rw [← zero_add (g _), ← f.map_zero]
state_before: R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type ?u.203526
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f g : E →ₗ.[R] F
h : ∀ (x : { x // x ∈ f.domain }) (y : { x // x ∈ g.domain }), ↑x = ↑y → ↑f x = ↑g y
z₁ : { x // x ∈ g.domain }
z₂ : { x // x ∈ (LinearPMap.sup f g h).domain }
hz : ↑z₁ = ↑z₂
⊢ ↑g z₁ = ↑(LinearPMap.sup f g h) z₂

tactic: refine' (sup_apply h _ _ _ _).symm
state_before: R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type ?u.203526
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f g : E →ₗ.[R] F
h : ∀ (x : { x // x ∈ f.domain }) (y : { x // x ∈ g.domain }), ↑x = ↑y → ↑f x = ↑g y
z₁ : { x // x ∈ g.domain }
z₂ : { x // x ∈ (LinearPMap.sup f g h).domain }
hz : ↑z₁ = ↑z₂
⊢ ↑f 0 + ↑g z₁ = ↑(LinearPMap.sup f g h) z₂

tactic: simpa
state_before: R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type ?u.203526
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f g : E →ₗ.[R] F
h : ∀ (x : { x // x ∈ f.domain }) (y : { x // x ∈ g.domain }), ↑x = ↑y → ↑f x = ↑g y
z₁ : { x // x ∈ g.domain }
z₂ : { x // x ∈ (LinearPMap.sup f g h).domain }
hz : ↑z₁ = ↑z₂
⊢ ↑0 + ↑z₁ = ↑z₂