tasksource/leandojo huggingface dataset:
Theorem: CategoryTheory.GrothendieckTopology.isClosed_iff_close_eq_self
File: Mathlib/CategoryTheory/Sites/Closed.lean

tactic: constructor
state_before: C : Type u
inst✝ : Category C
J₁ J₂ : GrothendieckTopology C
X : C
S : Sieve X
⊢ IsClosed J₁ S ↔ close J₁ S = S

tactic: intro h
state_before: case mp
C : Type u
inst✝ : Category C
J₁ J₂ : GrothendieckTopology C
X : C
S : Sieve X
⊢ IsClosed J₁ S → close J₁ S = S

tactic: apply le_antisymm
state_before: case mp
C : Type u
inst✝ : Category C
J₁ J₂ : GrothendieckTopology C
X : C
S : Sieve X
h : IsClosed J₁ S
⊢ close J₁ S = S

tactic: intro Y f hf
state_before: case mp.a
C : Type u
inst✝ : Category C
J₁ J₂ : GrothendieckTopology C
X : C
S : Sieve X
h : IsClosed J₁ S
⊢ close J₁ S ≤ S

tactic: rw [← J₁.covers_iff_mem_of_isClosed h]
state_before: case mp.a
C : Type u
inst✝ : Category C
J₁ J₂ : GrothendieckTopology C
X : C
S : Sieve X
h : IsClosed J₁ S
Y : C
f : Y ⟶ X
hf : (close J₁ S).arrows f
⊢ S.arrows f

tactic: apply hf
state_before: case mp.a
C : Type u
inst✝ : Category C
J₁ J₂ : GrothendieckTopology C
X : C
S : Sieve X
h : IsClosed J₁ S
Y : C
f : Y ⟶ X
hf : (close J₁ S).arrows f
⊢ Covers J₁ S f

tactic: apply J₁.le_close
state_before: case mp.a
C : Type u
inst✝ : Category C
J₁ J₂ : GrothendieckTopology C
X : C
S : Sieve X
h : IsClosed J₁ S
⊢ S ≤ close J₁ S

tactic: intro e
state_before: case mpr
C : Type u
inst✝ : Category C
J₁ J₂ : GrothendieckTopology C
X : C
S : Sieve X
⊢ close J₁ S = S → IsClosed J₁ S

tactic: rw [← e]
state_before: case mpr
C : Type u
inst✝ : Category C
J₁ J₂ : GrothendieckTopology C
X : C
S : Sieve X
e : close J₁ S = S
⊢ IsClosed J₁ S

tactic: apply J₁.close_isClosed
state_before: case mpr
C : Type u
inst✝ : Category C
J₁ J₂ : GrothendieckTopology C
X : C
S : Sieve X
e : close J₁ S = S
⊢ IsClosed J₁ (close J₁ S)
Theorem: CategoryTheory.IsPullback.of_isLimit
File: Mathlib/CategoryTheory/Limits/Shapes/CommSq.lean

tactic: aesop_cat
state_before: C : Type u₁
inst✝ : Category C
P X Y Z : C
fst : P ⟶ X
snd : P ⟶ Y
f : X ⟶ Z
g : Y ⟶ Z
c : PullbackCone f g
h : IsLimit c
⊢ PullbackCone.fst c =
    (Iso.refl c.pt).hom ≫
      PullbackCone.fst
        (PullbackCone.mk (PullbackCone.fst c) (PullbackCone.snd c)
          (_ : PullbackCone.fst c ≫ f = PullbackCone.snd c ≫ g))

tactic: aesop_cat
state_before: C : Type u₁
inst✝ : Category C
P X Y Z : C
fst : P ⟶ X
snd : P ⟶ Y
f : X ⟶ Z
g : Y ⟶ Z
c : PullbackCone f g
h : IsLimit c
⊢ PullbackCone.snd c =
    (Iso.refl c.pt).hom ≫
      PullbackCone.snd
        (PullbackCone.mk (PullbackCone.fst c) (PullbackCone.snd c)
          (_ : PullbackCone.fst c ≫ f = PullbackCone.snd c ≫ g))
