tasksource/leandojo huggingface dataset:
Theorem: List.filter_append
File: Std/Data/List/Lemmas.lean

tactic: simp [filter]
state_before: α : Type u_1
p : α → Bool
a : α
l₁ l₂ : List α
⊢ filter p (a :: l₁ ++ l₂) = filter p (a :: l₁) ++ filter p l₂

tactic: split <;> simp [filter_append l₁]
state_before: α : Type u_1
p : α → Bool
a : α
l₁ l₂ : List α
⊢ (match p a with
    | true => a :: filter p (l₁ ++ l₂)
    | false => filter p (l₁ ++ l₂)) =
    (match p a with
      | true => a :: filter p l₁
      | false => filter p l₁) ++
      filter p l₂
Theorem: openEmbedding_sigma_map
File: Mathlib/Topology/Constructions.lean

tactic: simp only [openEmbedding_iff_embedding_open, isOpenMap_sigma_map, embedding_sigma_map h,
  forall_and]
state_before: α : Type u
β : Type v
γ : Type ?u.553929
δ : Type ?u.553932
ε : Type ?u.553935
ζ : Type ?u.553938
ι : Type u_1
κ : Type u_2
σ : ι → Type u_3
τ : κ → Type u_4
inst✝² : (i : ι) → TopologicalSpace (σ i)
inst✝¹ : (k : κ) → TopologicalSpace (τ k)
inst✝ : TopologicalSpace α
f₁ : ι → κ
f₂ : (i : ι) → σ i → τ (f₁ i)
h : Injective f₁
⊢ OpenEmbedding (Sigma.map f₁ f₂) ↔ ∀ (i : ι), OpenEmbedding (f₂ i)
Theorem: Set.not_monotoneOn_not_antitoneOn_iff_exists_lt_lt
File: Mathlib/Data/Set/Basic.lean

tactic: simp [monotoneOn_iff_monotone, antitoneOn_iff_antitone, and_assoc, exists_and_left,
  not_monotone_not_antitone_iff_exists_lt_lt, @and_left_comm (_ ∈ s)]
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s s₁ s₂ t t₁ t₂ u : Set α
inst✝¹ : LinearOrder α
inst✝ : LinearOrder β
f : α → β
⊢ ¬MonotoneOn f s ∧ ¬AntitoneOn f s ↔ ∃ a x b x c x, a < b ∧ b < c ∧ (f a < f b ∧ f c < f b ∨ f b < f a ∧ f b < f c)
Theorem: Cycle.formPerm_apply_mem_eq_next
File: Mathlib/GroupTheory/Perm/Cycle/Concrete.lean

tactic: induction s using Quot.inductionOn
state_before: α : Type u_1
inst✝ : DecidableEq α
s✝ s' s : Cycle α
h : Nodup s
x : α
hx : x ∈ s
⊢ ↑(formPerm s h) x = next s h x hx

tactic: simpa using List.formPerm_apply_mem_eq_next h _ (by simp_all)
state_before: case h
α : Type u_1
inst✝ : DecidableEq α
s s' : Cycle α
x : α
a✝ : List α
h : Nodup (Quot.mk Setoid.r a✝)
hx : x ∈ Quot.mk Setoid.r a✝
⊢ ↑(formPerm (Quot.mk Setoid.r a✝) h) x = next (Quot.mk Setoid.r a✝) h x hx

tactic: simp_all
state_before: α : Type u_1
inst✝ : DecidableEq α
s s' : Cycle α
x : α
a✝ : List α
h : Nodup (Quot.mk Setoid.r a✝)
hx : x ∈ Quot.mk Setoid.r a✝
⊢ x ∈ a✝
Theorem: contDiffOn_of_locally_contDiffOn
File: Mathlib/Analysis/Calculus/ContDiffDef.lean

tactic: intro x xs
state_before: 𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
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 uX
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
h : ∀ (x : E), x ∈ s → ∃ u, IsOpen u ∧ x ∈ u ∧ ContDiffOn 𝕜 n f (s ∩ u)
⊢ ContDiffOn 𝕜 n f s

tactic: rcases h x xs with ⟨u, u_open, xu, hu⟩
state_before: 𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
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 uX
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x✝ x₀ : E
c : F
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
h : ∀ (x : E), x ∈ s → ∃ u, IsOpen u ∧ x ∈ u ∧ ContDiffOn 𝕜 n f (s ∩ u)
x : E
xs : x ∈ s
⊢ ContDiffWithinAt 𝕜 n f s x

