tasksource/leandojo huggingface dataset:
Theorem: PFunctor.M.agree'_refl
File: Mathlib/Data/PFunctor/Univariate/M.lean

tactic: induction' n with _ n_ih generalizing x <;>
induction x using PFunctor.M.casesOn' <;> constructor <;> try rfl
state_before: F : PFunctor
X : Type ?u.16870
f : X → Obj F X
n : ℕ
x : M F
⊢ Agree' n x x

tactic: intros
state_before: case succ.f.a
F : PFunctor
X : Type ?u.16870
f : X → Obj F X
x : M F
n✝ : ℕ
n_ih : ∀ (x : M F), Agree' n✝ x x
a✝ : F.A
f✝ : B F a✝ → M F
⊢ ∀ (i : B F a✝), Agree' n✝ (f✝ i) (f✝ i)

tactic: apply n_ih
state_before: case succ.f.a
F : PFunctor
X : Type ?u.16870
f : X → Obj F X
x : M F
n✝ : ℕ
n_ih : ∀ (x : M F), Agree' n✝ x x
a✝ : F.A
f✝ : B F a✝ → M F
i✝ : B F a✝
⊢ Agree' n✝ (f✝ i✝) (f✝ i✝)

tactic: rfl
state_before: case succ.f.a
F : PFunctor
X : Type ?u.16870
f : X → Obj F X
x : M F
n✝ : ℕ
n_ih : ∀ (x : M F), Agree' n✝ x x
a✝ : F.A
f✝ : B F a✝ → M F
⊢ ∀ (i : B F a✝), Agree' n✝ (f✝ i) (f✝ i)
Theorem: lt_isLUB_iff
File: Mathlib/Order/Bounds/Basic.lean

tactic: simp_rw [← not_le, isLUB_le_iff h, mem_upperBounds, not_forall, not_le, exists_prop]
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝ : LinearOrder α
s : Set α
a b : α
h : IsLUB s a
⊢ b < a ↔ ∃ c, c ∈ s ∧ b < c
Theorem: Nat.choose_le_middle
File: Mathlib/Data/Nat/Choose/Basic.lean

tactic: cases' le_or_gt r n with b b
state_before: r n : ℕ
⊢ choose n r ≤ choose n (n / 2)

tactic: cases' le_or_lt r (n / 2) with a h
state_before: case inl
r n : ℕ
b : r ≤ n
⊢ choose n r ≤ choose n (n / 2)

tactic: apply choose_le_middle_of_le_half_left a
state_before: case inl.inl
r n : ℕ
b : r ≤ n
a : r ≤ n / 2
⊢ choose n r ≤ choose n (n / 2)

tactic: rw [← choose_symm b]
state_before: case inl.inr
r n : ℕ
b : r ≤ n
h : n / 2 < r
⊢ choose n r ≤ choose n (n / 2)

tactic: apply choose_le_middle_of_le_half_left
state_before: case inl.inr
r n : ℕ
b : r ≤ n
h : n / 2 < r
⊢ choose n (n - r) ≤ choose n (n / 2)