Theorem: Order.mem_range_pred_of_not_isPredLimit
File: Mathlib/Order/SuccPred/Limit.lean

tactic: cases' not_isPredLimit_iff.1 h with b hb
state_before: α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : PredOrder α
a b : α
C : α → Sort ?u.17064
h : ¬IsPredLimit a
⊢ a ∈ range pred

tactic: exact ⟨b, hb.2⟩
state_before: case intro
α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : PredOrder α
a b✝ : α
C : α → Sort ?u.17064
h : ¬IsPredLimit a
b : α
hb : ¬IsMin b ∧ pred b = a
⊢ a ∈ range pred
Theorem: iInf_eq_bot
File: Mathlib/Order/CompleteLattice.lean

tactic: simp only [← sInf_range, sInf_eq_bot, Set.exists_range_iff]
state_before: α : Type u_1
β : Type ?u.188056
β₂ : Type ?u.188059
γ : Type ?u.188062
ι : Sort u_2
ι' : Sort ?u.188068
κ : ι → Sort ?u.188073
κ' : ι' → Sort ?u.188078
inst✝ : CompleteLinearOrder α
f : ι → α
⊢ iInf f = ⊥ ↔ ∀ (b : α), b > ⊥ → ∃ i, f i < b
Theorem: Finset.ssubset_iff
File: Mathlib/Data/Finset/Basic.lean

tactic: exact_mod_cast @Set.ssubset_iff_insert α s t
state_before: α : Type u_1
β : Type ?u.114504
γ : Type ?u.114507
inst✝ : DecidableEq α
s t u v : Finset α
a b : α
⊢ s ⊂ t ↔ ∃ a x, insert a s ⊆ t
Theorem: rank_eq_of_surjective
File: Mathlib/LinearAlgebra/Dimension.lean

