tasksource/leandojo huggingface dataset:
Theorem: Set.ncard_eq_succ
File: Mathlib/Data/Set/Ncard.lean

tactic: refine' ⟨eq_insert_of_ncard_eq_succ, _⟩
state_before: α : Type u_1
β : Type ?u.161808
s t : Set α
a b x y : α
f : α → β
n : ℕ
hs : autoParam (Set.Finite s) _auto✝
⊢ ncard s = n + 1 ↔ ∃ a t, ¬a ∈ t ∧ insert a t = s ∧ ncard t = n

tactic: rintro ⟨a, t, hat, h, rfl⟩
state_before: α : Type u_1
β : Type ?u.161808
s t : Set α
a b x y : α
f : α → β
n : ℕ
hs : autoParam (Set.Finite s) _auto✝
⊢ (∃ a t, ¬a ∈ t ∧ insert a t = s ∧ ncard t = n) → ncard s = n + 1

tactic: rw [← h, ncard_insert_of_not_mem hat (hs.subset ((subset_insert a t).trans_eq h))]
state_before: case intro.intro.intro.intro
α : Type u_1
β : Type ?u.161808
s t✝ : Set α
a✝ b x y : α
f : α → β
hs : autoParam (Set.Finite s) _auto✝
a : α
t : Set α
hat : ¬a ∈ t
h : insert a t = s
⊢ ncard s = ncard t + 1
Theorem: ContDiffWithinAt.mono_of_mem
File: Mathlib/Analysis/Calculus/ContDiffDef.lean

tactic: intro m hm
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 : ContDiffWithinAt 𝕜 n f s x
t : Set E
hst : s ∈ 𝓝[t] x
⊢ ContDiffWithinAt 𝕜 n f t x

tactic: rcases h m hm with ⟨u, hu, p, H⟩
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 : ContDiffWithinAt 𝕜 n f s x
t : Set E
hst : s ∈ 𝓝[t] x
m : ℕ
hm : ↑m ≤ n
⊢ ∃ u, u ∈ 𝓝[insert x t] x ∧ ∃ p, HasFTaylorSeriesUpToOn (↑m) f p u

tactic: exact ⟨u, nhdsWithin_le_of_mem (insert_mem_nhdsWithin_insert hst) hu, p, H⟩
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 : ContDiffWithinAt 𝕜 n f s x
t : Set E
hst : s ∈ 𝓝[t] x
m : ℕ
hm : ↑m ≤ n
u : Set E
hu : u ∈ 𝓝[insert x s] x
p : E → FormalMultilinearSeries 𝕜 E F
H : HasFTaylorSeriesUpToOn (↑m) f p u
⊢ ∃ u, u ∈ 𝓝[insert x t] x ∧ ∃ p, HasFTaylorSeriesUpToOn (↑m) f p u
Theorem: List.length_split_le
File: Mathlib/Data/List/Sort.lean

tactic: cases' e : split l with l₁ l₂
state_before: α : Type uu
r : α → α → Prop
inst✝ : DecidableRel r
a : α
l l₁' l₂' : List α
h : split (a :: l) = (l₁', l₂')
⊢ length l₁' ≤ length (a :: l) ∧ length l₂' ≤ length (a :: l)

tactic: injection (split_cons_of_eq _ e).symm.trans h
state_before: case mk
α : Type uu
r : α → α → Prop
inst✝ : DecidableRel r
a : α
l l₁' l₂' : List α
h : split (a :: l) = (l₁', l₂')
l₁ l₂ : List α
e : split l = (l₁, l₂)
⊢ length l₁' ≤ length (a :: l) ∧ length l₂' ≤ length (a :: l)

tactic: substs l₁' l₂'
state_before: case mk
α : Type uu
r : α → α → Prop
inst✝ : DecidableRel r
a : α
l l₁' l₂' : List α
h : split (a :: l) = (l₁', l₂')
l₁ l₂ : List α
e : split l = (l₁, l₂)
fst_eq✝ : a :: l₂ = l₁'
snd_eq✝ : l₁ = l₂'
⊢ length l₁' ≤ length (a :: l) ∧ length l₂' ≤ length (a :: l)