tactic: rw [div_lt_iff_lt_mul' zero_lt_two] at h
state_before: case inl.inr.hr
r n : ℕ
b : r ≤ n
h : n / 2 < r
⊢ n - r ≤ n / 2

tactic: rw [le_div_iff_mul_le' zero_lt_two, tsub_mul, tsub_le_iff_tsub_le, mul_two,
  add_tsub_cancel_right]
state_before: case inl.inr.hr
r n : ℕ
b : r ≤ n
h : n < r * 2
⊢ n - r ≤ n / 2

tactic: exact le_of_lt h
state_before: case inl.inr.hr
r n : ℕ
b : r ≤ n
h : n < r * 2
⊢ n ≤ r * 2

tactic: rw [choose_eq_zero_of_lt b]
state_before: case inr
r n : ℕ
b : r > n
⊢ choose n r ≤ choose n (n / 2)

tactic: apply zero_le
state_before: case inr
r n : ℕ
b : r > n
⊢ 0 ≤ choose n (n / 2)
Theorem: List.cons_diff
File: Std/Data/List/Lemmas.lean

tactic: induction l₂ generalizing l₁ with
| nil => rfl
| cons b l₂ ih => by_cases h : a = b <;> simp [*, eq_comm]
state_before: α : Type u_1
inst✝ : DecidableEq α
a : α
l₁ l₂ : List α
⊢ List.diff (a :: l₁) l₂ = if a ∈ l₂ then List.diff l₁ (List.erase l₂ a) else a :: List.diff l₁ l₂

tactic: rfl
state_before: case nil
α : Type u_1
inst✝ : DecidableEq α
a : α
l₁ : List α
⊢ List.diff (a :: l₁) [] = if a ∈ [] then List.diff l₁ (List.erase [] a) else a :: List.diff l₁ []

tactic: by_cases h : a = b <;> simp [*, eq_comm]
state_before: case cons
α : Type u_1
inst✝ : DecidableEq α
a b : α
l₂ : List α
ih : ∀ (l₁ : List α), List.diff (a :: l₁) l₂ = if a ∈ l₂ then List.diff l₁ (List.erase l₂ a) else a :: List.diff l₁ l₂
l₁ : List α
⊢ List.diff (a :: l₁) (b :: l₂) =
    if a ∈ b :: l₂ then List.diff l₁ (List.erase (b :: l₂) a) else a :: List.diff l₁ (b :: l₂)
Theorem: mem_closure_iff_ultrafilter
File: Mathlib/Topology/Basic.lean

tactic: simp [closure_eq_cluster_pts, ClusterPt, ← exists_ultrafilter_iff, and_comm]
state_before: α : Type u
β : Type v
ι : Sort w
a : α
s✝ s₁ s₂ t : Set α
p p₁ p₂ : α → Prop
inst✝ : TopologicalSpace α
s : Set α
x : α
⊢ x ∈ closure s ↔ ∃ u, s ∈ u ∧ ↑u ≤ 𝓝 x
Theorem: List.countp_eq_length
File: Mathlib/Data/List/Count.lean

tactic: rw [countp_eq_length_filter, filter_length_eq_length]
state_before: α : Type u_1
l : List α
p q : α → Bool
⊢ countp p l = length l ↔ ∀ (a : α), a ∈ l → p a = true
Theorem: iSup_disjoint_iff
File: Mathlib/Order/CompleteBooleanAlgebra.lean

tactic: simp only [disjoint_iff, iSup_inf_eq, iSup_eq_bot]
state_before: α : Type u
β : Type v
ι : Sort w
κ : ι → Sort ?u.7410
inst✝ : Frame α
s t : Set α
a b : α
f : ι → α
⊢ Disjoint (⨆ (i : ι), f i) a ↔ ∀ (i : ι), Disjoint (f i) a
Theorem: List.unzip_enum_eq_prod
File: Mathlib/Data/List/Range.lean

tactic: simp only [enum_eq_zip_range, unzip_zip, length_range]
state_before: α : Type u
l : List α
⊢ unzip (enum l) = (range (length l), l)
Theorem: Set.singleton_sigma
File: Mathlib/Data/Set/Sigma.lean

tactic: constructor
state_before: ι : Type u_1
ι' : Type ?u.6266
α : ι → Type u_2
β : ι → Type ?u.6276
s s₁ s₂ : Set ι
t t₁ t₂ : (i : ι) → Set (α i)
u : Set ((i : ι) × α i)
x✝ : (i : ι) × α i
i j : ι
a : α i
x : (i : ι) × α i
⊢ x ∈ Set.Sigma {i} t ↔ x ∈ Sigma.mk i '' t i

tactic: obtain ⟨j, a⟩ := x
state_before: case mp
ι : Type u_1
ι' : Type ?u.6266
α : ι → Type u_2
β : ι → Type ?u.6276
s s₁ s₂ : Set ι
t t₁ t₂ : (i : ι) → Set (α i)
u : Set ((i : ι) × α i)
x✝ : (i : ι) × α i
i j : ι
a : α i
x : (i : ι) × α i
⊢ x ∈ Set.Sigma {i} t → x ∈ Sigma.mk i '' t i

tactic: rintro ⟨rfl : j = i, ha⟩
state_before: case mp.mk
ι : Type u_1
ι' : Type ?u.6266
α : ι → Type u_2
β : ι → Type ?u.6276
s s₁ s₂ : Set ι
t t₁ t₂ : (i : ι) → Set (α i)
u : Set ((i : ι) × α i)
x : (i : ι) × α i
i j✝ : ι
a✝ : α i
j : ι
a : α j
⊢ { fst := j, snd := a } ∈ Set.Sigma {i} t → { fst := j, snd := a } ∈ Sigma.mk i '' t i

tactic: exact mem_image_of_mem _ ha
state_before: case mp.mk.intro
ι : Type u_1
ι' : Type ?u.6266
α : ι → Type u_2
β : ι → Type ?u.6276
s s₁ s₂ : Set ι
t t₁ t₂ : (i : ι) → Set (α i)
u : Set ((i : ι) × α i)
x : (i : ι) × α i
j✝ j : ι
a✝ : α j
ha : { fst := j, snd := a✝ }.snd ∈ t { fst := j, snd := a✝ }.fst
a : α j
⊢ { fst := j, snd := a✝ } ∈ Sigma.mk j '' t j

tactic: rintro ⟨b, hb, rfl⟩
state_before: case mpr
ι : Type u_1
ι' : Type ?u.6266
α : ι → Type u_2
β : ι → Type ?u.6276
s s₁ s₂ : Set ι
t t₁ t₂ : (i : ι) → Set (α i)
u : Set ((i : ι) × α i)
x✝ : (i : ι) × α i
i j : ι
a : α i
x : (i : ι) × α i
⊢ x ∈ Sigma.mk i '' t i → x ∈ Set.Sigma {i} t

tactic: exact ⟨rfl, hb⟩
state_before: case mpr.intro.intro
ι : Type u_1
ι' : Type ?u.6266
α : ι → Type u_2
β : ι → Type ?u.6276
s s₁ s₂ : Set ι
t t₁ t₂ : (i : ι) → Set (α i)
u : Set ((i : ι) × α i)
x : (i : ι) × α i
i j : ι
a b : α i
hb : b ∈ t i
⊢ { fst := i, snd := b } ∈ Set.Sigma {i} t
Theorem: Finset.card_pow_le'
File: Mathlib/Combinatorics/Additive/PluenneckeRuzsa.lean

tactic: simpa only [_root_.pow_zero, div_one] using card_pow_div_pow_le' hA _ _ 0
state_before: α : Type u_1
inst✝¹ : CommGroup α
inst✝ : DecidableEq α
A B✝ C : Finset α
hA : Finset.Nonempty A
B : Finset α
n : ℕ
⊢ ↑(card (B ^ n)) ≤ (↑(card (A / B)) / ↑(card A)) ^ n * ↑(card A)
Theorem: Continuous.matrix_det
File: Mathlib/Topology/Instances/Matrix.lean

tactic: simp_rw [Matrix.det_apply]
state_before: X : Type u_3
α : Type ?u.24141
l : Type ?u.24144
m : Type ?u.24147
n : Type u_1
p : Type ?u.24153
S : Type ?u.24156
R : Type u_2
m' : l → Type ?u.24164
n' : l → Type ?u.24169
inst✝⁵ : TopologicalSpace X
inst✝⁴ : TopologicalSpace R
inst✝³ : Fintype n
inst✝² : DecidableEq n
inst✝¹ : CommRing R
inst✝ : TopologicalRing R
A : X → Matrix n n R
hA : Continuous A
⊢ Continuous fun x => det (A x)

tactic: refine' continuous_finset_sum _ fun l _ => Continuous.const_smul _ _
state_before: X : Type u_3
α : Type ?u.24141
l : Type ?u.24144
m : Type ?u.24147
n : Type u_1
p : Type ?u.24153
S : Type ?u.24156
R : Type u_2
m' : l → Type ?u.24164
n' : l → Type ?u.24169
inst✝⁵ : TopologicalSpace X
inst✝⁴ : TopologicalSpace R
inst✝³ : Fintype n
inst✝² : DecidableEq n
inst✝¹ : CommRing R
inst✝ : TopologicalRing R
A : X → Matrix n n R
hA : Continuous A
⊢ Continuous fun x =>
    Finset.sum Finset.univ fun x_1 => ↑Equiv.Perm.sign x_1 • Finset.prod Finset.univ fun x_2 => A x (↑x_1 x_2) x_2

tactic: refine' continuous_finset_prod _ fun l _ => hA.matrix_elem _ _
state_before: X : Type u_3
α : Type ?u.24141
l✝ : Type ?u.24144
m : Type ?u.24147
n : Type u_1
p : Type ?u.24153
S : Type ?u.24156
R : Type u_2
m' : l✝ → Type ?u.24164
n' : l✝ → Type ?u.24169
inst✝⁵ : TopologicalSpace X
inst✝⁴ : TopologicalSpace R
inst✝³ : Fintype n
inst✝² : DecidableEq n
inst✝¹ : CommRing R
inst✝ : TopologicalRing R
A : X → Matrix n n R
hA : Continuous A
l : Equiv.Perm n
x✝ : l ∈ Finset.univ
⊢ Continuous fun x => Finset.prod Finset.univ fun x_1 => A x (↑l x_1) x_1
Theorem: Vector.toList_cons
File: Mathlib/Data/Vector.lean

tactic: cases v
state_before: α : Type u
β : Type v
φ : Type w
n : ℕ
a : α
v : Vector α n
⊢ toList (cons a v) = a :: toList v

tactic: rfl
state_before: case mk
α : Type u
β : Type v
φ : Type w
n : ℕ
a : α
val✝ : List α
property✝ : List.length val✝ = n
⊢ toList (cons a { val := val✝, property := property✝ }) = a :: toList { val := val✝, property := property✝ }
Theorem: finiteDimensional_of_isCompact_closedBall
File: Mathlib/Analysis/NormedSpace/FiniteDimension.lean

tactic: apply finiteDimensional_of_isCompact_closed_ball₀ 𝕜 rpos
state_before: 𝕜 : Type u
inst✝¹⁰ : NontriviallyNormedField 𝕜
E : Type v
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : NormedSpace 𝕜 E
F : Type w
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedSpace 𝕜 F
F' : Type x
inst✝⁵ : AddCommGroup F'
inst✝⁴ : Module 𝕜 F'
inst✝³ : TopologicalSpace F'
inst✝² : TopologicalAddGroup F'
inst✝¹ : ContinuousSMul 𝕜 F'
inst✝ : CompleteSpace 𝕜
r : ℝ
rpos : 0 < r
c : E
h : IsCompact (Metric.closedBall c r)
⊢ FiniteDimensional 𝕜 E

tactic: have : Continuous fun x => -c + x := continuous_const.add continuous_id
state_before: 𝕜 : Type u
inst✝¹⁰ : NontriviallyNormedField 𝕜
E : Type v
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : NormedSpace 𝕜 E
F : Type w
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedSpace 𝕜 F
F' : Type x
inst✝⁵ : AddCommGroup F'
inst✝⁴ : Module 𝕜 F'
inst✝³ : TopologicalSpace F'
inst✝² : TopologicalAddGroup F'
inst✝¹ : ContinuousSMul 𝕜 F'
inst✝ : CompleteSpace 𝕜
r : ℝ
rpos : 0 < r
c : E
h : IsCompact (Metric.closedBall c r)
⊢ IsCompact (Metric.closedBall 0 r)

tactic: simpa using h.image this
state_before: 𝕜 : Type u
inst✝¹⁰ : NontriviallyNormedField 𝕜
E : Type v
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : NormedSpace 𝕜 E
F : Type w
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedSpace 𝕜 F
F' : Type x
inst✝⁵ : AddCommGroup F'
inst✝⁴ : Module 𝕜 F'
inst✝³ : TopologicalSpace F'
inst✝² : TopologicalAddGroup F'
inst✝¹ : ContinuousSMul 𝕜 F'
inst✝ : CompleteSpace 𝕜
r : ℝ
rpos : 0 < r
c : E
h : IsCompact (Metric.closedBall c r)
this : Continuous fun x => -c + x
⊢ IsCompact (Metric.closedBall 0 r)
Theorem: IsometryEquiv.image_closedBall
File: Mathlib/Topology/MetricSpace/Isometry.lean

tactic: rw [← h.preimage_symm, h.symm.preimage_closedBall, symm_symm]
state_before: ι : Type ?u.1197004
α : Type u
β : Type v
γ : Type w
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
h✝ h : α ≃ᵢ β
x : α
r : ℝ
⊢ ↑h '' Metric.closedBall x r = Metric.closedBall (↑h x) r
Theorem: RingHomInvPair.comp_apply_eq₂
File: Mathlib/Algebra/Ring/CompTypeclasses.lean

tactic: rw [← RingHom.comp_apply, comp_eq₂]
state_before: R₁ : Type u_2
R₂ : Type u_1
R₃ : Type ?u.4227
inst✝³ : Semiring R₁
inst✝² : Semiring R₂
inst✝¹ : Semiring R₃
σ₁₂ : R₁ →+* R₂
σ₂₃ : R₂ →+* R₃
σ₁₃ : R₁ →+* R₃
σ : R₁ →+* R₂
σ' : R₂ →+* R₁
inst✝ : RingHomInvPair σ σ'
x : R₂
⊢ ↑σ (↑σ' x) = x

tactic: simp
state_before: R₁ : Type u_2
R₂ : Type u_1
R₃ : Type ?u.4227
inst✝³ : Semiring R₁
inst✝² : Semiring R₂
inst✝¹ : Semiring R₃
σ₁₂ : R₁ →+* R₂
σ₂₃ : R₂ →+* R₃
σ₁₃ : R₁ →+* R₃
σ : R₁ →+* R₂
σ' : R₂ →+* R₁
inst✝ : RingHomInvPair σ σ'
x : R₂
⊢ ↑(RingHom.id R₂) x = x
Theorem: homology.π_map
File: Mathlib/Algebra/Homology/ImageToKernel.lean

tactic: simp only [homology.π, homology.map, cokernel.π_desc]
state_before: ι : Type ?u.105508
V : Type u
inst✝¹⁹ : Category V
inst✝¹⁸ : HasZeroMorphisms V
A B C : V
f : A ⟶ B
inst✝¹⁷ : HasImage f
g : B ⟶ C
inst✝¹⁶ : HasKernel g
w : f ≫ g = 0
A' B' C' : V
f' : A' ⟶ B'
inst✝¹⁵ : HasImage f'
g' : B' ⟶ C'
inst✝¹⁴ : HasKernel g'
w' : f' ≫ g' = 0
α : Arrow.mk f ⟶ Arrow.mk f'
inst✝¹³ : HasImageMap α
β : Arrow.mk g ⟶ Arrow.mk g'
A₁ B₁ C₁ : V
f₁ : A₁ ⟶ B₁
inst✝¹² : HasImage f₁
g₁ : B₁ ⟶ C₁
inst✝¹¹ : HasKernel g₁
w₁ : f₁ ≫ g₁ = 0
A₂ B₂ C₂ : V
f₂ : A₂ ⟶ B₂
inst✝¹⁰ : HasImage f₂
g₂ : B₂ ⟶ C₂
inst✝⁹ : HasKernel g₂
w₂ : f₂ ≫ g₂ = 0
A₃ B₃ C₃ : V
f₃ : A₃ ⟶ B₃
inst✝⁸ : HasImage f₃
g₃ : B₃ ⟶ C₃
inst✝⁷ : HasKernel g₃
w₃ : f₃ ≫ g₃ = 0
α₁ : Arrow.mk f₁ ⟶ Arrow.mk f₂
inst✝⁶ : HasImageMap α₁
β₁ : Arrow.mk g₁ ⟶ Arrow.mk g₂
α₂ : Arrow.mk f₂ ⟶ Arrow.mk f₃
inst✝⁵ : HasImageMap α₂
β₂ : Arrow.mk g₂ ⟶ Arrow.mk g₃
inst✝⁴ : HasCokernel (imageToKernel f g w)
inst✝³ : HasCokernel (imageToKernel f' g' w')
inst✝² : HasCokernel (imageToKernel f₁ g₁ w₁)
inst✝¹ : HasCokernel (imageToKernel f₂ g₂ w₂)
inst✝ : HasCokernel (imageToKernel f₃ g₃ w₃)
p : α.right = β.left
⊢ π f g w ≫ map w w' α β p = kernelSubobjectMap β ≫ π f' g' w'
Theorem: thickenedIndicator_zero
File: Mathlib/Topology/MetricSpace/ThickenedIndicator.lean

tactic: rw [thickenedIndicator_apply, thickenedIndicatorAux_zero δ_pos E x_out, zero_toNNReal]
state_before: α : Type u_1
inst✝ : PseudoEMetricSpace α
δ : ℝ
δ_pos : 0 < δ
E : Set α
x : α
x_out : ¬x ∈ thickening δ E
⊢ ↑(thickenedIndicator δ_pos E) x = 0
Theorem: Stream'.drop_append_stream
File: Mathlib/Data/Stream/Init.lean

tactic: rfl
state_before: α : Type u
β : Type v
δ : Type w
s : Stream' α
⊢ drop (List.length []) ([] ++ₛ s) = s

tactic: rw [List.length_cons, drop_succ, cons_append_stream, tail_cons, drop_append_stream l s]
state_before: α : Type u
β : Type v
δ : Type w
a : α
l : List α
s : Stream' α
⊢ drop (List.length (a :: l)) (a :: l ++ₛ s) = s
Theorem: EuclideanGeometry.inversion_inversion
File: Mathlib/Geometry/Euclidean/Inversion.lean

tactic: rcases eq_or_ne x c with (rfl | hne)
state_before: V : Type u_2
P : Type u_1
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
a b c✝ d x✝ y z : P
R✝ : ℝ
c : P
R : ℝ
hR : R ≠ 0
x : P
⊢ inversion c R (inversion c R x) = x

tactic: rw [inversion_self, inversion_self]
state_before: case inl
V : Type u_2
P : Type u_1
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
a b c d x✝ y z : P
R✝ R : ℝ
hR : R ≠ 0
x : P
⊢ inversion x R (inversion x R x) = x

tactic: rw [inversion, dist_inversion_center, inversion_vsub_center, smul_smul, ← mul_pow,
  div_mul_div_comm, div_mul_cancel _ (dist_ne_zero.2 hne), ← sq, div_self, one_pow, one_smul,
  vsub_vadd]
state_before: case inr
V : Type u_2
P : Type u_1
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
a b c✝ d x✝ y z : P
R✝ : ℝ
c : P
R : ℝ
hR : R ≠ 0
x : P
hne : x ≠ c
⊢ inversion c R (inversion c R x) = x

tactic: exact pow_ne_zero _ hR
state_before: case inr
V : Type u_2
P : Type u_1
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
a b c✝ d x✝ y z : P
R✝ : ℝ
c : P
R : ℝ
hR : R ≠ 0
x : P
hne : x ≠ c
⊢ R ^ 2 ≠ 0
Theorem: ack_zero
File: Mathlib/Computability/Ackermann.lean

tactic: rw [ack]
state_before: n : ℕ
⊢ ack 0 n = n + 1
Theorem: Matrix.rank_submatrix_le
File: Mathlib/Data/Matrix/Rank.lean

tactic: rw [rank, rank, mulVecLin_submatrix, LinearMap.range_comp, LinearMap.range_comp,
  show LinearMap.funLeft R R e.symm = LinearEquiv.funCongrLeft R R e.symm from rfl,
  LinearEquiv.range, Submodule.map_top]
state_before: l : Type ?u.158986
m : Type u_2
n : Type u_3
o : Type ?u.158995
R : Type u_1
m_fin : Fintype m
inst✝⁴ : Fintype n
inst✝³ : Fintype o
inst✝² : CommRing R
inst✝¹ : StrongRankCondition R
inst✝ : Fintype m
f : n → m
e : n ≃ m
A : Matrix m m R
⊢ rank (submatrix A f ↑e) ≤ rank A

tactic: exact Submodule.finrank_map_le _ _
state_before: l : Type ?u.158986
m : Type u_2
n : Type u_3
o : Type ?u.158995
R : Type u_1
m_fin : Fintype m
inst✝⁴ : Fintype n
inst✝³ : Fintype o
inst✝² : CommRing R
inst✝¹ : StrongRankCondition R
inst✝ : Fintype m
f : n → m
e : n ≃ m
A : Matrix m m R
⊢ finrank R { x // x ∈ Submodule.map (LinearMap.funLeft R R f) (LinearMap.range (mulVecLin A)) } ≤
    finrank R { x // x ∈ LinearMap.range (mulVecLin A) }
Theorem: fderivWithin_const_add
File: Mathlib/Analysis/Calculus/FDeriv/Add.lean

tactic: simpa only [add_comm] using fderivWithin_add_const hxs c
state_before: 𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type ?u.284531
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.284626
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
hxs : UniqueDiffWithinAt 𝕜 s x
c : F
⊢ fderivWithin 𝕜 (fun y => c + f y) s x = fderivWithin 𝕜 f s x
Theorem: Bool.not_or
File: Mathlib/Data/Bool/Basic.lean

tactic: decide
state_before: ⊢ ∀ (a b : Bool), (!decide ((a || b) = (!a && !b))) = true
Theorem: TypeVec.subtypeVal_toSubtype'
File: Mathlib/Data/TypeVec.lean

tactic: ext (i x)
state_before: n : ℕ
α : TypeVec n
r : α ⊗ α ⟹ repeat n Prop
⊢ subtypeVal r ⊚ toSubtype' r = fun i x => prod.mk i (↑x).fst (↑x).snd

tactic: induction i <;> dsimp only [id, toSubtype', comp, subtypeVal, prod.mk] at *
state_before: case a.h
n : ℕ
α : TypeVec n
r : α ⊗ α ⟹ repeat n Prop
i : Fin2 n
x : (fun i => { x // ofRepeat (r i (prod.mk i x.fst x.snd)) }) i
⊢ (subtypeVal r ⊚ toSubtype' r) i x = prod.mk i (↑x).fst (↑x).snd

tactic: simp [*]
state_before: case a.h.fs
n n✝ : ℕ
a✝ : Fin2 n✝
a_ih✝ :
  ∀ {α : TypeVec n✝} (r : α ⊗ α ⟹ repeat n✝ Prop) (x : { x // ofRepeat (r a✝ (prod.mk a✝ x.fst x.snd)) }),
    subtypeVal r a✝ (toSubtype' r a✝ x) = prod.mk a✝ (↑x).fst (↑x).snd
α : TypeVec (Nat.succ n✝)
r : α ⊗ α ⟹ repeat (Nat.succ n✝) Prop
x : { x // ofRepeat (r (Fin2.fs a✝) (prod.mk (Fin2.fs a✝) x.fst x.snd)) }
⊢ subtypeVal (dropFun r) a✝ (toSubtype' (dropFun r) a✝ x) = prod.mk a✝ (↑x).fst (↑x).snd
Theorem: Real.ofReal_le_ennnorm
File: Mathlib/Analysis/Normed/Group/Basic.lean

tactic: obtain hr | hr := le_total 0 r
state_before: 𝓕 : Type ?u.1109820
𝕜 : Type ?u.1109823
α : Type ?u.1109826
ι : Type ?u.1109829
κ : Type ?u.1109832
E : Type ?u.1109835
F : Type ?u.1109838
G : Type ?u.1109841
inst✝¹ : SeminormedCommGroup E
inst✝ : SeminormedCommGroup F
a a₁ a₂ b b₁ b₂ : E
r✝ r₁ r₂ r : ℝ
⊢ ENNReal.ofReal r ≤ ↑‖r‖₊

tactic: exact (Real.ennnorm_eq_ofReal hr).ge
state_before: case inl
𝓕 : Type ?u.1109820
𝕜 : Type ?u.1109823
α : Type ?u.1109826
ι : Type ?u.1109829
κ : Type ?u.1109832
E : Type ?u.1109835
F : Type ?u.1109838
G : Type ?u.1109841
inst✝¹ : SeminormedCommGroup E
inst✝ : SeminormedCommGroup F
a a₁ a₂ b b₁ b₂ : E
r✝ r₁ r₂ r : ℝ
hr : 0 ≤ r
⊢ ENNReal.ofReal r ≤ ↑‖r‖₊

tactic: rw [ENNReal.ofReal_eq_zero.2 hr]
state_before: case inr
𝓕 : Type ?u.1109820
𝕜 : Type ?u.1109823
α : Type ?u.1109826
ι : Type ?u.1109829
κ : Type ?u.1109832
E : Type ?u.1109835
F : Type ?u.1109838
G : Type ?u.1109841
inst✝¹ : SeminormedCommGroup E
inst✝ : SeminormedCommGroup F
a a₁ a₂ b b₁ b₂ : E
r✝ r₁ r₂ r : ℝ
hr : r ≤ 0
⊢ ENNReal.ofReal r ≤ ↑‖r‖₊

tactic: exact bot_le
state_before: case inr
𝓕 : Type ?u.1109820
𝕜 : Type ?u.1109823
α : Type ?u.1109826
ι : Type ?u.1109829
κ : Type ?u.1109832
E : Type ?u.1109835
F : Type ?u.1109838
G : Type ?u.1109841
inst✝¹ : SeminormedCommGroup E
inst✝ : SeminormedCommGroup F
a a₁ a₂ b b₁ b₂ : E
r✝ r₁ r₂ r : ℝ
hr : r ≤ 0
⊢ 0 ≤ ↑‖r‖₊
Theorem: Ordnode.Valid'.dual_iff
File: Mathlib/Data/Ordmap/Ordset.lean

tactic: have := Valid'.dual h
state_before: α : Type u_1
inst✝ : Preorder α
t : Ordnode α
o₁ : WithBot α
o₂ : WithTop α
h : Valid' o₂ (Ordnode.dual t) o₁
⊢ Valid' o₁ t o₂

tactic: rwa [dual_dual, OrderDual.Preorder.dual_dual] at this
state_before: α : Type u_1
inst✝ : Preorder α
t : Ordnode α
o₁ : WithBot α
o₂ : WithTop α
h : Valid' o₂ (Ordnode.dual t) o₁
this : Valid' o₁ (Ordnode.dual (Ordnode.dual t)) o₂
⊢ Valid' o₁ t o₂
Theorem: Associates.sup_mul_inf
File: Mathlib/RingTheory/UniqueFactorizationDomain.lean

tactic: nontriviality α
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
dec_irr : (p : Associates α) → Decidable (Irreducible p)
inst✝ : UniqueFactorizationMonoid α
dec : DecidableEq α
dec' : DecidableEq (Associates α)
a b : Associates α
⊢ FactorSet.prod (factors a ⊔ factors b) * FactorSet.prod (factors a ⊓ factors b) = a * b

tactic: refine' eq_of_factors_eq_factors _
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
dec_irr : (p : Associates α) → Decidable (Irreducible p)
inst✝ : UniqueFactorizationMonoid α
dec : DecidableEq α
dec' : DecidableEq (Associates α)
a b : Associates α
✝ : Nontrivial α
⊢ FactorSet.prod (factors a ⊔ factors b) * FactorSet.prod (factors a ⊓ factors b) = a * b

tactic: rw [← prod_add, prod_factors, factors_mul, FactorSet.sup_add_inf_eq_add]
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
dec_irr : (p : Associates α) → Decidable (Irreducible p)
inst✝ : UniqueFactorizationMonoid α
dec : DecidableEq α
dec' : DecidableEq (Associates α)
a b : Associates α
✝ : Nontrivial α
⊢ factors (FactorSet.prod (factors a ⊔ factors b) * FactorSet.prod (factors a ⊓ factors b)) = factors (a * b)
Theorem: Rat.mkRat_eq_iff
File: Std/Data/Rat/Lemmas.lean

tactic: rw [← normalize_eq_mkRat z₁, ← normalize_eq_mkRat z₂, normalize_eq_iff]
state_before: d₁ d₂ : Nat
n₁ n₂ : Int
z₁ : d₁ ≠ 0
z₂ : d₂ ≠ 0
⊢ mkRat n₁ d₁ = mkRat n₂ d₂ ↔ n₁ * ↑d₂ = n₂ * ↑d₁