tasksource/leandojo huggingface dataset:
Theorem: FirstOrder.Language.Equiv.toHom_range
File: Mathlib/ModelTheory/Substructures.lean

tactic: ext n
state_before: L : Language
M : Type w
N : Type u_1
P : Type ?u.1142600
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
S : Substructure L M
f : M ≃[L] N
⊢ Hom.range (toHom f) = ⊤

tactic: simp only [Hom.mem_range, coe_toHom, Substructure.mem_top, iff_true_iff]
state_before: case h
L : Language
M : Type w
N : Type u_1
P : Type ?u.1142600
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
S : Substructure L M
f : M ≃[L] N
n : N
⊢ n ∈ Hom.range (toHom f) ↔ n ∈ ⊤

tactic: exact ⟨f.symm n, apply_symm_apply _ _⟩
state_before: case h
L : Language
M : Type w
N : Type u_1
P : Type ?u.1142600
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
S : Substructure L M
f : M ≃[L] N
n : N
⊢ ∃ y, ↑f y = n
Theorem: MeasureTheory.Measure.bind_apply
File: Mathlib/MeasureTheory/Measure/GiryMonad.lean

tactic: rw [bind, join_apply hs, lintegral_map (measurable_coe hs) hf]
state_before: α : Type u_1
β : Type u_2
inst✝¹ : MeasurableSpace α
inst✝ : MeasurableSpace β
m : Measure α
f : α → Measure β
s : Set β
hs : MeasurableSet s
hf : Measurable f
⊢ ↑↑(bind m f) s = ∫⁻ (a : α), ↑↑(f a) s ∂m
Theorem: Subgroup.map_comap_eq
File: Mathlib/GroupTheory/Subgroup/Basic.lean

tactic: rw [coe_map, coe_comap, Set.image_preimage_eq_inter_range, coe_inf, coe_range, Set.inter_comm]
state_before: G : Type u_2
G' : Type ?u.564457
inst✝³ : Group G
inst✝² : Group G'
A : Type ?u.564466
inst✝¹ : AddGroup A
N : Type u_1
inst✝ : Group N
f : G →* N
H : Subgroup N
⊢ ↑(map f (comap f H)) = ↑(range f ⊓ H)
Theorem: upperSemicontinuous_iff_isClosed_preimage
File: Mathlib/Topology/Semicontinuous.lean