tactic: cases' length_split_le e with h₁ h₂
state_before: case mk
α : Type uu
r : α → α → Prop
inst✝ : DecidableRel r
a : α
l l₁ l₂ : List α
e : split l = (l₁, l₂)
h : split (a :: l) = (a :: l₂, l₁)
⊢ length (a :: l₂) ≤ length (a :: l) ∧ length l₁ ≤ length (a :: l)

tactic: exact ⟨Nat.succ_le_succ h₂, Nat.le_succ_of_le h₁⟩
state_before: case mk.intro
α : Type uu
r : α → α → Prop
inst✝ : DecidableRel r
a : α
l l₁ l₂ : List α
e : split l = (l₁, l₂)
h : split (a :: l) = (a :: l₂, l₁)
h₁ : length l₁ ≤ length l
h₂ : length l₂ ≤ length l
⊢ length (a :: l₂) ≤ length (a :: l) ∧ length l₁ ≤ length (a :: l)
Theorem: Multiset.untrop_sum
File: Mathlib/Algebra/Tropical/BigOperators.lean

tactic: induction' s using Multiset.induction with s x IH
state_before: R : Type u_1
S : Type ?u.37156
inst✝¹ : LinearOrder R
inst✝ : OrderTop R
s : Multiset (Tropical R)
⊢ untrop (sum s) = inf (map untrop s)

tactic: simp
state_before: case empty
R : Type u_1
S : Type ?u.37156
inst✝¹ : LinearOrder R
inst✝ : OrderTop R
⊢ untrop (sum 0) = inf (map untrop 0)

tactic: simp only [sum_cons, ge_iff_le, untrop_add, untrop_le_iff, map_cons, inf_cons, ← IH]
state_before: case cons
R : Type u_1
S : Type ?u.37156
inst✝¹ : LinearOrder R
inst✝ : OrderTop R
s : Tropical R
x : Multiset (Tropical R)
IH : untrop (sum x) = inf (map untrop x)
⊢ untrop (sum (s ::ₘ x)) = inf (map untrop (s ::ₘ x))

tactic: rfl
state_before: case cons
R : Type u_1
S : Type ?u.37156
inst✝¹ : LinearOrder R
inst✝ : OrderTop R
s : Tropical R
x : Multiset (Tropical R)
IH : untrop (sum x) = inf (map untrop x)
⊢ min (untrop s) (untrop (sum x)) = untrop s ⊓ untrop (sum x)
Theorem: List.foldr_hom₂
File: Mathlib/Data/List/Basic.lean

tactic: revert a
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
l : List ι
f : α → β → γ
op₁ : ι → α → α
op₂ : ι → β → β
op₃ : ι → γ → γ
a : α
b : β
h : ∀ (a : α) (b : β) (i : ι), f (op₁ i a) (op₂ i b) = op₃ i (f a b)
⊢ foldr op₃ (f a b) l = f (foldr op₁ a l) (foldr op₂ b l)

tactic: induction l <;> intros <;> [rfl; simp only [*, foldr]]
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
l : List ι
f : α → β → γ
op₁ : ι → α → α
op₂ : ι → β → β
op₃ : ι → γ → γ
b : β
h : ∀ (a : α) (b : β) (i : ι), f (op₁ i a) (op₂ i b) = op₃ i (f a b)
⊢ ∀ (a : α), foldr op₃ (f a b) l = f (foldr op₁ a l) (foldr op₂ b l)
Theorem: PEquiv.inj
File: Mathlib/Data/PEquiv.lean

tactic: rw [← mem_iff_mem] at *
state_before: α : Type u
β : Type v
γ : Type w
δ : Type x
f : α ≃. β
a₁ a₂ : α
b : β
h₁ : b ∈ ↑f a₁
h₂ : b ∈ ↑f a₂
⊢ a₁ = a₂

tactic: cases h : f.symm b <;> simp_all
state_before: α : Type u
β : Type v
γ : Type w
δ : Type x
f : α ≃. β
a₁ a₂ : α
b : β
h₁ : a₁ ∈ ↑(PEquiv.symm f) b
h₂ : a₂ ∈ ↑(PEquiv.symm f) b
⊢ a₁ = a₂
Theorem: NNReal.nndist_eq
File: Mathlib/Topology/MetricSpace/Basic.lean

tactic: simp only [← NNReal.coe_le_coe, coe_nndist, dist_eq, max_le_iff, abs_sub_le_iff,
  tsub_le_iff_right, NNReal.coe_add]