tactic: apply (contDiffWithinAt_inter _).1 (hu x ⟨xs, xu⟩)
state_before: case intro.intro.intro
𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
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 uX
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u✝ : Set E
f f₁ : E → F
g : F → G
x✝ x₀ : E
c : F
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
h : ∀ (x : E), x ∈ s → ∃ u, IsOpen u ∧ x ∈ u ∧ ContDiffOn 𝕜 n f (s ∩ u)
x : E
xs : x ∈ s
u : Set E
u_open : IsOpen u
xu : x ∈ u
hu : ContDiffOn 𝕜 n f (s ∩ u)
⊢ ContDiffWithinAt 𝕜 n f s x

tactic: exact IsOpen.mem_nhds u_open xu
state_before: 𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
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 uX
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u✝ : Set E
f f₁ : E → F
g : F → G
x✝ x₀ : E
c : F
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
h : ∀ (x : E), x ∈ s → ∃ u, IsOpen u ∧ x ∈ u ∧ ContDiffOn 𝕜 n f (s ∩ u)
x : E
xs : x ∈ s
u : Set E
u_open : IsOpen u
xu : x ∈ u
hu : ContDiffOn 𝕜 n f (s ∩ u)
⊢ u ∈ 𝓝 x
Theorem: FirstOrder.Language.LHom.comp_id
File: Mathlib/ModelTheory/LanguageMap.lean

tactic: cases F
state_before: L : Language
L' : Language
M : Type w
inst✝ : Structure L M
ϕ : L →ᴸ L'
L'' : Language
F : L →ᴸ L'
⊢ F ∘' LHom.id L = F

tactic: rfl
state_before: case mk
L : Language
L' : Language
M : Type w
inst✝ : Structure L M
ϕ : L →ᴸ L'
L'' : Language
onFunction✝ : ⦃n : ℕ⦄ → Functions L n → Functions L' n
onRelation✝ : ⦃n : ℕ⦄ → Relations L n → Relations L' n
⊢ { onFunction := onFunction✝, onRelation := onRelation✝ } ∘' LHom.id L =
    { onFunction := onFunction✝, onRelation := onRelation✝ }
Theorem: EReal.continuousAt_add_top_top
File: Mathlib/Topology/Instances/EReal.lean

tactic: simp only [ContinuousAt, tendsto_nhds_top_iff_real, top_add_top]
state_before: α : Type ?u.21891
inst✝ : TopologicalSpace α
⊢ ContinuousAt (fun p => p.fst + p.snd) (⊤, ⊤)

tactic: refine fun r ↦ ((lt_mem_nhds (coe_lt_top 0)).prod_nhds
  (lt_mem_nhds <| coe_lt_top r)).mono fun _ h ↦ ?_
state_before: α : Type ?u.21891
inst✝ : TopologicalSpace α
⊢ ∀ (x : ℝ), ∀ᶠ (a : EReal × EReal) in 𝓝 (⊤, ⊤), ↑x < a.fst + a.snd

tactic: simpa only [coe_zero, zero_add] using add_lt_add h.1 h.2
state_before: α : Type ?u.21891
inst✝ : TopologicalSpace α
r : ℝ
x✝ : EReal × EReal
h : ↑0 < x✝.fst ∧ ↑r < x✝.snd
⊢ ↑r < x✝.fst + x✝.snd
Theorem: Submodule.adjoint_orthogonalProjection
File: Mathlib/Analysis/InnerProductSpace/Adjoint.lean