tactic: rw [upperSemicontinuous_iff_isOpen_preimage]
state_before: α : Type u_1
inst✝² : TopologicalSpace α
β : Type ?u.149869
inst✝¹ : Preorder β
f✝ g : α → β
x : α
s t : Set α
y z : β
γ : Type u_2
inst✝ : LinearOrder γ
f : α → γ
⊢ UpperSemicontinuous f ↔ ∀ (y : γ), IsClosed (f ⁻¹' Ici y)

tactic: simp only [← isOpen_compl_iff, ← preimage_compl, compl_Ici]
state_before: α : Type u_1
inst✝² : TopologicalSpace α
β : Type ?u.149869
inst✝¹ : Preorder β
f✝ g : α → β
x : α
s t : Set α
y z : β
γ : Type u_2
inst✝ : LinearOrder γ
f : α → γ
⊢ (∀ (y : γ), IsOpen (f ⁻¹' Iio y)) ↔ ∀ (y : γ), IsClosed (f ⁻¹' Ici y)
Theorem: String.any_eq
File: Std/Data/String/Lemmas.lean

tactic: simpa using anyAux_of_valid p [] s.1 []
state_before: s : String
p : Char → Bool
⊢ any s p = List.any s.data p
Theorem: Set.Icc_add_bij
File: Mathlib/Data/Set/Intervals/Monoid.lean

tactic: rw [← Ici_inter_Iic, ← Ici_inter_Iic]
state_before: M : Type u_1
inst✝¹ : OrderedCancelAddCommMonoid M
inst✝ : ExistsAddOfLE M
a b c d : M
⊢ BijOn (fun x => x + d) (Icc a b) (Icc (a + d) (b + d))

tactic: exact
  (Ici_add_bij a d).inter_mapsTo (fun x hx => add_le_add_right hx _) fun x hx =>
    le_of_add_le_add_right hx.2
state_before: M : Type u_1
inst✝¹ : OrderedCancelAddCommMonoid M
inst✝ : ExistsAddOfLE M
a b c d : M
⊢ BijOn (fun x => x + d) (Ici a ∩ Iic b) (Ici (a + d) ∩ Iic (b + d))
Theorem: Polynomial.revAtFun_invol
File: Mathlib/Data/Polynomial/Reverse.lean

tactic: unfold revAtFun
state_before: R : Type ?u.164
inst✝ : Semiring R
f : R[X]
N i : ℕ
⊢ revAtFun N (revAtFun N i) = i

tactic: split_ifs with h j
state_before: R : Type ?u.164
inst✝ : Semiring R
f : R[X]
N i : ℕ
⊢ (if (if i ≤ N then N - i else i) ≤ N then N - if i ≤ N then N - i else i else if i ≤ N then N - i else i) = i

tactic: exact tsub_tsub_cancel_of_le h
state_before: case inl.inl
R : Type ?u.164
inst✝ : Semiring R
f : R[X]
N i : ℕ
h : i ≤ N
j : N - i ≤ N
⊢ N - (N - i) = i

tactic: exfalso
state_before: case inl.inr
R : Type ?u.164
inst✝ : Semiring R
f : R[X]
N i : ℕ
h : i ≤ N
j : ¬N - i ≤ N
⊢ N - i = i

tactic: apply j
state_before: case inl.inr.h
R : Type ?u.164
inst✝ : Semiring R
f : R[X]
N i : ℕ
h : i ≤ N
j : ¬N - i ≤ N
⊢ False

tactic: exact Nat.sub_le N i
state_before: case inl.inr.h
R : Type ?u.164
inst✝ : Semiring R
f : R[X]
N i : ℕ
h : i ≤ N
j : ¬N - i ≤ N
⊢ N - i ≤ N

tactic: rfl
state_before: case inr
R : Type ?u.164
inst✝ : Semiring R
f : R[X]
N i : ℕ
h : ¬i ≤ N
⊢ i = i
Theorem: Computation.not_mem_empty
File: Mathlib/Data/Seq/Computation.lean

tactic: contradiction
state_before: α : Type u
β : Type v
γ : Type w
a : α
x✝ : a ∈ empty α
n : ℕ
h : (fun b => some a = b) (Stream'.nth (↑(empty α)) n)
⊢ False
Theorem: CategoryTheory.NatTrans.mapHomologicalComplex_comp
File: Mathlib/Algebra/Homology/Additive.lean

tactic: aesop_cat
state_before: ι : Type u_1
V : Type u
inst✝⁶ : Category V
inst✝⁵ : Preadditive V
c✝ : ComplexShape ι
C D E : HomologicalComplex V c✝
f g : C ⟶ D
h k : D ⟶ E
i : ι
W : Type u_3
inst✝⁴ : Category W
inst✝³ : Preadditive W
c : ComplexShape ι
F G H : V ⥤ W
inst✝² : Functor.Additive F
inst✝¹ : Functor.Additive G
inst✝ : Functor.Additive H
α : F ⟶ G
β : G ⟶ H
⊢ mapHomologicalComplex (α ≫ β) c = mapHomologicalComplex α c ≫ mapHomologicalComplex β c
Theorem: Ideal.span_singleton_mul_le_iff
File: Mathlib/RingTheory/Ideal/Operations.lean

tactic: simp only [mul_le, mem_span_singleton_mul, mem_span_singleton]
state_before: R : Type u
ι : Type ?u.232307
inst✝ : CommSemiring R
I✝ J✝ K L : Ideal R
x : R
I J : Ideal R
⊢ span {x} * I ≤ J ↔ ∀ (z : R), z ∈ I → x * z ∈ J

tactic: constructor
state_before: R : Type u
ι : Type ?u.232307
inst✝ : CommSemiring R
I✝ J✝ K L : Ideal R
x : R
I J : Ideal R
⊢ (∀ (r : R), x ∣ r → ∀ (s : R), s ∈ I → r * s ∈ J) ↔ ∀ (z : R), z ∈ I → x * z ∈ J

tactic: intro h zI hzI
state_before: case mp
R : Type u
ι : Type ?u.232307
inst✝ : CommSemiring R
I✝ J✝ K L : Ideal R
x : R
I J : Ideal R
⊢ (∀ (r : R), x ∣ r → ∀ (s : R), s ∈ I → r * s ∈ J) → ∀ (z : R), z ∈ I → x * z ∈ J

tactic: exact h x (dvd_refl x) zI hzI
state_before: case mp
R : Type u
ι : Type ?u.232307
inst✝ : CommSemiring R
I✝ J✝ K L : Ideal R
x : R
I J : Ideal R
h : ∀ (r : R), x ∣ r → ∀ (s : R), s ∈ I → r * s ∈ J
zI : R
hzI : zI ∈ I
⊢ x * zI ∈ J

tactic: rintro h _ ⟨z, rfl⟩ zI hzI
state_before: case mpr
R : Type u
ι : Type ?u.232307
inst✝ : CommSemiring R
I✝ J✝ K L : Ideal R
x : R
I J : Ideal R
⊢ (∀ (z : R), z ∈ I → x * z ∈ J) → ∀ (r : R), x ∣ r → ∀ (s : R), s ∈ I → r * s ∈ J

tactic: rw [mul_comm x z, mul_assoc]
state_before: case mpr.intro
R : Type u
ι : Type ?u.232307
inst✝ : CommSemiring R
I✝ J✝ K L : Ideal R
x : R
I J : Ideal R
h : ∀ (z : R), z ∈ I → x * z ∈ J
z zI : R
hzI : zI ∈ I
⊢ x * z * zI ∈ J

tactic: exact J.mul_mem_left _ (h zI hzI)
state_before: case mpr.intro
R : Type u
ι : Type ?u.232307
inst✝ : CommSemiring R
I✝ J✝ K L : Ideal R
x : R
I J : Ideal R
h : ∀ (z : R), z ∈ I → x * z ∈ J
z zI : R
hzI : zI ∈ I
⊢ z * (x * zI) ∈ J
Theorem: Sym2.mem_and_mem_iff
File: Mathlib/Data/Sym/Sym2.lean

tactic: constructor
state_before: α : Type u_1
β : Type ?u.35991
γ : Type ?u.35994
x y : α
z : Sym2 α
hne : x ≠ y
⊢ x ∈ z ∧ y ∈ z ↔ z = Quotient.mk (Rel.setoid α) (x, y)

tactic: induction' z using Sym2.ind with x' y'
state_before: case mp
α : Type u_1
β : Type ?u.35991
γ : Type ?u.35994
x y : α
z : Sym2 α
hne : x ≠ y
⊢ x ∈ z ∧ y ∈ z → z = Quotient.mk (Rel.setoid α) (x, y)

tactic: rw [mem_iff, mem_iff]
state_before: case mp.h
α : Type u_1
β : Type ?u.35991
γ : Type ?u.35994
x y : α
hne : x ≠ y
x' y' : α
⊢ x ∈ Quotient.mk (Rel.setoid α) (x', y') ∧ y ∈ Quotient.mk (Rel.setoid α) (x', y') →
    Quotient.mk (Rel.setoid α) (x', y') = Quotient.mk (Rel.setoid α) (x, y)

tactic: aesop
state_before: case mp.h
α : Type u_1
β : Type ?u.35991
γ : Type ?u.35994
x y : α
hne : x ≠ y
x' y' : α
⊢ (x = x' ∨ x = y') ∧ (y = x' ∨ y = y') → Quotient.mk (Rel.setoid α) (x', y') = Quotient.mk (Rel.setoid α) (x, y)

tactic: rintro rfl
state_before: case mpr
α : Type u_1
β : Type ?u.35991
γ : Type ?u.35994
x y : α
z : Sym2 α
hne : x ≠ y
⊢ z = Quotient.mk (Rel.setoid α) (x, y) → x ∈ z ∧ y ∈ z

tactic: simp
state_before: case mpr
α : Type u_1
β : Type ?u.35991
γ : Type ?u.35994
x y : α
hne : x ≠ y
⊢ x ∈ Quotient.mk (Rel.setoid α) (x, y) ∧ y ∈ Quotient.mk (Rel.setoid α) (x, y)
Theorem: Real.Angle.sign_ne_zero_iff
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

tactic: rw [← not_or, ← sign_eq_zero_iff]
state_before: θ : Angle
⊢ sign θ ≠ 0 ↔ θ ≠ 0 ∧ θ ≠ ↑π
Theorem: MvQPF.recF_eq'
File: Mathlib/Data/QPF/Multivariate/Constructions/Fix.lean

tactic: apply q.P.w_cases _ x
state_before: n : ℕ
F : TypeVec (n + 1) → Type u
inst✝ : MvFunctor F
q : MvQPF F
α : TypeVec n
β : Type u
g : F (α ::: β) → β
x : MvPFunctor.W (P F) α
⊢ recF g x = g (abs ((TypeVec.id ::: recF g) <$$> MvPFunctor.wDest' (P F) x))

tactic: intro a f' f
state_before: n : ℕ
F : TypeVec (n + 1) → Type u
inst✝ : MvFunctor F
q : MvQPF F
α : TypeVec n
β : Type u
g : F (α ::: β) → β
x : MvPFunctor.W (P F) α
⊢ ∀ (a : (P F).A) (f' : MvPFunctor.B (MvPFunctor.drop (P F)) a ⟹ α)
    (f : PFunctor.B (MvPFunctor.last (P F)) a → MvPFunctor.W (P F) α),
    recF g (MvPFunctor.wMk (P F) a f' f) =
      g (abs ((TypeVec.id ::: recF g) <$$> MvPFunctor.wDest' (P F) (MvPFunctor.wMk (P F) a f' f)))

tactic: rw [recF_eq, q.P.wDest'_wMk, MvPFunctor.map_eq, appendFun_comp_splitFun, TypeVec.id_comp]
state_before: n : ℕ
F : TypeVec (n + 1) → Type u
inst✝ : MvFunctor F
q : MvQPF F
α : TypeVec n
β : Type u
g : F (α ::: β) → β
x : MvPFunctor.W (P F) α
a : (P F).A
f' : MvPFunctor.B (MvPFunctor.drop (P F)) a ⟹ α
f : PFunctor.B (MvPFunctor.last (P F)) a → MvPFunctor.W (P F) α
⊢ recF g (MvPFunctor.wMk (P F) a f' f) =
    g (abs ((TypeVec.id ::: recF g) <$$> MvPFunctor.wDest' (P F) (MvPFunctor.wMk (P F) a f' f)))
Theorem: Multiset.cons_sub_of_le
File: Mathlib/Data/Multiset/Basic.lean

tactic: rw [← singleton_add, ← singleton_add, add_tsub_assoc_of_le h]
state_before: α : Type u_1
β : Type ?u.160229
γ : Type ?u.160232
inst✝ : DecidableEq α
s✝ t✝ u : Multiset α
a✝ b a : α
s t : Multiset α
h : t ≤ s
⊢ a ::ₘ s - t = a ::ₘ (s - t)
Theorem: tsum_pos
File: Mathlib/Topology/Algebra/InfiniteSum/Order.lean

tactic: rw [← tsum_zero]
state_before: ι : Type u_2
κ : Type ?u.47829
α : Type u_1
inst✝³ : OrderedAddCommGroup α
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalAddGroup α
inst✝ : OrderClosedTopology α
f g : ι → α
a₁ a₂ : α
i✝ : ι
hsum : Summable g
hg : ∀ (i : ι), 0 ≤ g i
i : ι
hi : 0 < g i
⊢ 0 < ∑' (i : ι), g i

tactic: exact tsum_lt_tsum hg hi summable_zero hsum
state_before: ι : Type u_2
κ : Type ?u.47829
α : Type u_1
inst✝³ : OrderedAddCommGroup α
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalAddGroup α
inst✝ : OrderClosedTopology α
f g : ι → α
a₁ a₂ : α
i✝ : ι
hsum : Summable g
hg : ∀ (i : ι), 0 ≤ g i
i : ι
hi : 0 < g i
⊢ (∑' (x : ?m.49191), 0) < ∑' (i : ι), g i

ι : Type u_2
κ : Type ?u.47829
α : Type u_1
inst✝³ : OrderedAddCommGroup α
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalAddGroup α
inst✝ : OrderClosedTopology α
f g : ι → α
a₁ a₂ : α
i✝ : ι
hsum : Summable g
hg : ∀ (i : ι), 0 ≤ g i
i : ι
hi : 0 < g i
⊢ Type ?u.49189
Theorem: MeasureTheory.OuterMeasure.map_top
File: Mathlib/MeasureTheory/Measure/OuterMeasure.lean

tactic: rw [map_apply, restrict_apply, ← image_preimage_eq_inter_range, top_apply', top_apply',
  Set.image_eq_empty]
state_before: α : Type u_2
β : Type u_1
R : Type ?u.127541
R' : Type ?u.127544
ms : Set (OuterMeasure α)
m : OuterMeasure α
f : α → β
s : Set β
⊢ ↑(↑(map f) ⊤) s = ↑(↑(restrict (range f)) ⊤) s
Theorem: Matrix.transpose_transpose
File: Mathlib/Data/Matrix/Basic.lean

tactic: ext
state_before: l : Type ?u.923744
m : Type u_1
n : Type u_2
o : Type ?u.923753
m' : o → Type ?u.923758
n' : o → Type ?u.923763
R : Type ?u.923766
S : Type ?u.923769
α : Type v
β : Type w
γ : Type ?u.923776
M : Matrix m n α
⊢ Mᵀᵀ = M

tactic: rfl
state_before: case a.h
l : Type ?u.923744
m : Type u_1
n : Type u_2
o : Type ?u.923753
m' : o → Type ?u.923758
n' : o → Type ?u.923763
R : Type ?u.923766
S : Type ?u.923769
α : Type v
β : Type w
γ : Type ?u.923776
M : Matrix m n α
i✝ : m
x✝ : n
⊢ Mᵀᵀ i✝ x✝ = M i✝ x✝
Theorem: Nat.div_one
File: Std/Data/Nat/Lemmas.lean

tactic: have := mod_add_div n 1
state_before: n : Nat
⊢ n / 1 = n

tactic: rwa [mod_one, Nat.zero_add, Nat.one_mul] at this
state_before: n : Nat
this : n % 1 + 1 * (n / 1) = n
⊢ n / 1 = n
Theorem: Filter.prod_neBot
File: Mathlib/Order/Filter/Prod.lean

tactic: simp only [neBot_iff, Ne, prod_eq_bot, not_or]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.50863
δ : Type ?u.50866
ι : Sort ?u.50869
s : Set α
t : Set β
f✝ : Filter α
g✝ : Filter β
f : Filter α
g : Filter β
⊢ NeBot (f ×ˢ g) ↔ NeBot f ∧ NeBot g
Theorem: padicNorm.padicNorm_of_prime_of_ne
File: Mathlib/NumberTheory/Padics/PadicNorm.lean

tactic: have p : padicValRat p q = 0 := by exact_mod_cast padicValNat_primes neq
state_before: p q : ℕ
p_prime : Fact (Nat.Prime p)
q_prime : Fact (Nat.Prime q)
neq : p ≠ q
⊢ padicNorm p ↑q = 1

tactic: rw [padicNorm, p]
state_before: p✝ q : ℕ
p_prime : Fact (Nat.Prime p✝)
q_prime : Fact (Nat.Prime q)
neq : p✝ ≠ q
p : padicValRat p✝ ↑q = 0
⊢ padicNorm p✝ ↑q = 1

tactic: simp [q_prime.1.ne_zero]
state_before: p✝ q : ℕ
p_prime : Fact (Nat.Prime p✝)
q_prime : Fact (Nat.Prime q)
neq : p✝ ≠ q
p : padicValRat p✝ ↑q = 0
⊢ (if ↑q = 0 then 0 else ↑p✝ ^ (-0)) = 1

tactic: exact_mod_cast padicValNat_primes neq
state_before: p q : ℕ
p_prime : Fact (Nat.Prime p)
q_prime : Fact (Nat.Prime q)
neq : p ≠ q
⊢ padicValRat p ↑q = 0
Theorem: Multiset.product_add
File: Mathlib/Data/Multiset/Bind.lean

tactic: rw [cons_product, IH]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.60368
δ : Type ?u.60371
a✝ : α
b : β
s✝¹ : Multiset α
t✝ : Multiset β
s✝ : Multiset α
a : α
s : Multiset α
IH : ∀ (t u : Multiset β), s ×ˢ (t + u) = s ×ˢ t + s ×ˢ u
t u : Multiset β
⊢ (a ::ₘ s) ×ˢ (t + u) = (a ::ₘ s) ×ˢ t + (a ::ₘ s) ×ˢ u

tactic: simp [add_comm, add_left_comm, add_assoc]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.60368
δ : Type ?u.60371
a✝ : α
b : β
s✝¹ : Multiset α
t✝ : Multiset β
s✝ : Multiset α
a : α
s : Multiset α
IH : ∀ (t u : Multiset β), s ×ˢ (t + u) = s ×ˢ t + s ×ˢ u
t u : Multiset β
⊢ map (Prod.mk a) (t + u) + (s ×ˢ t + s ×ˢ u) = (a ::ₘ s) ×ˢ t + (a ::ₘ s) ×ˢ u
Theorem: Finsupp.single_eq_zero
File: Mathlib/Data/Finsupp/Defs.lean

tactic: simp [FunLike.ext_iff, single_eq_set_indicator]
state_before: α : Type u_1
β : Type ?u.58789
γ : Type ?u.58792
ι : Type ?u.58795
M : Type u_2
M' : Type ?u.58801
N : Type ?u.58804
P : Type ?u.58807
G : Type ?u.58810
H : Type ?u.58813
R : Type ?u.58816
S : Type ?u.58819
inst✝ : Zero M
a a' : α
b : M
⊢ single a b = 0 ↔ b = 0
Theorem: ENNReal.rpow_lt_rpow_of_exponent_lt
File: Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean

tactic: lift x to ℝ≥0 using hx'
state_before: x : ℝ≥0∞
y z : ℝ
hx : 1 < x
hx' : x ≠ ⊤
hyz : y < z
⊢ x ^ y < x ^ z

tactic: rw [one_lt_coe_iff] at hx
state_before: case intro
y z : ℝ
hyz : y < z
x : ℝ≥0
hx : 1 < ↑x
⊢ ↑x ^ y < ↑x ^ z

tactic: simp [coe_rpow_of_ne_zero (ne_of_gt (lt_trans zero_lt_one hx)),
  NNReal.rpow_lt_rpow_of_exponent_lt hx hyz]
state_before: case intro
y z : ℝ
hyz : y < z
x : ℝ≥0
hx : 1 < x
⊢ ↑x ^ y < ↑x ^ z
Theorem: Submodule.IsPrincipal.generator_map_dvd_of_mem
File: Mathlib/RingTheory/PrincipalIdealDomain.lean

tactic: rw [← mem_iff_generator_dvd, Submodule.mem_map]
state_before: R : Type u
M : Type v
inst✝³ : AddCommGroup M
inst✝² : CommRing R
inst✝¹ : Module R M
N : Submodule R M
ϕ : M →ₗ[R] R
inst✝ : IsPrincipal (map ϕ N)
x : M
hx : x ∈ N
⊢ generator (map ϕ N) ∣ ↑ϕ x

tactic: exact ⟨x, hx, rfl⟩
state_before: R : Type u
M : Type v
inst✝³ : AddCommGroup M
inst✝² : CommRing R
inst✝¹ : Module R M
N : Submodule R M
ϕ : M →ₗ[R] R
inst✝ : IsPrincipal (map ϕ N)
x : M
hx : x ∈ N
⊢ ∃ y, y ∈ N ∧ ↑ϕ y = ↑ϕ x
Theorem: Matrix.cons_vec_bit0_eq_alt0
File: Mathlib/Data/Fin/VecNotation.lean

tactic: rw [vecAlt0_vecAppend]
state_before: α : Type u
m n o : ℕ
m' : Type ?u.49580
n' : Type ?u.49583
o' : Type ?u.49586
x : α
u : Fin n → α
i : Fin (n + 1)
⊢ vecCons x u (bit0 i) =
    vecAlt0 (_ : Nat.succ n + Nat.succ n = Nat.succ n + Nat.succ n)
      (vecAppend (_ : Nat.succ n + Nat.succ n = Nat.succ n + Nat.succ n) (vecCons x u) (vecCons x u)) i

tactic: rfl
state_before: α : Type u
m n o : ℕ
m' : Type ?u.49580
n' : Type ?u.49583
o' : Type ?u.49586
x : α
u : Fin n → α
i : Fin (n + 1)
⊢ vecCons x u (bit0 i) = (vecCons x u ∘ bit0) i
Theorem: Std.BinomialHeapImp.Heap.deleteMin_fst
File: Std/Data/BinomialHeap.lean

tactic: simp only [deleteMin, findMin_val, Option.map, head?]
state_before: α : Type u_1
s✝ : Heap α
le : α → α → Bool
r : Nat
a : α
c : HeapNode α
s : Heap α
⊢ Option.map (fun x => x.fst) (deleteMin le (cons r a c s)) = head? le (cons r a c s)
Theorem: LowerSet.map_Iic
File: Mathlib/Order/UpperLower/Basic.lean

tactic: ext
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.117528
ι : Sort ?u.117531
κ : ι → Sort ?u.117536
inst✝¹ : Preorder α
inst✝ : Preorder β
s : LowerSet α
a✝ b : α
f : α ≃o β
a : α
⊢ ↑(map f) (Iic a) = Iic (↑f a)

tactic: simp
state_before: case a.h
α : Type u_1
β : Type u_2
γ : Type ?u.117528
ι : Sort ?u.117531
κ : ι → Sort ?u.117536
inst✝¹ : Preorder α
inst✝ : Preorder β
s : LowerSet α
a✝ b : α
f : α ≃o β
a : α
x✝ : β
⊢ x✝ ∈ ↑(↑(map f) (Iic a)) ↔ x✝ ∈ ↑(Iic (↑f a))
Theorem: Subgroup.relindex_sup_left
File: Mathlib/GroupTheory/Index.lean

tactic: rw [sup_comm, relindex_sup_right]
state_before: G : Type u_1
inst✝¹ : Group G
H K L : Subgroup G
inst✝ : Normal K
⊢ relindex K (K ⊔ H) = relindex K H
Theorem: SimpleGraph.edgeFinset_inj
File: Mathlib/Combinatorics/SimpleGraph/Basic.lean

tactic: simp
state_before: ι : Sort ?u.106151
𝕜 : Type ?u.106154
V : Type u
W : Type v
X : Type w
G : SimpleGraph V
G' : SimpleGraph W
a b c u v w : V
e : Sym2 V
G₁ G₂ : SimpleGraph V
inst✝² : Fintype ↑(edgeSet G)
inst✝¹ : Fintype ↑(edgeSet G₁)
inst✝ : Fintype ↑(edgeSet G₂)
⊢ edgeFinset G₁ = edgeFinset G₂ ↔ G₁ = G₂
Theorem: CategoryTheory.shift_shiftFunctorCompIsoId_inv_app
File: Mathlib/CategoryTheory/Shift/Basic.lean

tactic: rw [← neg_eq_of_add_eq_zero_left h, add_right_neg]
state_before: C : Type u
A : Type ?u.197556
inst✝² : Category C
inst✝¹ : AddGroup A
inst✝ : HasShift C A
X✝ Y : C
f : X✝ ⟶ Y
n m : A
h : n + m = 0
X : C
⊢ m + n = 0

tactic: rw [← cancel_mono (((shiftFunctorCompIsoId C n m h).hom.app X)⟦n⟧'),
  ← Functor.map_comp, Iso.inv_hom_id_app, Functor.map_id,
  shift_shiftFunctorCompIsoId_hom_app, Iso.inv_hom_id_app]
state_before: C : Type u
A : Type u_1
inst✝² : Category C
inst✝¹ : AddGroup A
inst✝ : HasShift C A
X✝ Y : C
f : X✝ ⟶ Y
n m : A
h : n + m = 0
X : C
⊢ (shiftFunctor C n).map ((shiftFunctorCompIsoId C n m h).inv.app X) =
    (shiftFunctorCompIsoId C m n (_ : m + n = 0)).inv.app ((shiftFunctor C n).obj X)

tactic: rfl
state_before: C : Type u
A : Type u_1
inst✝² : Category C
inst✝¹ : AddGroup A
inst✝ : HasShift C A
X✝ Y : C
f : X✝ ⟶ Y
n m : A
h : n + m = 0
X : C
⊢ 𝟙 ((shiftFunctor C n).obj ((𝟭 C).obj X)) = 𝟙 ((𝟭 C).obj ((shiftFunctor C n).obj X))
Theorem: closure_openSegment
File: Mathlib/Analysis/Convex/Topology.lean

tactic: rw [segment_eq_image, openSegment_eq_image, ← closure_Ioo (zero_ne_one' 𝕜)]
state_before: ι : Type ?u.22920
𝕜 : Type u_2
E : Type u_1
inst✝¹¹ : LinearOrderedRing 𝕜
inst✝¹⁰ : DenselyOrdered 𝕜
inst✝⁹ : PseudoMetricSpace 𝕜
inst✝⁸ : OrderTopology 𝕜
inst✝⁷ : ProperSpace 𝕜
inst✝⁶ : CompactIccSpace 𝕜
inst✝⁵ : AddCommGroup E
inst✝⁴ : TopologicalSpace E
inst✝³ : T2Space E
inst✝² : ContinuousAdd E
inst✝¹ : Module 𝕜 E
inst✝ : ContinuousSMul 𝕜 E
x y : E
⊢ closure (openSegment 𝕜 x y) = [x-[𝕜]y]

tactic: exact
  (image_closure_of_isCompact (bounded_Ioo _ _).isCompact_closure <|
      Continuous.continuousOn <| by continuity).symm
state_before: ι : Type ?u.22920
𝕜 : Type u_2
E : Type u_1
inst✝¹¹ : LinearOrderedRing 𝕜
inst✝¹⁰ : DenselyOrdered 𝕜
inst✝⁹ : PseudoMetricSpace 𝕜
inst✝⁸ : OrderTopology 𝕜
inst✝⁷ : ProperSpace 𝕜
inst✝⁶ : CompactIccSpace 𝕜
inst✝⁵ : AddCommGroup E
inst✝⁴ : TopologicalSpace E
inst✝³ : T2Space E
inst✝² : ContinuousAdd E
inst✝¹ : Module 𝕜 E
inst✝ : ContinuousSMul 𝕜 E
x y : E
⊢ closure ((fun θ => (1 - θ) • x + θ • y) '' Ioo 0 1) = (fun θ => (1 - θ) • x + θ • y) '' closure (Ioo 0 1)

tactic: continuity
state_before: ι : Type ?u.22920
𝕜 : Type u_2
E : Type u_1
inst✝¹¹ : LinearOrderedRing 𝕜
inst✝¹⁰ : DenselyOrdered 𝕜
inst✝⁹ : PseudoMetricSpace 𝕜
inst✝⁸ : OrderTopology 𝕜
inst✝⁷ : ProperSpace 𝕜
inst✝⁶ : CompactIccSpace 𝕜
inst✝⁵ : AddCommGroup E
inst✝⁴ : TopologicalSpace E
inst✝³ : T2Space E
inst✝² : ContinuousAdd E
inst✝¹ : Module 𝕜 E
inst✝ : ContinuousSMul 𝕜 E
x y : E
⊢ Continuous fun θ => (1 - θ) • x + θ • y
Theorem: BinaryHeap.size_insert
File: Mathlib/Data/BinaryHeap.lean

tactic: simp [insert, size, size_heapifyUp]
state_before: α : Type u_1
lt : α → α → Bool
self : BinaryHeap α lt
x : α
⊢ size (insert self x) = size self + 1
Theorem: covariant_le_of_covariant_lt
File: Mathlib/Algebra/CovariantAndContravariant.lean

tactic: intro h a b c bc
state_before: M : Type u_2
N : Type u_1
μ : M → N → N
r : N → N → Prop
inst✝ : PartialOrder N
⊢ (Covariant M N μ fun x x_1 => x < x_1) → Covariant M N μ fun x x_1 => x ≤ x_1

tactic: rcases le_iff_eq_or_lt.mp bc with (rfl | bc)
state_before: M : Type u_2
N : Type u_1
μ : M → N → N
r : N → N → Prop
inst✝ : PartialOrder N
h : Covariant M N μ fun x x_1 => x < x_1
a : M
b c : N
bc : b ≤ c
⊢ μ a b ≤ μ a c

tactic: exact rfl.le
state_before: case inl
M : Type u_2
N : Type u_1
μ : M → N → N
r : N → N → Prop
inst✝ : PartialOrder N
h : Covariant M N μ fun x x_1 => x < x_1
a : M
b : N
bc : b ≤ b
⊢ μ a b ≤ μ a b

tactic: exact (h _ bc).le
state_before: case inr
M : Type u_2
N : Type u_1
μ : M → N → N
r : N → N → Prop
inst✝ : PartialOrder N
h : Covariant M N μ fun x x_1 => x < x_1
a : M
b c : N
bc✝ : b ≤ c
bc : b < c
⊢ μ a b ≤ μ a c
Theorem: BoxIntegral.Box.mk'_eq_bot
File: Mathlib/Analysis/BoxIntegral/Box/Basic.lean

tactic: rw [mk']
state_before: ι : Type u_1
I J : Box ι
x y l u : ι → ℝ
⊢ mk' l u = ⊥ ↔ ∃ i, u i ≤ l i

tactic: split_ifs with h <;> simpa using h
state_before: ι : Type u_1
I J : Box ι
x y l u : ι → ℝ
⊢ (if h : ∀ (i : ι), l i < u i then ↑{ lower := l, upper := u, lower_lt_upper := h } else ⊥) = ⊥ ↔ ∃ i, u i ≤ l i