state_before: α : Type u
β : Type v
X : Type ?u.237706
ι : Type ?u.237709
inst✝ : PseudoMetricSpace α
a b x✝ : ℝ≥0
⊢ nndist a b ≤ x✝ ↔ max (a - b) (b - a) ≤ x✝
Theorem: MvPolynomial.C_mul_X_pow_eq_monomial
File: Mathlib/Data/MvPolynomial/Basic.lean

tactic: rw [← zero_add (Finsupp.single s n), monomial_add_single, C_apply]
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
s : σ
a : R
n : ℕ
⊢ ↑C a * X s ^ n = ↑(monomial (Finsupp.single s n)) a
Theorem: Finset.not_mem_sigmaLift_of_ne_left
File: Mathlib/Data/Finset/Sigma.lean

tactic: rw [mem_sigmaLift]
state_before: ι : Type u_2
α : ι → Type u_3
β : ι → Type u_4
γ : ι → Type u_1
inst✝ : DecidableEq ι
f : ⦃i : ι⦄ → α i → β i → Finset (γ i)
a : Sigma α
b : Sigma β
x : Sigma γ
h : a.fst ≠ x.fst
⊢ ¬x ∈ sigmaLift f a b

tactic: exact fun H => h H.fst
state_before: ι : Type u_2
α : ι → Type u_3
β : ι → Type u_4
γ : ι → Type u_1
inst✝ : DecidableEq ι
f : ⦃i : ι⦄ → α i → β i → Finset (γ i)
a : Sigma α
b : Sigma β
x : Sigma γ
h : a.fst ≠ x.fst
⊢ ¬∃ ha hb, x.snd ∈ f (ha ▸ a.snd) (hb ▸ b.snd)
Theorem: finrank_span_finset_eq_card
File: Mathlib/LinearAlgebra/Finrank.lean