tactic: rw [← rank_range_add_rank_ker f, ← rank_range_of_surjective f h]
state_before: K : Type u
V V₁ V₂ V₃ : Type v
V' V'₁ : Type v'
V'' : Type v''
ι : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type ?u.586525
inst✝⁶ : DivisionRing K
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module K V
inst✝³ : AddCommGroup V'
inst✝² : Module K V'
inst✝¹ : AddCommGroup V₁
inst✝ : Module K V₁
f : V →ₗ[K] V₁
h : Surjective ↑f
⊢ Module.rank K V = Module.rank K V₁ + Module.rank K { x // x ∈ LinearMap.ker f }
Theorem: Mathlib.Tactic.RingNF.int_rawCast_1
File: Mathlib/Tactic/Ring/RingNF.lean

tactic: simp [Int.negOfNat_eq]
state_before: R✝ : Type ?u.76784
inst✝¹ : CommSemiring R✝
R : Type u_1
inst✝ : Ring R
⊢ Int.rawCast (Int.negOfNat 1) = -1
Theorem: inner_self_eq_norm_mul_norm
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

tactic: rw [@norm_eq_sqrt_inner 𝕜, ← sqrt_mul inner_self_nonneg (re ⟪x, x⟫),
  sqrt_mul_self inner_self_nonneg]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.2233904
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
dec_E : DecidableEq E
x : E
⊢ ↑re (inner x x) = ‖x‖ * ‖x‖
Theorem: compl_sSup
File: Mathlib/Order/CompleteBooleanAlgebra.lean

tactic: simp only [sSup_eq_iSup, compl_iSup]
state_before: α : Type u
β : Type v
ι : Sort w
κ : ι → Sort ?u.27525
inst✝ : CompleteBooleanAlgebra α
a b : α
s : Set α
f : ι → α
⊢ sSup sᶜ = ⨅ (i : α) (_ : i ∈ s), iᶜ
Theorem: LieSubmodule.lcs_le_self
File: Mathlib/Algebra/Lie/Nilpotent.lean

tactic: induction' k with k ih
state_before: R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
k : ℕ
N : LieSubmodule R L M
⊢ lcs k N ≤ N

tactic: simp
state_before: case zero
R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
k : ℕ
N : LieSubmodule R L M
⊢ lcs Nat.zero N ≤ N

tactic: simp only [lcs_succ]
state_before: case succ
R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
k✝ : ℕ
N : LieSubmodule R L M
k : ℕ
ih : lcs k N ≤ N
⊢ lcs (Nat.succ k) N ≤ N

tactic: exact (LieSubmodule.mono_lie_right _ _ ⊤ ih).trans (N.lie_le_right ⊤)
state_before: case succ
R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
k✝ : ℕ
N : LieSubmodule R L M
k : ℕ
ih : lcs k N ≤ N
⊢ ⁅⊤, lcs k N⁆ ≤ N
Theorem: Finset.mem_image_const
File: Mathlib/Data/Finset/Image.lean

tactic: rw [mem_image]
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.63472
inst✝ : DecidableEq β
f g : α → β
s : Finset α
t : Finset β
a : α
b c : β
⊢ c ∈ image (const α b) s ↔ Finset.Nonempty s ∧ b = c

tactic: simp only [exists_prop, const_apply, exists_and_right]
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.63472
inst✝ : DecidableEq β
f g : α → β
s : Finset α
t : Finset β
a : α
b c : β
⊢ (∃ a, a ∈ s ∧ const α b a = c) ↔ Finset.Nonempty s ∧ b = c

tactic: rfl
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.63472
inst✝ : DecidableEq β
f g : α → β
s : Finset α
t : Finset β
a : α
b c : β
⊢ (∃ x, x ∈ s) ∧ b = c ↔ Finset.Nonempty s ∧ b = c
Theorem: Dfinsupp.support_mapRange
File: Mathlib/Data/Dfinsupp/Basic.lean

tactic: simp [mapRange_def]
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝⁵ : (i : ι) → Zero (β i)
inst✝⁴ : (i : ι) → (x : β i) → Decidable (x ≠ 0)
inst✝³ : (i : ι) → Zero (β₁ i)
inst✝² : (i : ι) → Zero (β₂ i)
inst✝¹ : (i : ι) → (x : β₁ i) → Decidable (x ≠ 0)
inst✝ : (i : ι) → (x : β₂ i) → Decidable (x ≠ 0)
f : (i : ι) → β₁ i → β₂ i
hf : ∀ (i : ι), f i 0 = 0
g : Π₀ (i : ι), β₁ i
⊢ support (mapRange f hf g) ⊆ support g
Theorem: Metric.diam_subsingleton
File: Mathlib/Topology/MetricSpace/Basic.lean

tactic: simp only [diam, EMetric.diam_subsingleton hs, ENNReal.zero_toReal]
state_before: α : Type u
β : Type v
X : Type ?u.528785
ι : Type ?u.528788
inst✝ : PseudoMetricSpace α
s : Set α
x y z : α
hs : Set.Subsingleton s
⊢ diam s = 0
Theorem: Finset.filter_eq_self
File: Mathlib/Data/Finset/Basic.lean

tactic: simp [Finset.ext_iff]
state_before: α : Type u_1
β : Type ?u.321633
γ : Type ?u.321636
p q : α → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
s : Finset α
⊢ filter p s = s ↔ ∀ (x : α), x ∈ s → p x
Theorem: isOpen_singleton_iff_punctured_nhds
File: Mathlib/Topology/Basic.lean

tactic: rw [isOpen_singleton_iff_nhds_eq_pure, nhdsWithin, ← mem_iff_inf_principal_compl, ← le_pure_iff,
  nhds_neBot.le_pure_iff]
state_before: α✝ : Type u
β : Type v
ι : Sort w
a✝ : α✝
s s₁ s₂ t : Set α✝
p p₁ p₂ : α✝ → Prop
inst✝¹ : TopologicalSpace α✝
α : Type u_1
inst✝ : TopologicalSpace α
a : α
⊢ IsOpen {a} ↔ 𝓝[{a}ᶜ] a = ⊥
Theorem: Nat.unpair_zero
File: Mathlib/Data/Nat/Pairing.lean

tactic: rw [unpair]
state_before: ⊢ unpair 0 = 0

tactic: simp
state_before: ⊢ (let s := sqrt 0;
    if 0 - s * s < s then (0 - s * s, s) else (s, 0 - s * s - s)) =
    0
Theorem: List.length_set
File: src/lean/Init/Data/List/Basic.lean

tactic: induction as generalizing i with
| nil => rfl
| cons x xs ih =>
  cases i with
  | zero => rfl
  | succ i => simp [set, ih]
state_before: α : Type u
β : Type v
γ : Type w
as : List α
i : Nat
a : α
⊢ length (set as i a) = length as

tactic: rfl
state_before: case nil
α : Type u
β : Type v
γ : Type w
a : α
i : Nat
⊢ length (set nil i a) = length nil

tactic: cases i with
| zero => rfl
| succ i => simp [set, ih]
state_before: case cons
α : Type u
β : Type v
γ : Type w
a x : α
xs : List α
ih : ∀ (i : Nat), length (set xs i a) = length xs
i : Nat
⊢ length (set (x :: xs) i a) = length (x :: xs)

tactic: rfl
state_before: case cons.zero
α : Type u
β : Type v
γ : Type w
a x : α
xs : List α
ih : ∀ (i : Nat), length (set xs i a) = length xs
⊢ length (set (x :: xs) Nat.zero a) = length (x :: xs)

tactic: simp [set, ih]
state_before: case cons.succ
α : Type u
β : Type v
γ : Type w
a x : α
xs : List α
ih : ∀ (i : Nat), length (set xs i a) = length xs
i : Nat
⊢ length (set (x :: xs) (Nat.succ i) a) = length (x :: xs)
Theorem: NormedAddGroupHom.sum_apply
File: Mathlib/Analysis/Normed/Group/Hom.lean

tactic: simp only [coe_sum, Finset.sum_apply]
state_before: V : Type ?u.446095
V₁ : Type u_2
V₂ : Type u_3
V₃ : Type ?u.446104
inst✝³ : SeminormedAddCommGroup V
inst✝² : SeminormedAddCommGroup V₁
inst✝¹ : SeminormedAddCommGroup V₂
inst✝ : SeminormedAddCommGroup V₃
f✝ g : NormedAddGroupHom V₁ V₂
ι : Type u_1
s : Finset ι
f : ι → NormedAddGroupHom V₁ V₂
v : V₁
⊢ ↑(∑ i in s, f i) v = ∑ i in s, ↑(f i) v
Theorem: Orthonormal.inner_right_sum
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

tactic: classical!
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.1919924
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
dec_E : DecidableEq E
ι : Type u_3
dec_ι : DecidableEq ι
v : ι → E
hv : Orthonormal 𝕜 v
l : ι → 𝕜
s : Finset ι
i : ι
hi : i ∈ s
⊢ inner (v i) (∑ i in s, l i • v i) = l i

tactic: simp [inner_sum, inner_smul_right, orthonormal_iff_ite.mp hv, hi]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.1919924
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
dec_E : DecidableEq E
ι : Type u_3
dec_ι : DecidableEq ι
v : ι → E
hv : Orthonormal 𝕜 v
l : ι → 𝕜
s : Finset ι
i : ι
hi : i ∈ s
em✝ : (a : Prop) → Decidable a
⊢ inner (v i) (∑ i in s, l i • v i) = l i
Theorem: Nat.gcd_mul_lcm
File: Std/Data/Nat/Gcd.lean

tactic: rw [lcm, Nat.mul_div_cancel' (Nat.dvd_trans (gcd_dvd_left m n) (Nat.dvd_mul_right m n))]
state_before: m n : Nat
⊢ gcd m n * lcm m n = m * n
Theorem: Metric.exists_isOpen_bounded_image_of_isCompact_of_forall_continuousAt
File: Mathlib/Topology/MetricSpace/Basic.lean

tactic: simp_rw [← continuousWithinAt_univ] at hf
state_before: α : Type u
β : Type v
X : Type ?u.524771
ι : Type ?u.524774
inst✝¹ : PseudoMetricSpace α
x : α
s t : Set α
r : ℝ
inst✝ : TopologicalSpace β
k : Set β
f : β → α
hk : IsCompact k
hf : ∀ (x : β), x ∈ k → ContinuousAt f x
⊢ ∃ t, k ⊆ t ∧ IsOpen t ∧ Bounded (f '' t)

tactic: simpa only [inter_univ] using
  exists_isOpen_bounded_image_inter_of_isCompact_of_forall_continuousWithinAt hk hf
state_before: α : Type u
β : Type v
X : Type ?u.524771
ι : Type ?u.524774
inst✝¹ : PseudoMetricSpace α
x : α
s t : Set α
r : ℝ
inst✝ : TopologicalSpace β
k : Set β
f : β → α
hk : IsCompact k
hf : ∀ (x : β), x ∈ k → ContinuousWithinAt f univ x
⊢ ∃ t, k ⊆ t ∧ IsOpen t ∧ Bounded (f '' t)
Theorem: Nat.Primrec.pred
File: Mathlib/Computability/Primrec.lean

tactic: cases n <;> simp [*]
state_before: n : ℕ
⊢ Nat.casesOn n 0 id = Nat.pred n
Theorem: ProbabilityTheory.indep_biSup_limsup
File: Mathlib/Probability/Independence/ZeroOne.lean

tactic: refine' indep_of_indep_of_le_right (indep_biSup_compl h_le h_indep t) _
state_before: Ω : Type u_1
ι : Type u_2
m m0 : MeasurableSpace Ω
μ : MeasureTheory.Measure Ω
inst✝ : IsProbabilityMeasure μ
s : ι → MeasurableSpace Ω
α : Type ?u.378750
p : Set ι → Prop
f : Filter ι
ns : α → Set ι
h_le : ∀ (n : ι), s n ≤ m0
h_indep : iIndep s
hf : ∀ (t : Set ι), p t → tᶜ ∈ f
t : Set ι
ht : p t
⊢ Indep (⨆ (n : ι) (_ : n ∈ t), s n) (limsup s f)

tactic: refine' limsSup_le_of_le (by isBoundedDefault) _
state_before: Ω : Type u_1
ι : Type u_2
m m0 : MeasurableSpace Ω
μ : MeasureTheory.Measure Ω
inst✝ : IsProbabilityMeasure μ
s : ι → MeasurableSpace Ω
α : Type ?u.378750
p : Set ι → Prop
f : Filter ι
ns : α → Set ι
h_le : ∀ (n : ι), s n ≤ m0
h_indep : iIndep s
hf : ∀ (t : Set ι), p t → tᶜ ∈ f
t : Set ι
ht : p t
⊢ limsup s f ≤ ⨆ (n : ι) (_ : n ∈ tᶜ), s n

tactic: simp only [Set.mem_compl_iff, eventually_map]
state_before: Ω : Type u_1
ι : Type u_2
m m0 : MeasurableSpace Ω
μ : MeasureTheory.Measure Ω
inst✝ : IsProbabilityMeasure μ
s : ι → MeasurableSpace Ω
α : Type ?u.378750
p : Set ι → Prop
f : Filter ι
ns : α → Set ι
h_le : ∀ (n : ι), s n ≤ m0
h_indep : iIndep s
hf : ∀ (t : Set ι), p t → tᶜ ∈ f
t : Set ι
ht : p t
⊢ ∀ᶠ (n : MeasurableSpace Ω) in map s f, n ≤ ⨆ (n : ι) (_ : n ∈ tᶜ), s n

tactic: exact eventually_of_mem (hf t ht) le_iSup₂
state_before: Ω : Type u_1
ι : Type u_2
m m0 : MeasurableSpace Ω
μ : MeasureTheory.Measure Ω
inst✝ : IsProbabilityMeasure μ
s : ι → MeasurableSpace Ω
α : Type ?u.378750
p : Set ι → Prop
f : Filter ι
ns : α → Set ι
h_le : ∀ (n : ι), s n ≤ m0
h_indep : iIndep s
hf : ∀ (t : Set ι), p t → tᶜ ∈ f
t : Set ι
ht : p t
⊢ ∀ᶠ (a : ι) in f, s a ≤ ⨆ (n : ι) (_ : ¬n ∈ t), s n

tactic: isBoundedDefault
state_before: Ω : Type u_1
ι : Type u_2
m m0 : MeasurableSpace Ω
μ : MeasureTheory.Measure Ω
inst✝ : IsProbabilityMeasure μ
s : ι → MeasurableSpace Ω
α : Type ?u.378750
p : Set ι → Prop
f : Filter ι
ns : α → Set ι
h_le : ∀ (n : ι), s n ≤ m0
h_indep : iIndep s
hf : ∀ (t : Set ι), p t → tᶜ ∈ f
t : Set ι
ht : p t
⊢ IsCobounded (fun x x_1 => x ≤ x_1) (map s f)
Theorem: MeasureTheory.ProbabilityMeasure.nonempty
File: Mathlib/MeasureTheory/Measure/ProbabilityMeasure.lean

tactic: by_contra maybe_empty
state_before: Ω : Type u_1
inst✝ : MeasurableSpace Ω
μ : ProbabilityMeasure Ω
⊢ Nonempty Ω

tactic: have zero : (μ : Measure Ω) univ = 0 := by
  rw [univ_eq_empty_iff.mpr (not_nonempty_iff.mp maybe_empty), measure_empty]
state_before: Ω : Type u_1
inst✝ : MeasurableSpace Ω
μ : ProbabilityMeasure Ω
maybe_empty : ¬Nonempty Ω
⊢ False

tactic: rw [measure_univ] at zero
state_before: Ω : Type u_1
inst✝ : MeasurableSpace Ω
μ : ProbabilityMeasure Ω
maybe_empty : ¬Nonempty Ω
zero : ↑↑↑μ univ = 0
⊢ False

tactic: exact zero_ne_one zero.symm
state_before: Ω : Type u_1
inst✝ : MeasurableSpace Ω
μ : ProbabilityMeasure Ω
maybe_empty : ¬Nonempty Ω
zero : 1 = 0
⊢ False

tactic: rw [univ_eq_empty_iff.mpr (not_nonempty_iff.mp maybe_empty), measure_empty]
state_before: Ω : Type u_1
inst✝ : MeasurableSpace Ω
μ : ProbabilityMeasure Ω
maybe_empty : ¬Nonempty Ω
⊢ ↑↑↑μ univ = 0
Theorem: sq_ne_two_fin_zmod_four
File: Mathlib/NumberTheory/PythagoreanTriples.lean

tactic: change Fin 4 at z
state_before: z : ZMod 4
⊢ z * z ≠ 2

tactic: fin_cases z <;> norm_num [Fin.ext_iff, Fin.val_bit0, Fin.val_bit1]
state_before: z : Fin 4
⊢ z * z ≠ 2
Theorem: Real.pi_div_two_le_two
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

tactic: rw [Real.pi, mul_div_cancel_left _ (two_ne_zero' ℝ)]
state_before: ⊢ π / 2 ≤ 2

tactic: exact (Classical.choose_spec exists_cos_eq_zero).1.2
state_before: ⊢ choose exists_cos_eq_zero ≤ 2
Theorem: CategoryTheory.Limits.pullbackZeroZeroIso_inv_fst
File: Mathlib/CategoryTheory/Limits/Constructions/ZeroObjects.lean

tactic: dsimp [pullbackZeroZeroIso]
state_before: C : Type u_2
inst✝³ : Category C
inst✝² : HasZeroObject C
inst✝¹ : HasZeroMorphisms C
X Y : C
inst✝ : HasBinaryProduct X Y
⊢ (pullbackZeroZeroIso X Y).inv ≫ pullback.fst = prod.fst

tactic: simp
state_before: C : Type u_2
inst✝³ : Category C
inst✝² : HasZeroObject C
inst✝¹ : HasZeroMorphisms C
X Y : C
inst✝ : HasBinaryProduct X Y
⊢ (limit.isoLimitCone
          { cone := PullbackCone.mk prod.fst prod.snd (_ : prod.fst ≫ 0 = prod.snd ≫ 0),
            isLimit :=
              isPullbackOfIsTerminalIsProduct 0 0 prod.fst prod.snd HasZeroObject.zeroIsTerminal
                (prodIsProd X Y) }).inv ≫
      pullback.fst =
    prod.fst
Theorem: Irrational.of_one_div
File: Mathlib/Data/Real/Irrational.lean

tactic: rwa [cast_one]
state_before: q : ℚ
x y : ℝ
h : Irrational (1 / x)
⊢ Irrational (↑1 / x)
Theorem: AffineSubspace.affineSpan_coe
File: Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean

tactic: refine' le_antisymm _ (subset_spanPoints _ _)
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
p₁ p₂ : P
s : AffineSubspace k P
⊢ affineSpan k ↑s = s

tactic: rintro p ⟨p1, hp1, v, hv, rfl⟩
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
p₁ p₂ : P
s : AffineSubspace k P
⊢ affineSpan k ↑s ≤ s

tactic: exact vadd_mem_of_mem_direction hv hp1
state_before: case intro.intro.intro.intro
k : Type u_1
V : Type u_2
P : Type u_3
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
p₁ p₂ : P
s : AffineSubspace k P
p1 : P
hp1 : p1 ∈ ↑s
v : V
hv : v ∈ vectorSpan k ↑s
⊢ v +ᵥ p1 ∈ ↑s
Theorem: CategoryTheory.IsPullback.of_map
File: Mathlib/CategoryTheory/Limits/Shapes/CommSq.lean

tactic: refine' ⟨⟨e⟩, ⟨isLimitOfReflects F <| _⟩⟩
state_before: C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
F : C ⥤ D
W X Y Z : C
f : W ⟶ X
g : W ⟶ Y
h : X ⟶ Z
i : Y ⟶ Z
inst✝ : ReflectsLimit (cospan h i) F
e : f ≫ h = g ≫ i
H : IsPullback (F.map f) (F.map g) (F.map h) (F.map i)
⊢ IsPullback f g h i

tactic: refine'
  (IsLimit.equivOfNatIsoOfIso (cospanCompIso F h i) _ _ (WalkingCospan.ext _ _ _)).symm
    H.isLimit
state_before: C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
F : C ⥤ D
W X Y Z : C
f : W ⟶ X
g : W ⟶ Y
h : X ⟶ Z
i : Y ⟶ Z
inst✝ : ReflectsLimit (cospan h i) F
e : f ≫ h = g ≫ i
H : IsPullback (F.map f) (F.map g) (F.map h) (F.map i)
⊢ IsLimit (F.mapCone (PullbackCone.mk f g (_ : f ≫ h = g ≫ i)))

tactic: exacts [Iso.refl _, (Category.comp_id _).trans (Category.id_comp _).symm,
  (Category.comp_id _).trans (Category.id_comp _).symm]
state_before: case refine'_1
C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
F : C ⥤ D
W X Y Z : C
f : W ⟶ X
g : W ⟶ Y
h : X ⟶ Z
i : Y ⟶ Z
inst✝ : ReflectsLimit (cospan h i) F
e : f ≫ h = g ≫ i
H : IsPullback (F.map f) (F.map g) (F.map h) (F.map i)
⊢ ((Cones.postcompose (cospanCompIso F h i).hom).obj (F.mapCone (PullbackCone.mk f g (_ : f ≫ h = g ≫ i)))).pt ≅
    (cone H).pt

case refine'_2
C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
F : C ⥤ D
W X Y Z : C
f : W ⟶ X
g : W ⟶ Y
h : X ⟶ Z
i : Y ⟶ Z
inst✝ : ReflectsLimit (cospan h i) F
e : f ≫ h = g ≫ i
H : IsPullback (F.map f) (F.map g) (F.map h) (F.map i)
⊢ ((Cones.postcompose (cospanCompIso F h i).hom).obj (F.mapCone (PullbackCone.mk f g (_ : f ≫ h = g ≫ i)))).π.app
      WalkingCospan.left =
    ?refine'_1.hom ≫ (cone H).π.app WalkingCospan.left

case refine'_3
C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
F : C ⥤ D
W X Y Z : C
f : W ⟶ X
g : W ⟶ Y
h : X ⟶ Z
i : Y ⟶ Z
inst✝ : ReflectsLimit (cospan h i) F
e : f ≫ h = g ≫ i
H : IsPullback (F.map f) (F.map g) (F.map h) (F.map i)
⊢ ((Cones.postcompose (cospanCompIso F h i).hom).obj (F.mapCone (PullbackCone.mk f g (_ : f ≫ h = g ≫ i)))).π.app
      WalkingCospan.right =
    ?refine'_1.hom ≫ (cone H).π.app WalkingCospan.right
Theorem: Set.pi_univ_Ioc_update_union
File: Mathlib/Data/Set/Intervals/Pi.lean

tactic: simp_rw [pi_univ_Ioc_update_left hm.1, pi_univ_Ioc_update_right hm.2, ← union_inter_distrib_right,
  ← setOf_or, le_or_lt, setOf_true, univ_inter]
state_before: ι : Type u_2
α : ι → Type u_1
inst✝¹ : DecidableEq ι
inst✝ : (i : ι) → LinearOrder (α i)
x y : (i : ι) → α i
i₀ : ι
m : α i₀
hm : m ∈ Icc (x i₀) (y i₀)
⊢ ((pi univ fun i => Ioc (x i) (update y i₀ m i)) ∪ pi univ fun i => Ioc (update x i₀ m i) (y i)) =
    pi univ fun i => Ioc (x i) (y i)
Theorem: Set.Ioc_union_left
File: Mathlib/Data/Set/Intervals/Basic.lean

tactic: rw [← Icc_diff_left, diff_union_self,
  union_eq_self_of_subset_right (singleton_subset_iff.2 <| left_mem_Icc.2 hab)]
state_before: α : Type u_1
β : Type ?u.47327
inst✝ : PartialOrder α
a b c : α
hab : a ≤ b
⊢ Ioc a b ∪ {a} = Icc a b
Theorem: Finset.Nat.antidiagonal.snd_le
File: Mathlib/Data/Finset/NatAntidiagonal.lean

tactic: rw [le_iff_exists_add]
state_before: n : ℕ
kl : ℕ × ℕ
hlk : kl ∈ antidiagonal n
⊢ kl.snd ≤ n

tactic: use kl.1
state_before: n : ℕ
kl : ℕ × ℕ
hlk : kl ∈ antidiagonal n
⊢ ∃ c, n = kl.snd + c

tactic: rwa [mem_antidiagonal, eq_comm, add_comm] at hlk
state_before: n : ℕ
kl : ℕ × ℕ
hlk : kl ∈ antidiagonal n
⊢ n = kl.snd + kl.fst
Theorem: ciInf_eq_of_forall_ge_of_forall_gt_exists_lt
File: Mathlib/Order/ConditionallyCompleteLattice/Basic.lean

tactic: exact @ciSup_eq_of_forall_le_of_forall_lt_exists_gt αᵒᵈ _ _ _ _ ‹_› ‹_› ‹_›
state_before: α : Type u_2
β : Type ?u.60897
γ : Type ?u.60900
ι : Sort u_1
inst✝¹ : ConditionallyCompleteLattice α
s t : Set α
a b : α
inst✝ : Nonempty ι
f : ι → α
h₁ : ∀ (i : ι), b ≤ f i
h₂ : ∀ (w : α), b < w → ∃ i, f i < w
⊢ (⨅ (i : ι), f i) = b