tactic: rw [← U.adjoint_subtypeL, adjoint_adjoint]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.878200
G : Type ?u.878203
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
U : Submodule 𝕜 E
inst✝ : CompleteSpace { x // x ∈ U }
⊢ ↑adjoint (orthogonalProjection U) = Submodule.subtypeL U
Theorem: CategoryTheory.Limits.coprod.associator_naturality
File: Mathlib/CategoryTheory/Limits/Shapes/BinaryProducts.lean

tactic: simp
state_before: C : Type u
inst✝² : Category C
X Y : C
inst✝¹ : Category C
inst✝ : HasBinaryCoproducts C
X₁ X₂ X₃ Y₁ Y₂ Y₃ : C
f₁ : X₁ ⟶ Y₁
f₂ : X₂ ⟶ Y₂
f₃ : X₃ ⟶ Y₃
⊢ map (map f₁ f₂) f₃ ≫ (associator Y₁ Y₂ Y₃).hom = (associator X₁ X₂ X₃).hom ≫ map f₁ (map f₂ f₃)
Theorem: rank_tensorProduct'
File: Mathlib/LinearAlgebra/FreeModule/Rank.lean

tactic: simp
state_before: R : Type u
M : Type v
N✝ : Type w
inst✝¹⁰ : CommRing R
inst✝⁹ : StrongRankCondition R
inst✝⁸ : AddCommGroup M
inst✝⁷ : Module R M
inst✝⁶ : Module.Free R M
inst✝⁵ : AddCommGroup N✝
inst✝⁴ : Module R N✝
inst✝³ : Module.Free R N✝
N : Type v
inst✝² : AddCommGroup N
inst✝¹ : Module R N
inst✝ : Module.Free R N
⊢ Module.rank R (M ⊗[R] N) = Module.rank R M * Module.rank R N
Theorem: Finset.ne_insert_of_not_mem
File: Mathlib/Data/Finset/Basic.lean

tactic: contrapose! h
state_before: α : Type u_1
β : Type ?u.112192
γ : Type ?u.112195
inst✝ : DecidableEq α
s✝ t✝ u v : Finset α
a✝ b : α
s t : Finset α
a : α
h : ¬a ∈ s
⊢ s ≠ insert a t

tactic: simp [h]
state_before: α : Type u_1
β : Type ?u.112192
γ : Type ?u.112195
inst✝ : DecidableEq α
s✝ t✝ u v : Finset α
a✝ b : α
s t : Finset α
a : α
h : s = insert a t
⊢ a ∈ s
Theorem: Continuous.div_const
File: Mathlib/Topology/Algebra/GroupWithZero.lean

tactic: simpa only [div_eq_mul_inv] using hf.mul continuous_const
state_before: α : Type u_1
β : Type ?u.5613
G₀ : Type u_2
inst✝³ : DivInvMonoid G₀
inst✝² : TopologicalSpace G₀
inst✝¹ : ContinuousMul G₀
f : α → G₀
s : Set α
l : Filter α
inst✝ : TopologicalSpace α
hf : Continuous f
y : G₀
⊢ Continuous fun x => f x / y
Theorem: Ordinal.lsub_lt_ord
File: Mathlib/SetTheory/Cardinal/Cofinality.lean

tactic: rwa [(#ι).lift_id]
state_before: α : Type ?u.29527
r : α → α → Prop
ι : Type u
f : ι → Ordinal
c : Ordinal
hι : (#ι) < cof c
⊢ Cardinal.lift (#ι) < cof c
Theorem: Cardinal.add_one_le_succ
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: have : Set.Nonempty { c' | c < c' } := exists_gt c
state_before: α β : Type u
c : Cardinal
⊢ c + 1 ≤ succ c

tactic: simp_rw [succ_def, le_csInf_iff'' this, mem_setOf]
state_before: α β : Type u
c : Cardinal
this : Set.Nonempty {c' | c < c'}
⊢ c + 1 ≤ succ c

tactic: intro b hlt
state_before: α β : Type u
c : Cardinal
this : Set.Nonempty {c' | c < c'}
⊢ ∀ (b : Cardinal), c < b → c + 1 ≤ b

tactic: rcases b, c with ⟨⟨β⟩, ⟨γ⟩⟩
state_before: α β : Type u
c : Cardinal
this : Set.Nonempty {c' | c < c'}
b : Cardinal
hlt : c < b
⊢ c + 1 ≤ b

tactic: cases' le_of_lt hlt with f
state_before: case mk.mk
α β✝ : Type u
c b : Cardinal
β γ : Type u
this : Set.Nonempty {c' | Quot.mk Setoid.r γ < c'}
hlt : Quot.mk Setoid.r γ < Quot.mk Setoid.r β
⊢ Quot.mk Setoid.r γ + 1 ≤ Quot.mk Setoid.r β

tactic: have : ¬Surjective f := fun hn => (not_le_of_lt hlt) (mk_le_of_surjective hn)
state_before: case mk.mk.intro
α β✝ : Type u
c b : Cardinal
β γ : Type u
this : Set.Nonempty {c' | Quot.mk Setoid.r γ < c'}
hlt : Quot.mk Setoid.r γ < Quot.mk Setoid.r β
f : γ ↪ β
⊢ Quot.mk Setoid.r γ + 1 ≤ Quot.mk Setoid.r β

tactic: simp only [Surjective, not_forall] at this
state_before: case mk.mk.intro
α β✝ : Type u
c b : Cardinal
β γ : Type u
this✝ : Set.Nonempty {c' | Quot.mk Setoid.r γ < c'}
hlt : Quot.mk Setoid.r γ < Quot.mk Setoid.r β
f : γ ↪ β
this : ¬Surjective ↑f
⊢ Quot.mk Setoid.r γ + 1 ≤ Quot.mk Setoid.r β

tactic: rcases this with ⟨b, hb⟩
state_before: case mk.mk.intro
α β✝ : Type u
c b : Cardinal
β γ : Type u
this✝ : Set.Nonempty {c' | Quot.mk Setoid.r γ < c'}
hlt : Quot.mk Setoid.r γ < Quot.mk Setoid.r β
f : γ ↪ β
this : ∃ x, ¬∃ a, ↑f a = x
⊢ Quot.mk Setoid.r γ + 1 ≤ Quot.mk Setoid.r β

tactic: calc
  (#γ) + 1 = (#Option γ) := mk_option.symm
  _ ≤ (#β) := (f.optionElim b hb).cardinal_le
state_before: case mk.mk.intro.intro
α β✝ : Type u
c b✝ : Cardinal
β γ : Type u
this : Set.Nonempty {c' | Quot.mk Setoid.r γ < c'}
hlt : Quot.mk Setoid.r γ < Quot.mk Setoid.r β
f : γ ↪ β
b : β
hb : ¬∃ a, ↑f a = b
⊢ Quot.mk Setoid.r γ + 1 ≤ Quot.mk Setoid.r β
Theorem: SimpleGraph.Walk.adj_getVert_succ
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: cases hi
state_before: case nil
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v u✝ : V
i : ℕ
hi : i < length nil
⊢ Adj G (getVert nil i) (getVert nil (i + 1))

tactic: cases i
state_before: case cons
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v u✝ v✝ w✝ : V
hxy : Adj G u✝ v✝
p✝ : Walk G v✝ w✝
ih : ∀ {i : ℕ}, i < length p✝ → Adj G (getVert p✝ i) (getVert p✝ (i + 1))
i : ℕ
hi : i < length (cons hxy p✝)
⊢ Adj G (getVert (cons hxy p✝) i) (getVert (cons hxy p✝) (i + 1))

tactic: simp [getVert, hxy]
state_before: case cons.zero
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v u✝ v✝ w✝ : V
hxy : Adj G u✝ v✝
p✝ : Walk G v✝ w✝
ih : ∀ {i : ℕ}, i < length p✝ → Adj G (getVert p✝ i) (getVert p✝ (i + 1))
hi : Nat.zero < length (cons hxy p✝)
⊢ Adj G (getVert (cons hxy p✝) Nat.zero) (getVert (cons hxy p✝) (Nat.zero + 1))

tactic: exact ih (Nat.succ_lt_succ_iff.1 hi)
state_before: case cons.succ
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v u✝ v✝ w✝ : V
hxy : Adj G u✝ v✝
p✝ : Walk G v✝ w✝
ih : ∀ {i : ℕ}, i < length p✝ → Adj G (getVert p✝ i) (getVert p✝ (i + 1))
n✝ : ℕ
hi : Nat.succ n✝ < length (cons hxy p✝)
⊢ Adj G (getVert (cons hxy p✝) (Nat.succ n✝)) (getVert (cons hxy p✝) (Nat.succ n✝ + 1))
Theorem: Real.volume_interval
File: Mathlib/MeasureTheory/Measure/Lebesgue/Basic.lean

tactic: rw [← Icc_min_max, volume_Icc, max_sub_min_eq_abs]
state_before: ι : Type ?u.242227
inst✝ : Fintype ι
a b : ℝ
⊢ ↑↑volume (uIcc a b) = ofReal (abs (b - a))
Theorem: Isometry.antilipschitz
File: Mathlib/Topology/MetricSpace/Isometry.lean

tactic: simp only [h x y, ENNReal.coe_one, one_mul, le_refl]
state_before: ι : Type ?u.1422
α : Type u
β : Type v
γ : Type w
inst✝² : PseudoEMetricSpace α
inst✝¹ : PseudoEMetricSpace β
inst✝ : PseudoEMetricSpace γ
f : α → β
x✝ y✝ z : α
s : Set α
h : Isometry f
x y : α
⊢ edist x y ≤ ↑1 * edist (f x) (f y)
Theorem: Set.nonempty_sUnion
File: Mathlib/Data/Set/Lattice.lean

tactic: simp [nonempty_iff_ne_empty]
state_before: α : Type u_1
β : Type ?u.122213
γ : Type ?u.122216
ι : Sort ?u.122219
ι' : Sort ?u.122222
ι₂ : Sort ?u.122225
κ : ι → Sort ?u.122230
κ₁ : ι → Sort ?u.122235
κ₂ : ι → Sort ?u.122240
κ' : ι' → Sort ?u.122245
S : Set (Set α)
⊢ Set.Nonempty (⋃₀ S) ↔ ∃ s, s ∈ S ∧ Set.Nonempty s
Theorem: Polynomial.derivative_X_sub_C_pow
File: Mathlib/Data/Polynomial/Derivative.lean

tactic: rw [derivative_pow, derivative_X_sub_C, mul_one]
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
A : Type z
a b : R
n : ℕ
inst✝ : CommRing R
c : R
m : ℕ
⊢ ↑derivative ((X - ↑C c) ^ m) = ↑C ↑m * (X - ↑C c) ^ (m - 1)
Theorem: List.count_cons'
File: Mathlib/Data/List/Count.lean

tactic: conv =>
simp [count, countp_cons]
lhs
simp only [eq_comm]
state_before: α : Type u_1
l✝ : List α
inst✝ : DecidableEq α
a b : α
l : List α
⊢ count a (b :: l) = count a l + if a = b then 1 else 0
Theorem: AlternatingMap.map_update_update
File: Mathlib/LinearAlgebra/Alternating.lean

tactic: rw [Function.update_same, Function.update_noteq hij, Function.update_same]
state_before: R : Type u_4
inst✝¹⁵ : Semiring R
M : Type u_3
inst✝¹⁴ : AddCommMonoid M
inst✝¹³ : Module R M
N : Type u_2
inst✝¹² : AddCommMonoid N
inst✝¹¹ : Module R N
P : Type ?u.414052
inst✝¹⁰ : AddCommMonoid P
inst✝⁹ : Module R P
M' : Type ?u.414082
inst✝⁸ : AddCommGroup M'
inst✝⁷ : Module R M'
N' : Type ?u.414470
inst✝⁶ : AddCommGroup N'
inst✝⁵ : Module R N'
ι : Type u_1
ι' : Type ?u.414861
ι'' : Type ?u.414864
M₂ : Type ?u.414867
inst✝⁴ : AddCommMonoid M₂
inst✝³ : Module R M₂
M₃ : Type ?u.414897
inst✝² : AddCommMonoid M₃
inst✝¹ : Module R M₃
f f' : AlternatingMap R M N ι
g g₂ : AlternatingMap R M N' ι
g' : AlternatingMap R M' N' ι
v : ι → M
v' : ι → M'
inst✝ : DecidableEq ι
i j : ι
hij : i ≠ j
m : M
⊢ update (update v i m) j m i = update (update v i m) j m j
Theorem: Equiv.exists_congr_left
File: Mathlib/Logic/Equiv/Defs.lean

tactic: simpa using h
state_before: α✝ : Sort u
β✝ : Sort v
γ : Sort w
α : Sort u_1
β : Sort u_2
f : α ≃ β
p : α → Prop
x✝ : ∃ a, p a
a : α
h : p a
⊢ p (↑f.symm (↑f a))
Theorem: Subgroup.map_eq_comap_of_inverse
File: Mathlib/GroupTheory/Subgroup/Basic.lean

tactic: rw [coe_map, coe_comap, Set.image_eq_preimage_of_inverse hl hr]
state_before: G : Type u_1
G' : Type ?u.599712
inst✝³ : Group G
inst✝² : Group G'
A : Type ?u.599721
inst✝¹ : AddGroup A
N : Type u_2
inst✝ : Group N
f✝ f : G →* N
g : N →* G
hl : LeftInverse ↑g ↑f
hr : Function.RightInverse ↑g ↑f
H : Subgroup G
⊢ ↑(map f H) = ↑(comap g H)
Theorem: LinearMap.toMatrix_mulVec_repr
File: Mathlib/LinearAlgebra/Matrix/ToLin.lean

tactic: ext i
state_before: R : Type u_1
inst✝⁹ : CommSemiring R
l : Type ?u.2016127
m : Type u_4
n : Type u_5
inst✝⁸ : Fintype n
inst✝⁷ : Fintype m
inst✝⁶ : DecidableEq n
M₁ : Type u_2
M₂ : Type u_3
inst✝⁵ : AddCommMonoid M₁
inst✝⁴ : AddCommMonoid M₂
inst✝³ : Module R M₁
inst✝² : Module R M₂
v₁ : Basis n R M₁
v₂ : Basis m R M₂
M₃ : Type ?u.2016656
inst✝¹ : AddCommMonoid M₃
inst✝ : Module R M₃
v₃ : Basis l R M₃
f : M₁ →ₗ[R] M₂
x : M₁
⊢ mulVec (↑(toMatrix v₁ v₂) f) ↑(↑v₁.repr x) = ↑(↑v₂.repr (↑f x))

tactic: rw [← Matrix.toLin'_apply, LinearMap.toMatrix, LinearEquiv.trans_apply, Matrix.toLin'_toMatrix',
  LinearEquiv.arrowCongr_apply, v₂.equivFun_apply]
state_before: case h
R : Type u_1
inst✝⁹ : CommSemiring R
l : Type ?u.2016127
m : Type u_4
n : Type u_5
inst✝⁸ : Fintype n
inst✝⁷ : Fintype m
inst✝⁶ : DecidableEq n
M₁ : Type u_2
M₂ : Type u_3
inst✝⁵ : AddCommMonoid M₁
inst✝⁴ : AddCommMonoid M₂
inst✝³ : Module R M₁
inst✝² : Module R M₂
v₁ : Basis n R M₁
v₂ : Basis m R M₂
M₃ : Type ?u.2016656
inst✝¹ : AddCommMonoid M₃
inst✝ : Module R M₃
v₃ : Basis l R M₃
f : M₁ →ₗ[R] M₂
x : M₁
i : m
⊢ mulVec (↑(toMatrix v₁ v₂) f) (↑(↑v₁.repr x)) i = ↑(↑v₂.repr (↑f x)) i

tactic: congr
state_before: case h
R : Type u_1
inst✝⁹ : CommSemiring R
l : Type ?u.2016127
m : Type u_4
n : Type u_5
inst✝⁸ : Fintype n
inst✝⁷ : Fintype m
inst✝⁶ : DecidableEq n
M₁ : Type u_2
M₂ : Type u_3
inst✝⁵ : AddCommMonoid M₁
inst✝⁴ : AddCommMonoid M₂
inst✝³ : Module R M₁
inst✝² : Module R M₂
v₁ : Basis n R M₁
v₂ : Basis m R M₂
M₃ : Type ?u.2016656
inst✝¹ : AddCommMonoid M₃
inst✝ : Module R M₃
v₃ : Basis l R M₃
f : M₁ →ₗ[R] M₂
x : M₁
i : m
⊢ ↑(↑v₂.repr (↑f (↑(LinearEquiv.symm (Basis.equivFun v₁)) ↑(↑v₁.repr x)))) i = ↑(↑v₂.repr (↑f x)) i

tactic: exact v₁.equivFun.symm_apply_apply x
state_before: case h.e_a.h.e_6.h.h.e_6.h
R : Type u_1
inst✝⁹ : CommSemiring R
l : Type ?u.2016127
m : Type u_4
n : Type u_5
inst✝⁸ : Fintype n
inst✝⁷ : Fintype m
inst✝⁶ : DecidableEq n
M₁ : Type u_2
M₂ : Type u_3
inst✝⁵ : AddCommMonoid M₁
inst✝⁴ : AddCommMonoid M₂
inst✝³ : Module R M₁
inst✝² : Module R M₂
v₁ : Basis n R M₁
v₂ : Basis m R M₂
M₃ : Type ?u.2016656
inst✝¹ : AddCommMonoid M₃
inst✝ : Module R M₃
v₃ : Basis l R M₃
f : M₁ →ₗ[R] M₂
x : M₁
i : m
⊢ ↑(LinearEquiv.symm (Basis.equivFun v₁)) ↑(↑v₁.repr x) = x
Theorem: MeasureTheory.SimpleFunc.nnnorm_approxOn_le
File: Mathlib/MeasureTheory/Function/SimpleFuncDenseLp.lean

tactic: have := edist_approxOn_le hf h₀ x n
state_before: α : Type ?u.8872
β : Type u_2
ι : Type ?u.8878
E : Type u_1
F : Type ?u.8884
𝕜 : Type ?u.8887
inst✝⁵ : MeasurableSpace β
inst✝⁴ : MeasurableSpace E
inst✝³ : NormedAddCommGroup E
inst✝² : NormedAddCommGroup F
q : ℝ
p : ℝ≥0∞
inst✝¹ : OpensMeasurableSpace E
f : β → E
hf : Measurable f
s : Set E
y₀ : E
h₀ : y₀ ∈ s
inst✝ : SeparableSpace ↑s
x : β
n : ℕ
⊢ ‖↑(approxOn f hf s y₀ h₀ n) x - f x‖₊ ≤ ‖f x - y₀‖₊

tactic: rw [edist_comm y₀] at this
state_before: α : Type ?u.8872
β : Type u_2
ι : Type ?u.8878
E : Type u_1
F : Type ?u.8884
𝕜 : Type ?u.8887
inst✝⁵ : MeasurableSpace β
inst✝⁴ : MeasurableSpace E
inst✝³ : NormedAddCommGroup E
inst✝² : NormedAddCommGroup F
q : ℝ
p : ℝ≥0∞
inst✝¹ : OpensMeasurableSpace E
f : β → E
hf : Measurable f
s : Set E
y₀ : E
h₀ : y₀ ∈ s
inst✝ : SeparableSpace ↑s
x : β
n : ℕ
this : edist (↑(approxOn f hf s y₀ h₀ n) x) (f x) ≤ edist y₀ (f x)
⊢ ‖↑(approxOn f hf s y₀ h₀ n) x - f x‖₊ ≤ ‖f x - y₀‖₊

tactic: simp only [edist_nndist, nndist_eq_nnnorm] at this
state_before: α : Type ?u.8872
β : Type u_2
ι : Type ?u.8878
E : Type u_1
F : Type ?u.8884
𝕜 : Type ?u.8887
inst✝⁵ : MeasurableSpace β
inst✝⁴ : MeasurableSpace E
inst✝³ : NormedAddCommGroup E
inst✝² : NormedAddCommGroup F
q : ℝ
p : ℝ≥0∞
inst✝¹ : OpensMeasurableSpace E
f : β → E
hf : Measurable f
s : Set E
y₀ : E
h₀ : y₀ ∈ s
inst✝ : SeparableSpace ↑s
x : β
n : ℕ
this : edist (↑(approxOn f hf s y₀ h₀ n) x) (f x) ≤ edist (f x) y₀
⊢ ‖↑(approxOn f hf s y₀ h₀ n) x - f x‖₊ ≤ ‖f x - y₀‖₊

tactic: exact_mod_cast this
state_before: α : Type ?u.8872
β : Type u_2
ι : Type ?u.8878
E : Type u_1
F : Type ?u.8884
𝕜 : Type ?u.8887
inst✝⁵ : MeasurableSpace β
inst✝⁴ : MeasurableSpace E
inst✝³ : NormedAddCommGroup E
inst✝² : NormedAddCommGroup F
q : ℝ
p : ℝ≥0∞
inst✝¹ : OpensMeasurableSpace E
f : β → E
hf : Measurable f
s : Set E
y₀ : E
h₀ : y₀ ∈ s
inst✝ : SeparableSpace ↑s
x : β
n : ℕ
this : ↑‖↑(approxOn f hf s y₀ h₀ n) x - f x‖₊ ≤ ↑‖f x - y₀‖₊
⊢ ‖↑(approxOn f hf s y₀ h₀ n) x - f x‖₊ ≤ ‖f x - y₀‖₊
Theorem: isGδ_biInter
File: Mathlib/Topology/GDelta.lean

tactic: rw [biInter_eq_iInter]
state_before: α : Type u_2
β : Type ?u.5171
γ : Type ?u.5174
ι : Type u_1
inst✝ : TopologicalSpace α
s : Set ι
hs : Set.Countable s
t : (i : ι) → i ∈ s → Set α
ht : ∀ (i : ι) (hi : i ∈ s), IsGδ (t i hi)
⊢ IsGδ (⋂ (i : ι) (h : i ∈ s), t i h)

tactic: haveI := hs.toEncodable
state_before: α : Type u_2
β : Type ?u.5171
γ : Type ?u.5174
ι : Type u_1
inst✝ : TopologicalSpace α
s : Set ι
hs : Set.Countable s
t : (i : ι) → i ∈ s → Set α
ht : ∀ (i : ι) (hi : i ∈ s), IsGδ (t i hi)
⊢ IsGδ (⋂ (x : ↑s), t ↑x (_ : ↑x ∈ s))

tactic: exact isGδ_iInter fun x => ht x x.2
state_before: α : Type u_2
β : Type ?u.5171
γ : Type ?u.5174
ι : Type u_1
inst✝ : TopologicalSpace α
s : Set ι
hs : Set.Countable s
t : (i : ι) → i ∈ s → Set α
ht : ∀ (i : ι) (hi : i ∈ s), IsGδ (t i hi)
this : Encodable ↑s
⊢ IsGδ (⋂ (x : ↑s), t ↑x (_ : ↑x ∈ s))
Theorem: AffineSubspace.sSameSide_vadd_left_iff
File: Mathlib/Analysis/Convex/Side.lean

tactic: rw [SSameSide, SSameSide, wSameSide_vadd_left_iff hv, vadd_mem_iff_mem_of_mem_direction hv]
state_before: R : Type u_1
V : Type u_2
V' : Type ?u.135022
P : Type u_3
P' : Type ?u.135028
inst✝⁶ : StrictOrderedCommRing R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
s : AffineSubspace R P
x y : P
v : V
hv : v ∈ direction s
⊢ SSameSide s (v +ᵥ x) y ↔ SSameSide s x y
Theorem: Array.foldrM_eq_reverse_foldlM_data.aux
File: Std/Data/Array/Init/Lemmas.lean

tactic: unfold foldrM.fold
state_before: m : Type u_1 → Type u_2
α : Type u_3
β : Type u_1
inst✝ : Monad m
f : α → β → m β
arr : Array α
init : β
i : Nat
h : i ≤ size arr
⊢ List.foldlM (fun x y => f y x) init (List.reverse (List.take i arr.data)) = foldrM.fold f arr 0 i h init

tactic: simp [List.foldlM, List.take]
state_before: m : Type u_1 → Type u_2
α : Type u_3
β : Type u_1
inst✝ : Monad m
f : α → β → m β
arr : Array α
init : β
i : Nat
h : 0 ≤ size arr
⊢ List.foldlM (fun x y => f y x) init (List.reverse (List.take 0 arr.data)) =
    if (0 == 0) = true then pure init
    else
      match 0, h with
      | 0, x => pure init
      | Nat.succ i, h =>
        let_fun this := (_ : i < size arr);
        do
        let __do_lift ← f arr[i] init
        foldrM.fold f arr 0 i (_ : i ≤ size arr) __do_lift

tactic: rw [← List.take_concat_get _ _ h]
state_before: m : Type u_1 → Type u_2
α : Type u_3
β : Type u_1
inst✝ : Monad m
f : α → β → m β
arr : Array α
init : β
i✝ i : Nat
h : i + 1 ≤ size arr
⊢ List.foldlM (fun x y => f y x) init (List.reverse (List.take (i + 1) arr.data)) =
    if (i + 1 == 0) = true then pure init
    else
      match i + 1, h with
      | 0, x => pure init
      | Nat.succ i, h =>
        let_fun this := (_ : i < size arr);
        do
        let __do_lift ← f arr[i] init
        foldrM.fold f arr 0 i (_ : i ≤ size arr) __do_lift

tactic: rfl
state_before: m : Type u_1 → Type u_2
α : Type u_3
β : Type u_1
inst✝ : Monad m
f : α → β → m β
arr : Array α
init : β
i✝ i : Nat
h : i + 1 ≤ size arr
⊢ (do
      let s' ← f arr.data[i] init
      List.foldrM (fun x y => f x y) s' (List.take i arr.data)) =
    if i + 1 = 0 then pure init
    else do
      let s' ← f arr[i] init
      List.foldrM (fun x y => f x y) s' (List.take i arr.data)
Theorem: UniformContinuous.mul
File: Mathlib/Topology/Algebra/UniformGroup.lean

tactic: have : UniformContinuous fun x => f x / (g x)⁻¹ := hf.div hg.inv
state_before: α : Type u_2
β : Type u_1
inst✝³ : UniformSpace α
inst✝² : Group α
inst✝¹ : UniformGroup α
inst✝ : UniformSpace β
f g : β → α
hf : UniformContinuous f
hg : UniformContinuous g
⊢ UniformContinuous fun x => f x * g x

tactic: simp_all
state_before: α : Type u_2
β : Type u_1
inst✝³ : UniformSpace α
inst✝² : Group α
inst✝¹ : UniformGroup α
inst✝ : UniformSpace β
f g : β → α
hf : UniformContinuous f
hg : UniformContinuous g
this : UniformContinuous fun x => f x / (g x)⁻¹
⊢ UniformContinuous fun x => f x * g x