tactic: convert finrank_span_set_eq_card (s : Set V) hs
state_before: K : Type u
V : Type v
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
s : Finset V
hs : LinearIndependent K Subtype.val
⊢ finrank K { x // x ∈ span K ↑s } = Finset.card s

tactic: ext
state_before: case h.e'_3.h.e'_2
K : Type u
V : Type v
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
s : Finset V
hs : LinearIndependent K Subtype.val
⊢ s = Set.toFinset ↑s

tactic: simp
state_before: case h.e'_3.h.e'_2.a
K : Type u
V : Type v
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
s : Finset V
hs : LinearIndependent K Subtype.val
a✝ : V
⊢ a✝ ∈ s ↔ a✝ ∈ Set.toFinset ↑s
Theorem: Relation.flip_comp
File: Mathlib/Logic/Relation.lean

tactic: funext c a
state_before: α : Type u_1
β : Type u_3
γ : Type u_2
δ : Type ?u.12462
r : α → β → Prop
p : β → γ → Prop
q : γ → δ → Prop
⊢ flip (r ∘r p) = flip p ∘r flip r

tactic: apply propext
state_before: case h.h
α : Type u_1
β : Type u_3
γ : Type u_2
δ : Type ?u.12462
r : α → β → Prop
p : β → γ → Prop
q : γ → δ → Prop
c : γ
a : α
⊢ flip (r ∘r p) c a = (flip p ∘r flip r) c a

tactic: constructor
state_before: case h.h.a
α : Type u_1
β : Type u_3
γ : Type u_2
δ : Type ?u.12462
r : α → β → Prop
p : β → γ → Prop
q : γ → δ → Prop
c : γ
a : α
⊢ flip (r ∘r p) c a ↔ (flip p ∘r flip r) c a

tactic: exact fun ⟨b, hab, hbc⟩ ↦ ⟨b, hbc, hab⟩
state_before: case h.h.a.mp
α : Type u_1
β : Type u_3
γ : Type u_2
δ : Type ?u.12462
r : α → β → Prop
p : β → γ → Prop
q : γ → δ → Prop
c : γ
a : α
⊢ flip (r ∘r p) c a → (flip p ∘r flip r) c a

case h.h.a.mpr
α : Type u_1
β : Type u_3
γ : Type u_2
δ : Type ?u.12462
r : α → β → Prop
p : β → γ → Prop
q : γ → δ → Prop
c : γ
a : α
⊢ (flip p ∘r flip r) c a → flip (r ∘r p) c a

tactic: exact fun ⟨b, hbc, hab⟩ ↦ ⟨b, hab, hbc⟩
state_before: case h.h.a.mpr
α : Type u_1
β : Type u_3
γ : Type u_2
δ : Type ?u.12462
r : α → β → Prop
p : β → γ → Prop
q : γ → δ → Prop
c : γ
a : α
⊢ (flip p ∘r flip r) c a → flip (r ∘r p) c a
Theorem: Finsupp.mem_supported_support
File: Mathlib/LinearAlgebra/Finsupp.lean

tactic: rw [Finsupp.mem_supported]
state_before: α : Type u_1
M : Type u_2
N : Type ?u.60317
P : Type ?u.60320
R : Type u_3
S : Type ?u.60326
inst✝⁷ : Semiring R
inst✝⁶ : Semiring S
inst✝⁵ : AddCommMonoid M
inst✝⁴ : Module R M
inst✝³ : AddCommMonoid N
inst✝² : Module R N
inst✝¹ : AddCommMonoid P
inst✝ : Module R P
p : α →₀ M
⊢ p ∈ supported M R ↑p.support
Theorem: Set.sigma_diff_sigma
File: Mathlib/Data/Set/Sigma.lean

tactic: by_cases h₁ : x.1 ∈ s₁ <;> by_cases h₂ : x.2 ∈ t₁ x.1 <;> simp [*, ← imp_iff_or_not]
state_before: ι : Type u_1
ι' : Type ?u.32460
α : ι → Type u_2
β : ι → Type ?u.32470
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 s₁ t₁ \ Set.Sigma s₂ t₂ ↔ x ∈ Set.Sigma s₁ (t₁ \ t₂) ∪ Set.Sigma (s₁ \ s₂) t₁
Theorem: Metric.hausdorffDist_le_diam
File: Mathlib/Topology/MetricSpace/HausdorffDistance.lean

tactic: rcases hs with ⟨x, xs⟩
state_before: ι : Sort ?u.77842
α : Type u
β : Type v
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
s t u : Set α
x y : α
Φ : α → β
hs : Set.Nonempty s
bs : Bounded s
ht : Set.Nonempty t
bt : Bounded t
⊢ hausdorffDist s t ≤ diam (s ∪ t)

tactic: rcases ht with ⟨y, yt⟩
state_before: case intro
ι : Sort ?u.77842
α : Type u
β : Type v
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
s t u : Set α
x✝ y : α
Φ : α → β
bs : Bounded s
ht : Set.Nonempty t
bt : Bounded t
x : α
xs : x ∈ s
⊢ hausdorffDist s t ≤ diam (s ∪ t)

tactic: refine hausdorffDist_le_of_mem_dist diam_nonneg ?_ ?_
state_before: case intro.intro
ι : Sort ?u.77842
α : Type u
β : Type v
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
s t u : Set α
x✝ y✝ : α
Φ : α → β
bs : Bounded s
bt : Bounded t
x : α
xs : x ∈ s
y : α
yt : y ∈ t
⊢ hausdorffDist s t ≤ diam (s ∪ t)

tactic: exact fun z hz => ⟨y, yt,
  dist_le_diam_of_mem (bounded_union.2 ⟨bs, bt⟩) (subset_union_left _ _ hz)
    (subset_union_right _ _ yt)⟩
state_before: case intro.intro.refine_1
ι : Sort ?u.77842
α : Type u
β : Type v
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
s t u : Set α
x✝ y✝ : α
Φ : α → β
bs : Bounded s
bt : Bounded t
x : α
xs : x ∈ s
y : α
yt : y ∈ t
⊢ ∀ (x : α), x ∈ s → ∃ y, y ∈ t ∧ dist x y ≤ diam (s ∪ t)

tactic: exact fun z hz => ⟨x, xs,
  dist_le_diam_of_mem (bounded_union.2 ⟨bs, bt⟩) (subset_union_right _ _ hz)
    (subset_union_left _ _ xs)⟩
state_before: case intro.intro.refine_2
ι : Sort ?u.77842
α : Type u
β : Type v
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
s t u : Set α
x✝ y✝ : α
Φ : α → β
bs : Bounded s
bt : Bounded t
x : α
xs : x ∈ s
y : α
yt : y ∈ t
⊢ ∀ (x : α), x ∈ t → ∃ y, y ∈ s ∧ dist x y ≤ diam (s ∪ t)
Theorem: CartanMatrix.Relations.adF_of_eq_eq_zero
File: Mathlib/Algebra/Lie/CartanMatrix.lean

tactic: have h' : (-2 : ℤ).toNat = 0 := by rfl
state_before: R : Type u
B : Type v
inst✝² : CommRing R
inst✝¹ : DecidableEq B
inst✝ : Fintype B
A : Matrix B B ℤ
i : B
h : A i i = 2
⊢ adF R A (i, i) = 0

tactic: simp [adF, h, h']
state_before: R : Type u
B : Type v
inst✝² : CommRing R
inst✝¹ : DecidableEq B
inst✝ : Fintype B
A : Matrix B B ℤ
i : B
h : A i i = 2
h' : Int.toNat (-2) = 0
⊢ adF R A (i, i) = 0

tactic: rfl
state_before: R : Type u
B : Type v
inst✝² : CommRing R
inst✝¹ : DecidableEq B
inst✝ : Fintype B
A : Matrix B B ℤ
i : B
h : A i i = 2
⊢ Int.toNat (-2) = 0
Theorem: gramSchmidt_triangular
File: Mathlib/Analysis/InnerProductSpace/GramSchmidtOrtho.lean

tactic: have : gramSchmidt 𝕜 b i ∈ span 𝕜 (gramSchmidt 𝕜 b '' Set.Iio j) :=
  subset_span ((Set.mem_image _ _ _).2 ⟨i, hij, rfl⟩)
state_before: 𝕜 : Type u_2
E : Type u_3
inst✝⁵ : IsROrC 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : InnerProductSpace 𝕜 E
ι : Type u_1
inst✝² : LinearOrder ι
inst✝¹ : LocallyFiniteOrderBot ι
inst✝ : IsWellOrder ι fun x x_1 => x < x_1
i j : ι
hij : i < j
b : Basis ι 𝕜 E
⊢ ↑(↑b.repr (gramSchmidt 𝕜 (↑b) i)) j = 0

tactic: have : gramSchmidt 𝕜 b i ∈ span 𝕜 (b '' Set.Iio j) := by rwa [← span_gramSchmidt_Iio 𝕜 b j]
state_before: 𝕜 : Type u_2
E : Type u_3
inst✝⁵ : IsROrC 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : InnerProductSpace 𝕜 E
ι : Type u_1
inst✝² : LinearOrder ι
inst✝¹ : LocallyFiniteOrderBot ι
inst✝ : IsWellOrder ι fun x x_1 => x < x_1
i j : ι
hij : i < j
b : Basis ι 𝕜 E
this : gramSchmidt 𝕜 (↑b) i ∈ span 𝕜 (gramSchmidt 𝕜 ↑b '' Set.Iio j)
⊢ ↑(↑b.repr (gramSchmidt 𝕜 (↑b) i)) j = 0

tactic: have : ↑(b.repr (gramSchmidt 𝕜 b i)).support ⊆ Set.Iio j :=
  Basis.repr_support_subset_of_mem_span b (Set.Iio j) this
state_before: 𝕜 : Type u_2
E : Type u_3
inst✝⁵ : IsROrC 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : InnerProductSpace 𝕜 E
ι : Type u_1
inst✝² : LinearOrder ι
inst✝¹ : LocallyFiniteOrderBot ι
inst✝ : IsWellOrder ι fun x x_1 => x < x_1
i j : ι
hij : i < j
b : Basis ι 𝕜 E
this✝ : gramSchmidt 𝕜 (↑b) i ∈ span 𝕜 (gramSchmidt 𝕜 ↑b '' Set.Iio j)
this : gramSchmidt 𝕜 (↑b) i ∈ span 𝕜 (↑b '' Set.Iio j)
⊢ ↑(↑b.repr (gramSchmidt 𝕜 (↑b) i)) j = 0

tactic: exact (Finsupp.mem_supported' _ _).1 ((Finsupp.mem_supported 𝕜 _).2 this) j Set.not_mem_Iio_self
state_before: 𝕜 : Type u_2
E : Type u_3
inst✝⁵ : IsROrC 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : InnerProductSpace 𝕜 E
ι : Type u_1
inst✝² : LinearOrder ι
inst✝¹ : LocallyFiniteOrderBot ι
inst✝ : IsWellOrder ι fun x x_1 => x < x_1
i j : ι
hij : i < j
b : Basis ι 𝕜 E
this✝¹ : gramSchmidt 𝕜 (↑b) i ∈ span 𝕜 (gramSchmidt 𝕜 ↑b '' Set.Iio j)
this✝ : gramSchmidt 𝕜 (↑b) i ∈ span 𝕜 (↑b '' Set.Iio j)
this : ↑(↑b.repr (gramSchmidt 𝕜 (↑b) i)).support ⊆ Set.Iio j
⊢ ↑(↑b.repr (gramSchmidt 𝕜 (↑b) i)) j = 0

tactic: rwa [← span_gramSchmidt_Iio 𝕜 b j]
state_before: 𝕜 : Type u_2
E : Type u_3
inst✝⁵ : IsROrC 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : InnerProductSpace 𝕜 E
ι : Type u_1
inst✝² : LinearOrder ι
inst✝¹ : LocallyFiniteOrderBot ι
inst✝ : IsWellOrder ι fun x x_1 => x < x_1
i j : ι
hij : i < j
b : Basis ι 𝕜 E
this : gramSchmidt 𝕜 (↑b) i ∈ span 𝕜 (gramSchmidt 𝕜 ↑b '' Set.Iio j)
⊢ gramSchmidt 𝕜 (↑b) i ∈ span 𝕜 (↑b '' Set.Iio j)
Theorem: MeasureTheory.Measure.restrict_finset_biUnion_congr
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: induction' s using Finset.induction_on with i s _ hs
state_before: α : Type u_2
β : Type ?u.310858
γ : Type ?u.310861
δ : Type ?u.310864
ι : Type u_1
R : Type ?u.310870
R' : Type ?u.310873
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t✝ : Set α
s : Finset ι
t : ι → Set α
⊢ restrict μ (⋃ (i : ι) (_ : i ∈ s), t i) = restrict ν (⋃ (i : ι) (_ : i ∈ s), t i) ↔
    ∀ (i : ι), i ∈ s → restrict μ (t i) = restrict ν (t i)

tactic: simp only [forall_eq_or_imp, iUnion_iUnion_eq_or_left, Finset.mem_insert]
state_before: case insert
α : Type u_2
β : Type ?u.310858
γ : Type ?u.310861
δ : Type ?u.310864
ι : Type u_1
R : Type ?u.310870
R' : Type ?u.310873
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t✝ : Set α
t : ι → Set α
i : ι
s : Finset ι
a✝ : ¬i ∈ s
hs :
  restrict μ (⋃ (i : ι) (_ : i ∈ s), t i) = restrict ν (⋃ (i : ι) (_ : i ∈ s), t i) ↔
    ∀ (i : ι), i ∈ s → restrict μ (t i) = restrict ν (t i)
⊢ restrict μ (⋃ (i_1 : ι) (_ : i_1 ∈ insert i s), t i_1) = restrict ν (⋃ (i_1 : ι) (_ : i_1 ∈ insert i s), t i_1) ↔
    ∀ (i_1 : ι), i_1 ∈ insert i s → restrict μ (t i_1) = restrict ν (t i_1)

tactic: rw [restrict_union_congr, ← hs]
state_before: case insert
α : Type u_2
β : Type ?u.310858
γ : Type ?u.310861
δ : Type ?u.310864
ι : Type u_1
R : Type ?u.310870
R' : Type ?u.310873
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t✝ : Set α
t : ι → Set α
i : ι
s : Finset ι
a✝ : ¬i ∈ s
hs :
  restrict μ (⋃ (i : ι) (_ : i ∈ s), t i) = restrict ν (⋃ (i : ι) (_ : i ∈ s), t i) ↔
    ∀ (i : ι), i ∈ s → restrict μ (t i) = restrict ν (t i)
⊢ restrict μ (t i ∪ ⋃ (x : ι) (_ : x ∈ s), t x) = restrict ν (t i ∪ ⋃ (x : ι) (_ : x ∈ s), t x) ↔
    restrict μ (t i) = restrict ν (t i) ∧ ∀ (a : ι), a ∈ s → restrict μ (t a) = restrict ν (t a)

tactic: simp
state_before: case empty
α : Type u_2
β : Type ?u.310858
γ : Type ?u.310861
δ : Type ?u.310864
ι : Type u_1
R : Type ?u.310870
R' : Type ?u.310873
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t✝ : Set α
t : ι → Set α
⊢ restrict μ (⋃ (i : ι) (_ : i ∈ ∅), t i) = restrict ν (⋃ (i : ι) (_ : i ∈ ∅), t i) ↔
    ∀ (i : ι), i ∈ ∅ → restrict μ (t i) = restrict ν (t i)
Theorem: IsUpperSet.card_inter_le_finset
File: Mathlib/Combinatorics/SetFamily/HarrisKleitman.lean

tactic: rw [← isLowerSet_compl, ← coe_compl] at h𝒜
state_before: α : Type u_1
inst✝¹ : DecidableEq α
𝒜 ℬ : Finset (Finset α)
s : Finset α
a : α
inst✝ : Fintype α
h𝒜 : IsUpperSet ↑𝒜
hℬ : IsLowerSet ↑ℬ
⊢ 2 ^ Fintype.card α * card (𝒜 ∩ ℬ) ≤ card 𝒜 * card ℬ

tactic: have := h𝒜.le_card_inter_finset hℬ
state_before: α : Type u_1
inst✝¹ : DecidableEq α
𝒜 ℬ : Finset (Finset α)
s : Finset α
a : α
inst✝ : Fintype α
h𝒜✝ : IsLowerSet (↑𝒜ᶜ)
h𝒜 : IsLowerSet ↑(𝒜ᶜ)
hℬ : IsLowerSet ↑ℬ
⊢ 2 ^ Fintype.card α * card (𝒜 ∩ ℬ) ≤ card 𝒜 * card ℬ

tactic: rwa [card_compl, Fintype.card_finset, tsub_mul, tsub_le_iff_tsub_le, ← mul_tsub, ←
  card_sdiff (inter_subset_right _ _), sdiff_inter_self_right, sdiff_compl,
  _root_.inf_comm] at this
state_before: α : Type u_1
inst✝¹ : DecidableEq α
𝒜 ℬ : Finset (Finset α)
s : Finset α
a : α
inst✝ : Fintype α
h𝒜✝ : IsLowerSet (↑𝒜ᶜ)
h𝒜 : IsLowerSet ↑(𝒜ᶜ)
hℬ : IsLowerSet ↑ℬ
this : card (𝒜ᶜ) * card ℬ ≤ 2 ^ Fintype.card α * card (𝒜ᶜ ∩ ℬ)
⊢ 2 ^ Fintype.card α * card (𝒜 ∩ ℬ) ≤ card 𝒜 * card ℬ
Theorem: SimpleGraph.singletonFinsubgraph_le_adj_left
File: Mathlib/Combinatorics/SimpleGraph/Finsubgraph.lean

tactic: simp [singletonFinsubgraph, finsubgraphOfAdj]
state_before: V : Type u
W : Type v
G : SimpleGraph V
F : SimpleGraph W
u v : V
e : Adj G u v
⊢ singletonFinsubgraph u ≤ finsubgraphOfAdj e
Theorem: CategoryTheory.Localization.liftNatTrans_id
File: Mathlib/CategoryTheory/Localization/Predicate.lean

tactic: simp only [liftNatTrans_app, NatTrans.id_app, id_comp, Iso.hom_inv_id_app]
state_before: C : Type u_3
D : Type u_6
inst✝³ : Category C
inst✝² : Category D
L : C ⥤ D
W : MorphismProperty C
E : Type u_4
inst✝¹ : Category E
inst✝ : Functor.IsLocalization L W
F : C ⥤ E
F' : D ⥤ E
h : Lifting L W F F'
X : C
⊢ (liftNatTrans L W F F F' F' (𝟙 F)).app (L.obj X) = (𝟙 F').app (L.obj X)

tactic: rfl
state_before: C : Type u_3
D : Type u_6
inst✝³ : Category C
inst✝² : Category D
L : C ⥤ D
W : MorphismProperty C
E : Type u_4
inst✝¹ : Category E
inst✝ : Functor.IsLocalization L W
F : C ⥤ E
F' : D ⥤ E
h : Lifting L W F F'
X : C
⊢ 𝟙 ((L ⋙ F').obj X) = 𝟙 (F'.obj (L.obj X))
Theorem: Int.sub_le_self
File: Std/Data/Int/Lemmas.lean

tactic: rw [Int.add_zero]
state_before: a b : Int
h : 0 ≤ b
⊢ a + 0 = a
Theorem: RatFunc.laurent_at_zero
File: Mathlib/FieldTheory/Laurent.lean

tactic: induction f using RatFunc.induction_on
state_before: R : Type u
inst✝ : CommRing R
hdomain : IsDomain R
r s : R
p q : R[X]
f : RatFunc R
⊢ ↑(laurent 0) f = f

tactic: simp
state_before: case f
R : Type u
inst✝ : CommRing R
hdomain : IsDomain R
r s : R
p q : R[X]
f : RatFunc R
p✝ q✝ : R[X]
hq✝ : q✝ ≠ 0
⊢ ↑(laurent 0) (↑(algebraMap R[X] (RatFunc R)) p✝ / ↑(algebraMap R[X] (RatFunc R)) q✝) =
    ↑(algebraMap R[X] (RatFunc R)) p✝ / ↑(algebraMap R[X] (RatFunc R)) q✝
Theorem: List.periodic_prod
File: Mathlib/Algebra/Periodic.lean

tactic: induction' l with g l ih hl
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.34343
f g : α → β
c c₁ c₂ x : α
inst✝¹ : Add α
inst✝ : Monoid β
l : List (α → β)
hl : ∀ (f : α → β), f ∈ l → Periodic f c
⊢ Periodic (List.prod l) c

tactic: simp
state_before: case nil
α : Type u_1
β : Type u_2
γ : Type ?u.34343
f g : α → β
c c₁ c₂ x : α
inst✝¹ : Add α
inst✝ : Monoid β
l : List (α → β)
hl✝ : ∀ (f : α → β), f ∈ l → Periodic f c
hl : ∀ (f : α → β), f ∈ [] → Periodic f c
⊢ Periodic (List.prod []) c

tactic: rw [List.forall_mem_cons] at hl
state_before: case cons
α : Type u_1
β : Type u_2
γ : Type ?u.34343
f g✝ : α → β
c c₁ c₂ x : α
inst✝¹ : Add α
inst✝ : Monoid β
l✝ : List (α → β)
hl✝ : ∀ (f : α → β), f ∈ l✝ → Periodic f c
g : α → β
l : List (α → β)
ih : (∀ (f : α → β), f ∈ l → Periodic f c) → Periodic (List.prod l) c
hl : ∀ (f : α → β), f ∈ g :: l → Periodic f c
⊢ Periodic (List.prod (g :: l)) c

tactic: simpa only [List.prod_cons] using hl.1.mul (ih hl.2)
state_before: case cons
α : Type u_1
β : Type u_2
γ : Type ?u.34343
f g✝ : α → β
c c₁ c₂ x : α
inst✝¹ : Add α
inst✝ : Monoid β
l✝ : List (α → β)
hl✝ : ∀ (f : α → β), f ∈ l✝ → Periodic f c
g : α → β
l : List (α → β)
ih : (∀ (f : α → β), f ∈ l → Periodic f c) → Periodic (List.prod l) c
hl : Periodic g c ∧ ∀ (x : α → β), x ∈ l → Periodic x c
⊢ Periodic (List.prod (g :: l)) c
Theorem: MvPolynomial.supportedEquivMvPolynomial_symm_X
File: Mathlib/Data/MvPolynomial/Supported.lean

tactic: simp [supportedEquivMvPolynomial]
state_before: σ : Type u_1
τ : Type ?u.86982
R : Type u
S : Type v
r : R
e : ℕ
n m : σ
inst✝ : CommSemiring R
p q : MvPolynomial σ R
s : Set σ
i : ↑s
⊢ ↑(↑(AlgEquiv.symm (supportedEquivMvPolynomial s)) (X i)) = X ↑i
Theorem: Complex.inv_im
File: Mathlib/Data/Complex/Basic.lean

tactic: simp [inv_def, division_def, ofReal']
state_before: z : ℂ
⊢ z⁻¹.im = -z.im / ↑normSq z
Theorem: dvd_iff_exists_eq_mul_left
File: Mathlib/Algebra/Divisibility/Basic.lean

tactic: rintro ⟨c, rfl⟩
state_before: α : Type u_1
inst✝ : CommSemigroup α
a b c : α
⊢ (∃ c, b = c * a) → a ∣ b

tactic: exact ⟨c, mul_comm _ _⟩
state_before: case intro
α : Type u_1
inst✝ : CommSemigroup α
a c✝ c : α
⊢ a ∣ c * a