tasksource/leandojo huggingface dataset:
Theorem: CategoryTheory.Abelian.Pseudoelement.apply_eq_zero_of_comp_eq_zero
File: Mathlib/CategoryTheory/Abelian/Pseudoelements.lean

tactic: simp [over_coe_def, pseudoApply_mk', Over.coe_hom, h]
state_before: C : Type u
inst✝¹ : Category C
inst✝ : Abelian C
P Q R : C
f : Q ⟶ R
a : P ⟶ Q
h : a ≫ f = 0
⊢ pseudoApply f (Quot.mk (PseudoEqual Q) (Over.mk a)) = 0
Theorem: symmDiff_symmDiff_cancel_right
File: Mathlib/Order/SymmDiff.lean

tactic: simp [symmDiff_assoc]
state_before: ι : Type ?u.74084
α : Type u_1
β : Type ?u.74090
π : ι → Type ?u.74095
inst✝ : GeneralizedBooleanAlgebra α
a b c d : α
⊢ b ∆ a ∆ a = b
Theorem: Filter.limsup_eq_iInf_iSup_of_nat'
File: Mathlib/Order/LiminfLimsup.lean

tactic: simp only [limsup_eq_iInf_iSup_of_nat, iSup_ge_eq_iSup_nat_add]
state_before: α : Type u_1
β : Type ?u.108288
γ : Type ?u.108291
ι : Type ?u.108294
inst✝ : CompleteLattice α
u : ℕ → α
⊢ limsup u atTop = ⨅ (n : ℕ), ⨆ (i : ℕ), u (i + n)
Theorem: partialSups_eq_ciSup_Iic
File: Mathlib/Order/PartialSups.lean

tactic: have : Set.Iio (n + 1) = Set.Iic n := Set.ext fun _ => Nat.lt_succ_iff
state_before: α : Type u_1
inst✝ : ConditionallyCompleteLattice α
f : ℕ → α
n : ℕ
⊢ ↑(partialSups f) n = ⨆ (i : ↑(Set.Iic n)), f ↑i

tactic: rw [partialSups_eq_sup'_range, Finset.sup'_eq_csSup_image, Finset.coe_range, iSup, this]
state_before: α : Type u_1
inst✝ : ConditionallyCompleteLattice α
f : ℕ → α
n : ℕ
this : Set.Iio (n + 1) = Set.Iic n
⊢ ↑(partialSups f) n = ⨆ (i : ↑(Set.Iic n)), f ↑i
Theorem: MeasureTheory.FiniteMeasure.tendsto_of_tendsto_normalize_testAgainstNN_of_tendsto_mass
File: Mathlib/MeasureTheory/Measure/ProbabilityMeasure.lean

tactic: rw [tendsto_iff_forall_testAgainstNN_tendsto]
state_before: Ω : Type u_2
inst✝² : Nonempty Ω
m0 : MeasurableSpace Ω
μ : FiniteMeasure Ω
inst✝¹ : TopologicalSpace Ω
inst✝ : OpensMeasurableSpace Ω
γ : Type u_1
F : Filter γ
μs : γ → FiniteMeasure Ω
μs_lim : Tendsto (fun i => normalize (μs i)) F (𝓝 (normalize μ))
mass_lim : Tendsto (fun i => mass (μs i)) F (𝓝 (mass μ))
⊢ Tendsto μs F (𝓝 μ)

tactic: exact fun f =>
  tendsto_testAgainstNN_of_tendsto_normalize_testAgainstNN_of_tendsto_mass μs_lim mass_lim f
state_before: Ω : Type u_2
inst✝² : Nonempty Ω
m0 : MeasurableSpace Ω
μ : FiniteMeasure Ω
inst✝¹ : TopologicalSpace Ω
inst✝ : OpensMeasurableSpace Ω
γ : Type u_1
F : Filter γ
μs : γ → FiniteMeasure Ω
μs_lim : Tendsto (fun i => normalize (μs i)) F (𝓝 (normalize μ))
mass_lim : Tendsto (fun i => mass (μs i)) F (𝓝 (mass μ))
⊢ ∀ (f : Ω →ᵇ ℝ≥0), Tendsto (fun i => testAgainstNN (μs i) f) F (𝓝 (testAgainstNN μ f))
Theorem: Real.map_exp_atTop
File: Mathlib/Analysis/SpecialFunctions/Exp.lean

tactic: rw [← coe_comp_expOrderIso, ← Filter.map_map, OrderIso.map_atTop, map_val_Ioi_atTop]
state_before: α : Type ?u.84797
x y z : ℝ
l : Filter α
⊢ Filter.map exp atTop = atTop
Theorem: FreeProduct.of_leftInverse
File: Mathlib/GroupTheory/FreeProduct.lean

tactic: simp only [lift_of, Pi.mulSingle_eq_same, MonoidHom.id_apply]
state_before: ι : Type u_1
M : ι → Type u_2
inst✝² : (i : ι) → Monoid (M i)
N : Type ?u.215701
inst✝¹ : Monoid N
inst✝ : DecidableEq ι
i : ι
x : M i
⊢ ↑(↑lift (Pi.mulSingle i (MonoidHom.id (M i)))) (↑of x) = x
Theorem: Set.empty_pi
File: Mathlib/Data/Set/Prod.lean

tactic: ext
state_before: ι : Type u_2
α : ι → Type u_1
β : ι → Type ?u.112962
s✝ s₁ s₂ : Set ι
t t₁ t₂ : (i : ι) → Set (α i)
i : ι
s : (i : ι) → Set (α i)
⊢ pi ∅ s = univ

tactic: simp [pi]
state_before: case h
ι : Type u_2
α : ι → Type u_1
β : ι → Type ?u.112962
s✝ s₁ s₂ : Set ι
t t₁ t₂ : (i : ι) → Set (α i)
i : ι
s : (i : ι) → Set (α i)
x✝ : (i : ι) → α i
⊢ x✝ ∈ pi ∅ s ↔ x✝ ∈ univ
Theorem: Set.Definable.union
File: Mathlib/ModelTheory/Definability.lean

tactic: rcases hf with ⟨φ, hφ⟩
state_before: M : Type w
A : Set M
L : Language
inst✝ : Structure L M
α : Type u₁
β : Type ?u.12600
B : Set M
s f g : Set (α → M)
hf : Definable A L f
hg : Definable A L g
⊢ Definable A L (f ∪ g)

tactic: rcases hg with ⟨θ, hθ⟩
state_before: case intro
M : Type w
A : Set M
L : Language
inst✝ : Structure L M
α : Type u₁
β : Type ?u.12600
B : Set M
s f g : Set (α → M)
hg : Definable A L g
φ : Formula (L[[↑A]]) α
hφ : f = setOf (Formula.Realize φ)
⊢ Definable A L (f ∪ g)

tactic: refine' ⟨φ ⊔ θ, _⟩
state_before: case intro.intro
M : Type w
A : Set M
L : Language
inst✝ : Structure L M
α : Type u₁
β : Type ?u.12600
B : Set M
s f g : Set (α → M)
φ : Formula (L[[↑A]]) α
hφ : f = setOf (Formula.Realize φ)
θ : Formula (L[[↑A]]) α
hθ : g = setOf (Formula.Realize θ)
⊢ Definable A L (f ∪ g)

tactic: ext
state_before: case intro.intro
M : Type w
A : Set M
L : Language
inst✝ : Structure L M
α : Type u₁
β : Type ?u.12600
B : Set M
s f g : Set (α → M)
φ : Formula (L[[↑A]]) α
hφ : f = setOf (Formula.Realize φ)
θ : Formula (L[[↑A]]) α
hθ : g = setOf (Formula.Realize θ)
⊢ f ∪ g = setOf (Formula.Realize (φ ⊔ θ))

tactic: rw [hφ, hθ, mem_setOf_eq, Formula.realize_sup, mem_union, mem_setOf_eq, mem_setOf_eq]
state_before: case intro.intro.h
M : Type w
A : Set M
L : Language
inst✝ : Structure L M
α : Type u₁
β : Type ?u.12600
B : Set M
s f g : Set (α → M)
φ : Formula (L[[↑A]]) α
hφ : f = setOf (Formula.Realize φ)
θ : Formula (L[[↑A]]) α
hθ : g = setOf (Formula.Realize θ)
x✝ : α → M
⊢ x✝ ∈ f ∪ g ↔ x✝ ∈ setOf (Formula.Realize (φ ⊔ θ))
Theorem: Int.norm_coe_nat
File: Mathlib/Analysis/Normed/Group/Basic.lean

tactic: simp [Int.norm_eq_abs]
state_before: 𝓕 : Type ?u.1111633
𝕜 : Type ?u.1111636
α : Type ?u.1111639
ι : Type ?u.1111642
κ : Type ?u.1111645
E : Type ?u.1111648
F : Type ?u.1111651
G : Type ?u.1111654
inst✝¹ : SeminormedCommGroup E
inst✝ : SeminormedCommGroup F
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
n : ℕ
⊢ ‖↑n‖ = ↑n
Theorem: RelEmbedding.wellFounded_iff_no_descending_seq
File: Mathlib/Order/OrderIsoNat.lean

tactic: constructor
state_before: α : Type u_1
r : α → α → Prop
inst✝ : IsStrictOrder α r
⊢ WellFounded r ↔ IsEmpty ((fun x x_1 => x > x_1) ↪r r)

tactic: rintro ⟨h⟩
state_before: case mp
α : Type u_1
r : α → α → Prop
inst✝ : IsStrictOrder α r
⊢ WellFounded r → IsEmpty ((fun x x_1 => x > x_1) ↪r r)

tactic: exact ⟨fun f => not_acc_of_decreasing_seq f 0 (h _)⟩
state_before: case mp.intro
α : Type u_1
r : α → α → Prop
inst✝ : IsStrictOrder α r
h : ∀ (a : α), Acc r a
⊢ IsEmpty ((fun x x_1 => x > x_1) ↪r r)

tactic: intro h
state_before: case mpr
α : Type u_1
r : α → α → Prop
inst✝ : IsStrictOrder α r
⊢ IsEmpty ((fun x x_1 => x > x_1) ↪r r) → WellFounded r

tactic: exact ⟨fun x => acc_iff_no_decreasing_seq.2 inferInstance⟩
state_before: case mpr
α : Type u_1
r : α → α → Prop
inst✝ : IsStrictOrder α r
h : IsEmpty ((fun x x_1 => x > x_1) ↪r r)
⊢ WellFounded r
Theorem: Vector3.insert_fs
File: Mathlib/Data/Vector3.lean

tactic: refine' j.cases' _ fun j => _ <;> simp [insert, insertPerm]
state_before: α : Type u_1
m n : ℕ
a b : α
v : Vector3 α n
i : Fin2 (succ n)
j : Fin2 (succ (succ n))
⊢ insert a (b :: v) (fs i) j = (b :: insert a v i) j

tactic: refine' Fin2.cases' _ _ (insertPerm i j) <;> simp [insertPerm]
state_before: case refine'_2
α : Type u_1
m n : ℕ
a b : α
v : Vector3 α n
i : Fin2 (succ n)
j✝ : Fin2 (succ (succ n))
j : Fin2 (n + 1)
⊢ (a :: b :: v)
      (match insertPerm i j with
      | fz => fz
      | fs k => fs (fs k)) =
    (a :: v) (insertPerm i j)
Theorem: SubgroupClass.inclusion_right
File: Mathlib/GroupTheory/Subgroup/Basic.lean

tactic: cases x
state_before: G : Type u_2
G' : Type ?u.62545
inst✝⁶ : Group G
inst✝⁵ : Group G'
A : Type ?u.62554
inst✝⁴ : AddGroup A
M : Type ?u.62560
S : Type u_1
inst✝³ : DivInvMonoid M
inst✝² : SetLike S M
hSM : SubgroupClass S M
H K : S
inst✝¹ : SetLike S G
inst✝ : SubgroupClass S G
h : H ≤ K
x : { x // x ∈ K }
hx : ↑x ∈ H
⊢ ↑(inclusion h) { val := ↑x, property := hx } = x

tactic: rfl
state_before: case mk
G : Type u_2
G' : Type ?u.62545
inst✝⁶ : Group G
inst✝⁵ : Group G'
A : Type ?u.62554
inst✝⁴ : AddGroup A
M : Type ?u.62560
S : Type u_1
inst✝³ : DivInvMonoid M
inst✝² : SetLike S M
hSM : SubgroupClass S M
H K : S
inst✝¹ : SetLike S G
inst✝ : SubgroupClass S G
h : H ≤ K
val✝ : G
property✝ : val✝ ∈ K
hx : ↑{ val := val✝, property := property✝ } ∈ H
⊢ ↑(inclusion h) { val := ↑{ val := val✝, property := property✝ }, property := hx } =
    { val := val✝, property := property✝ }
Theorem: CategoryTheory.constant_of_preserves_morphisms
File: Mathlib/CategoryTheory/IsConnected.lean

tactic: simpa using
  any_functor_const_on_obj
    { obj := Discrete.mk ∘ F
      map := @fun _ _ f =>
        eqToHom
          (by
            ext
            exact h _ _ f) }
    j j'
state_before: J : Type u₁
inst✝² : Category J
K : Type u₂
inst✝¹ : Category K
inst✝ : IsPreconnected J
α : Type u₁
F : J → α
h : ∀ (j₁ j₂ : J), (j₁ ⟶ j₂) → F j₁ = F j₂
j j' : J
⊢ F j = F j'

tactic: ext
state_before: J : Type u₁
inst✝² : Category J
K : Type u₂
inst✝¹ : Category K
inst✝ : IsPreconnected J
α : Type u₁
F : J → α
h : ∀ (j₁ j₂ : J), (j₁ ⟶ j₂) → F j₁ = F j₂
j j' x✝¹ x✝ : J
f : x✝¹ ⟶ x✝
⊢ (Discrete.mk ∘ F) x✝¹ = (Discrete.mk ∘ F) x✝

tactic: exact h _ _ f
state_before: case as
J : Type u₁
inst✝² : Category J
K : Type u₂
inst✝¹ : Category K
inst✝ : IsPreconnected J
α : Type u₁
F : J → α
h : ∀ (j₁ j₂ : J), (j₁ ⟶ j₂) → F j₁ = F j₂
j j' x✝¹ x✝ : J
f : x✝¹ ⟶ x✝
⊢ ((Discrete.mk ∘ F) x✝¹).as = ((Discrete.mk ∘ F) x✝).as
Theorem: Int.le_natAbs
File: Std/Data/Int/Lemmas.lean

tactic: rw [eq_natAbs_of_zero_le h]
state_before: a : Int
h : 0 ≤ a
⊢ a ≤ ↑(natAbs a)

tactic: apply Int.le_refl
state_before: a : Int
h : 0 ≤ a
⊢ ↑(natAbs a) ≤ ↑(natAbs ↑(natAbs a))
Theorem: SimpleGraph.Subgraph.neighborSet_iInf
File: Mathlib/Combinatorics/SimpleGraph/Subgraph.lean

tactic: simp [iInf]
state_before: ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G₁ G₂ : Subgraph G
a b : V
f : ι → Subgraph G
v : V
⊢ neighborSet (⨅ (i : ι), f i) v = (⋂ (i : ι), neighborSet (f i) v) ∩ SimpleGraph.neighborSet G v
Theorem: cauchy_series_of_le_geometric
File: Mathlib/Analysis/SpecificLimits/Normed.lean

tactic: simp [h]
state_before: α : Type u_1
β : Type ?u.1068136
ι : Type ?u.1068139
inst✝ : SeminormedAddCommGroup α
r✝ C✝ : ℝ
f : ℕ → α
C : ℝ
u : ℕ → α
r : ℝ
hr : r < 1
h : ∀ (n : ℕ), ‖u n‖ ≤ C * r ^ n
⊢ ∀ (n : ℕ), dist (∑ k in Finset.range n, u k) (∑ k in Finset.range (n + 1), u k) ≤ C * r ^ n
Theorem: Polynomial.degree_C_mul_X_le
File: Mathlib/Data/Polynomial/Degree/Definitions.lean

tactic: simpa only [pow_one] using degree_C_mul_X_pow_le 1 a
state_before: R : Type u
S : Type v
a✝ b c d : R
n m : ℕ
inst✝ : Semiring R
p q r : R[X]
a : R
⊢ degree (↑C a * X) ≤ 1
Theorem: ZMod.nat_cast_zmod_val
File: Mathlib/Data/ZMod/Basic.lean

tactic: cases n
state_before: n✝ : ℕ
R : Type ?u.21503
n : ℕ
inst✝ : NeZero n
a : ZMod n
⊢ ↑(val a) = a

tactic: cases NeZero.ne 0 rfl
state_before: case zero
n : ℕ
R : Type ?u.21503
inst✝ : NeZero Nat.zero
a : ZMod Nat.zero
⊢ ↑(val a) = a

tactic: apply Fin.cast_val_eq_self
state_before: case succ
n : ℕ
R : Type ?u.21503
n✝ : ℕ
inst✝ : NeZero (Nat.succ n✝)
a : ZMod (Nat.succ n✝)
⊢ ↑(val a) = a
Theorem: Submodule.span_pow
File: Mathlib/Algebra/Algebra/Operations.lean

tactic: rw [pow_zero, pow_zero, one_eq_span_one_set]
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
s : Set A
⊢ span R s ^ 0 = span R (s ^ 0)

tactic: rw [pow_succ, pow_succ, span_pow s n, span_mul_span]
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
s : Set A
n : ℕ
⊢ span R s ^ (n + 1) = span R (s ^ (n + 1))
Theorem: MeasureTheory.VectorMeasure.map_zero
File: Mathlib/MeasureTheory/Measure/VectorMeasure.lean

tactic: by_cases hf : Measurable f
state_before: α : Type u_3
β : Type u_1
m inst✝³ : MeasurableSpace α
inst✝² : MeasurableSpace β
M : Type u_2
inst✝¹ : AddCommMonoid M
inst✝ : TopologicalSpace M
v : VectorMeasure α M
f : α → β
⊢ map 0 f = 0

tactic: ext i
state_before: case pos
α : Type u_3
β : Type u_1
m inst✝³ : MeasurableSpace α
inst✝² : MeasurableSpace β
M : Type u_2
inst✝¹ : AddCommMonoid M
inst✝ : TopologicalSpace M
v : VectorMeasure α M
f : α → β
hf : Measurable f
⊢ map 0 f = 0

tactic: intro hi
state_before: case pos.h
α : Type u_3
β : Type u_1
m inst✝³ : MeasurableSpace α
inst✝² : MeasurableSpace β
M : Type u_2
inst✝¹ : AddCommMonoid M
inst✝ : TopologicalSpace M
v : VectorMeasure α M
f : α → β
hf : Measurable f
i : Set β
⊢ MeasurableSet i → ↑(map 0 f) i = ↑0 i

tactic: rw [map_apply _ hf hi, zero_apply, zero_apply]
state_before: case pos.h
α : Type u_3
β : Type u_1
m inst✝³ : MeasurableSpace α
inst✝² : MeasurableSpace β
M : Type u_2
inst✝¹ : AddCommMonoid M
inst✝ : TopologicalSpace M
v : VectorMeasure α M
f : α → β
hf : Measurable f
i : Set β
hi : MeasurableSet i
⊢ ↑(map 0 f) i = ↑0 i

tactic: exact dif_neg hf
state_before: case neg
α : Type u_3
β : Type u_1
m inst✝³ : MeasurableSpace α
inst✝² : MeasurableSpace β
M : Type u_2
inst✝¹ : AddCommMonoid M
inst✝ : TopologicalSpace M
v : VectorMeasure α M
f : α → β
hf : ¬Measurable f
⊢ map 0 f = 0
Theorem: Submonoid.subsingleton_iff
File: Mathlib/GroupTheory/Submonoid/Basic.lean

tactic: simp [Submonoid.one_mem]
state_before: M : Type u_1
N : Type ?u.19160
A : Type ?u.19163
inst✝¹ : MulOneClass M
s : Set M
inst✝ : AddZeroClass A
t : Set A
S : Submonoid M
h : Subsingleton M
x y : Submonoid M
i : M
⊢ 1 ∈ x ↔ 1 ∈ y
Theorem: diff_mem_nhdsWithin_diff
File: Mathlib/Topology/ContinuousOn.lean

tactic: rw [nhdsWithin, diff_eq, diff_eq, ← inf_principal, ← inf_assoc]
state_before: α : Type u_1
β : Type ?u.5955
γ : Type ?u.5958
δ : Type ?u.5961
inst✝ : TopologicalSpace α
x : α
s t : Set α
hs : s ∈ 𝓝[t] x
t' : Set α
⊢ s \ t' ∈ 𝓝[t \ t'] x

tactic: exact inter_mem_inf hs (mem_principal_self _)
state_before: α : Type u_1
β : Type ?u.5955
γ : Type ?u.5958
δ : Type ?u.5961
inst✝ : TopologicalSpace α
x : α
s t : Set α
hs : s ∈ 𝓝[t] x
t' : Set α
⊢ s ∩ t'ᶜ ∈ 𝓝 x ⊓ 𝓟 t ⊓ 𝓟 (t'ᶜ)
Theorem: TopologicalSpace.Closeds.isAtom_iff
File: Mathlib/Topology/Sets/Closeds.lean

tactic: have : IsAtom (s : Set α) ↔ IsAtom s := by
  refine' Closeds.gi.isAtom_iff' rfl (fun t ht => _) s
  obtain ⟨x, rfl⟩ := t.isAtom_iff.mp ht
  exact closure_singleton
state_before: ι : Type ?u.25211
α : Type u_1
β : Type ?u.25217
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : T1Space α
s : Closeds α
⊢ IsAtom s ↔ ∃ x, s = singleton x

tactic: simp only [← this, (s : Set α).isAtom_iff, SetLike.ext'_iff, Closeds.singleton_coe]
state_before: ι : Type ?u.25211
α : Type u_1
β : Type ?u.25217
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : T1Space α
s : Closeds α
this : IsAtom ↑s ↔ IsAtom s
⊢ IsAtom s ↔ ∃ x, s = singleton x

tactic: refine' Closeds.gi.isAtom_iff' rfl (fun t ht => _) s
state_before: ι : Type ?u.25211
α : Type u_1
β : Type ?u.25217
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : T1Space α
s : Closeds α
⊢ IsAtom ↑s ↔ IsAtom s

tactic: obtain ⟨x, rfl⟩ := t.isAtom_iff.mp ht
state_before: ι : Type ?u.25211
α : Type u_1
β : Type ?u.25217
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : T1Space α
s : Closeds α
t : Set α
ht : IsAtom t
⊢ ↑(Closeds.closure t) = t

tactic: exact closure_singleton
state_before: case intro
ι : Type ?u.25211
α : Type u_1
β : Type ?u.25217
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : T1Space α
s : Closeds α
x : α
ht : IsAtom {x}
⊢ ↑(Closeds.closure {x}) = {x}
Theorem: List.pairwise_ofFn
File: Mathlib/Data/List/OfFn.lean

tactic: simp only [pairwise_iff_get, (Fin.cast (length_ofFn f)).surjective.forall, get_ofFn,
  OrderIso.lt_iff_lt]
state_before: α : Type u
R : α → α → Prop
n : ℕ
f : Fin n → α
⊢ Pairwise R (ofFn f) ↔ ∀ ⦃i j : Fin n⦄, i < j → R (f i) (f j)
Theorem: Ideal.torsionOf_zero
File: Mathlib/Algebra/Module/Torsion.lean

tactic: simp [torsionOf]
state_before: R : Type u_1
M : Type u_2
inst✝² : Semiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
⊢ torsionOf R M 0 = ⊤
Theorem: IsOrderRightAdjoint.orderIso_comp
File: Mathlib/Order/SemiconjSup.lean

tactic: simpa [e.le_symm_apply] using h (e.symm y)
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : Preorder γ
f : α → β
g : β → α
h : IsOrderRightAdjoint f g
e : β ≃o γ
y : γ
⊢ IsLUB {x | (↑e ∘ f) x ≤ y} ((g ∘ ↑(OrderIso.symm e)) y)
Theorem: LinearMap.IsSymmetric.coe_reApplyInnerSelf_apply
File: Mathlib/Analysis/InnerProductSpace/Symmetric.lean

tactic: rsuffices ⟨r, hr⟩ : ∃ r : ℝ, ⟪T x, x⟫ = r
state_before: 𝕜 : Type u_1
E : Type u_2
E' : Type ?u.56213
F : Type ?u.56216
G : Type ?u.56219
inst✝⁸ : IsROrC 𝕜
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : InnerProductSpace 𝕜 E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : InnerProductSpace 𝕜 F
inst✝³ : NormedAddCommGroup G
inst✝² : InnerProductSpace 𝕜 G
inst✝¹ : NormedAddCommGroup E'
inst✝ : InnerProductSpace ℝ E'
T : E →L[𝕜] E
hT : IsSymmetric ↑T
x : E
⊢ ↑(ContinuousLinearMap.reApplyInnerSelf T x) = inner (↑T x) x

tactic: rw [← conj_eq_iff_real]
state_before: 𝕜 : Type u_1
E : Type u_2
E' : Type ?u.56213
F : Type ?u.56216
G : Type ?u.56219
inst✝⁸ : IsROrC 𝕜
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : InnerProductSpace 𝕜 E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : InnerProductSpace 𝕜 F
inst✝³ : NormedAddCommGroup G
inst✝² : InnerProductSpace 𝕜 G
inst✝¹ : NormedAddCommGroup E'
inst✝ : InnerProductSpace ℝ E'
T : E →L[𝕜] E
hT : IsSymmetric ↑T
x : E
⊢ ∃ r, inner (↑T x) x = ↑r

tactic: exact hT.conj_inner_sym x x
state_before: 𝕜 : Type u_1
E : Type u_2
E' : Type ?u.56213
F : Type ?u.56216
G : Type ?u.56219
inst✝⁸ : IsROrC 𝕜
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : InnerProductSpace 𝕜 E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : InnerProductSpace 𝕜 F
inst✝³ : NormedAddCommGroup G
inst✝² : InnerProductSpace 𝕜 G
inst✝¹ : NormedAddCommGroup E'
inst✝ : InnerProductSpace ℝ E'
T : E →L[𝕜] E
hT : IsSymmetric ↑T
x : E
⊢ ↑(starRingEnd 𝕜) (inner (↑T x) x) = inner (↑T x) x

tactic: simp [hr, T.reApplyInnerSelf_apply]
state_before: case intro
𝕜 : Type u_1
E : Type u_2
E' : Type ?u.56213
F : Type ?u.56216
G : Type ?u.56219
inst✝⁸ : IsROrC 𝕜
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : InnerProductSpace 𝕜 E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : InnerProductSpace 𝕜 F
inst✝³ : NormedAddCommGroup G
inst✝² : InnerProductSpace 𝕜 G
inst✝¹ : NormedAddCommGroup E'
inst✝ : InnerProductSpace ℝ E'
T : E →L[𝕜] E
hT : IsSymmetric ↑T
x : E
r : ℝ
hr : inner (↑T x) x = ↑r
⊢ ↑(ContinuousLinearMap.reApplyInnerSelf T x) = inner (↑T x) x
Theorem: Nat.multichoose_two
File: Mathlib/Data/Nat/Choose/Basic.lean

tactic: induction' k with k IH
state_before: k : ℕ
⊢ multichoose 2 k = k + 1

tactic: rw [multichoose, IH]
state_before: case succ
k : ℕ
IH : multichoose 2 k = k + 1
⊢ multichoose 2 (succ k) = succ k + 1

tactic: simp [add_comm, succ_eq_add_one]
state_before: case succ
k : ℕ
IH : multichoose 2 k = k + 1
⊢ multichoose 1 (k + 1) + (k + 1) = succ k + 1

tactic: simp
state_before: case zero

⊢ multichoose 2 zero = zero + 1
Theorem: eq_of_sub_eq_zero'
File: Mathlib/Algebra/GroupWithZero/Defs.lean

tactic: rw [← sub_eq_add_neg, h, add_neg_self]
state_before: G₀ : Type u
M₀ : Type ?u.15
M₀' : Type ?u.18
G₀' : Type ?u.21
R : Type u_1
inst✝ : AddGroup R
a b : R
h : a - b = 0
⊢ a + -b = b + -b
Theorem: Orthonormal.comp_linearIsometry
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

tactic: rwa [f.orthonormal_comp_iff]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.2902038
inst✝⁸ : IsROrC 𝕜
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : InnerProductSpace 𝕜 E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : InnerProductSpace ℝ F
dec_E : DecidableEq E
ι : Type u_3
ι' : Type ?u.2902090
ι'' : Type ?u.2902093
E' : Type u_4
inst✝³ : NormedAddCommGroup E'
inst✝² : InnerProductSpace 𝕜 E'
E'' : Type ?u.2902114
inst✝¹ : NormedAddCommGroup E''
inst✝ : InnerProductSpace 𝕜 E''
v : ι → E
hv : Orthonormal 𝕜 v
f : E →ₗᵢ[𝕜] E'
⊢ Orthonormal 𝕜 (↑f ∘ v)
Theorem: ENNReal.exists_ne_top
File: Mathlib/Data/Real/ENNReal.lean

tactic: simp only [exists_ne_top', ← exists_prop]
state_before: α : Type ?u.22430
β : Type ?u.22433
a b c d : ℝ≥0∞
r p✝ q : ℝ≥0
p : ℝ≥0∞ → Prop
⊢ (∃ a, a ≠ ⊤ ∧ p a) ↔ ∃ r, p ↑r
Theorem: Matrix.blockDiagonal_smul
File: Mathlib/Data/Matrix/Block.lean

tactic: ext
state_before: l : Type ?u.169372
m : Type u_3
n : Type u_4
o : Type u_5
p : Type ?u.169384
q : Type ?u.169387
m' : o → Type ?u.169392
n' : o → Type ?u.169397
p' : o → Type ?u.169402
R✝ : Type ?u.169405
S : Type ?u.169408
α : Type u_2
β : Type ?u.169414
inst✝³ : DecidableEq o
R : Type u_1
inst✝² : Monoid R
inst✝¹ : AddMonoid α
inst✝ : DistribMulAction R α
x : R
M : o → Matrix m n α
⊢ blockDiagonal (x • M) = x • blockDiagonal M

tactic: simp only [blockDiagonal_apply, Pi.smul_apply, smul_apply]
state_before: case a.h
l : Type ?u.169372
m : Type u_3
n : Type u_4
o : Type u_5
p : Type ?u.169384
q : Type ?u.169387
m' : o → Type ?u.169392
n' : o → Type ?u.169397
p' : o → Type ?u.169402
R✝ : Type ?u.169405
S : Type ?u.169408
α : Type u_2
β : Type ?u.169414
inst✝³ : DecidableEq o
R : Type u_1
inst✝² : Monoid R
inst✝¹ : AddMonoid α
inst✝ : DistribMulAction R α
x : R
M : o → Matrix m n α
i✝ : m × o
x✝ : n × o
⊢ blockDiagonal (x • M) i✝ x✝ = (x • blockDiagonal M) i✝ x✝

tactic: split_ifs <;> simp
state_before: case a.h
l : Type ?u.169372
m : Type u_3
n : Type u_4
o : Type u_5
p : Type ?u.169384
q : Type ?u.169387
m' : o → Type ?u.169392
n' : o → Type ?u.169397
p' : o → Type ?u.169402
R✝ : Type ?u.169405
S : Type ?u.169408
α : Type u_2
β : Type ?u.169414
inst✝³ : DecidableEq o
R : Type u_1
inst✝² : Monoid R
inst✝¹ : AddMonoid α
inst✝ : DistribMulAction R α
x : R
M : o → Matrix m n α
i✝ : m × o
x✝ : n × o
⊢ (if i✝.snd = x✝.snd then x • M i✝.snd i✝.fst x✝.fst else 0) =
    x • if i✝.snd = x✝.snd then M i✝.snd i✝.fst x✝.fst else 0
Theorem: CategoryTheory.transferNatTransSelf_symm_comp
File: Mathlib/CategoryTheory/Adjunction/Mates.lean

tactic: rw [Equiv.eq_symm_apply, ← transferNatTransSelf_comp _ adj₂]
state_before: C : Type u₁
D : Type u₂
inst✝¹ : Category C
inst✝ : Category D
L₁ L₂ L₃ : C ⥤ D
R₁ R₂ R₃ : D ⥤ C
adj₁ : L₁ ⊣ R₁
adj₂ : L₂ ⊣ R₂
adj₃ : L₃ ⊣ R₃
f : R₂ ⟶ R₁
g : R₃ ⟶ R₂
⊢ ↑(transferNatTransSelf adj₂ adj₁).symm f ≫ ↑(transferNatTransSelf adj₃ adj₂).symm g =
    ↑(transferNatTransSelf adj₃ adj₁).symm (g ≫ f)

tactic: simp
state_before: C : Type u₁
D : Type u₂
inst✝¹ : Category C
inst✝ : Category D
L₁ L₂ L₃ : C ⥤ D
R₁ R₂ R₃ : D ⥤ C
adj₁ : L₁ ⊣ R₁
adj₂ : L₂ ⊣ R₂
adj₃ : L₃ ⊣ R₃
f : R₂ ⟶ R₁
g : R₃ ⟶ R₂
⊢ ↑(transferNatTransSelf adj₃ adj₂) (↑(transferNatTransSelf adj₃ adj₂).symm g) ≫
      ↑(transferNatTransSelf adj₂ adj₁) (↑(transferNatTransSelf adj₂ adj₁).symm f) =
    g ≫ f
Theorem: MeasureTheory.AEEqFun.liftRel_iff_coeFn
File: Mathlib/MeasureTheory/Function/AEEqFun.lean

tactic: rw [← liftRel_mk_mk, mk_coeFn, mk_coeFn]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type ?u.449609
inst✝³ : MeasurableSpace α
μ ν : Measure α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
r : β → γ → Prop
f : α →ₘ[μ] β
g : α →ₘ[μ] γ
⊢ LiftRel r f g ↔ ∀ᵐ (a : α) ∂μ, r (↑f a) (↑g a)
Theorem: Stream'.unfolds_eq
File: Mathlib/Data/Stream/Init.lean

tactic: unfold unfolds
state_before: α : Type u
β : Type v
δ : Type w
g : α → β
f : α → α
a : α
⊢ unfolds g f a = g a :: unfolds g f (f a)

tactic: rw [corec_eq]
state_before: α : Type u
β : Type v
δ : Type w
g : α → β
f : α → α
a : α
⊢ corec g f a = g a :: corec g f (f a)
Theorem: Ssyt.row_weak_of_le
File: Mathlib/Combinatorics/Young/SemistandardTableau.lean

tactic: cases' eq_or_lt_of_le hj with h h
state_before: μ : YoungDiagram
T : Ssyt μ
i j1 j2 : ℕ
hj : j1 ≤ j2
cell : (i, j2) ∈ μ
⊢ ↑T i j1 ≤ ↑T i j2

tactic: . rw [h]
state_before: case inl
μ : YoungDiagram
T : Ssyt μ
i j1 j2 : ℕ
hj : j1 ≤ j2
cell : (i, j2) ∈ μ
h : j1 = j2
⊢ ↑T i j1 ≤ ↑T i j2

case inr
μ : YoungDiagram
T : Ssyt μ
i j1 j2 : ℕ
hj : j1 ≤ j2
cell : (i, j2) ∈ μ
h : j1 < j2
⊢ ↑T i j1 ≤ ↑T i j2

tactic: . exact T.row_weak h cell
state_before: case inr
μ : YoungDiagram
T : Ssyt μ
i j1 j2 : ℕ
hj : j1 ≤ j2
cell : (i, j2) ∈ μ
h : j1 < j2
⊢ ↑T i j1 ≤ ↑T i j2

tactic: rw [h]
state_before: case inl
μ : YoungDiagram
T : Ssyt μ
i j1 j2 : ℕ
hj : j1 ≤ j2
cell : (i, j2) ∈ μ
h : j1 = j2
⊢ ↑T i j1 ≤ ↑T i j2

tactic: exact T.row_weak h cell
state_before: case inr
μ : YoungDiagram
T : Ssyt μ
i j1 j2 : ℕ
hj : j1 ≤ j2
cell : (i, j2) ∈ μ
h : j1 < j2
⊢ ↑T i j1 ≤ ↑T i j2