file_path
stringlengths 11
79
| full_name
stringlengths 2
100
| traced_tactics
list | end
list | commit
stringclasses 4
values | url
stringclasses 4
values | start
list |
|---|---|---|---|---|---|---|
Mathlib/Order/Filter/Basic.lean
|
Filter.map_comap_of_mem
|
[
{
"state_after": "no goals",
"state_before": "α : Type u\nβ : Type v\nγ : Type w\nδ : Type ?u.257261\nι : Sort x\nf✝ f₁ f₂ : Filter α\ng g₁ g₂ : Filter β\nm✝ : α → β\nm' : β → γ\ns : Set α\nt : Set β\nf : Filter β\nm : α → β\nhf : range m ∈ f\n⊢ map m (comap m f) = f",
"tactic": "rw [map_comap, inf_eq_left.2 (le_principal_iff.2 hf)]"
}
] |
[
2260,
56
] |
5a919533f110b7d76410134a237ee374f24eaaad
|
https://github.com/leanprover-community/mathlib4
|
[
2259,
1
] |
Std/Data/Int/DivMod.lean
|
Int.natAbs_div
|
[
{
"state_after": "a b : Int\nw✝¹ w✝ : Nat\n⊢ natAbs (div ↑w✝¹ ↑w✝) = Nat.div (natAbs ↑w✝¹) (natAbs ↑w✝)",
"state_before": "a b : Int\nw✝¹ w✝ : Nat\n⊢ natAbs (div (↑w✝¹) (-↑w✝)) = Nat.div (natAbs ↑w✝¹) (natAbs (-↑w✝))",
"tactic": "rw [Int.div_neg, natAbs_neg, natAbs_neg]"
},
{
"state_after": "no goals",
"state_before": "a b : Int\nw✝¹ w✝ : Nat\n⊢ natAbs (div ↑w✝¹ ↑w✝) = Nat.div (natAbs ↑w✝¹) (natAbs ↑w✝)",
"tactic": "rfl"
},
{
"state_after": "a b : Int\nw✝¹ w✝ : Nat\n⊢ natAbs (div ↑w✝¹ ↑w✝) = Nat.div (natAbs ↑w✝¹) (natAbs ↑w✝)",
"state_before": "a b : Int\nw✝¹ w✝ : Nat\n⊢ natAbs (div (-↑w✝¹) ↑w✝) = Nat.div (natAbs (-↑w✝¹)) (natAbs ↑w✝)",
"tactic": "rw [Int.neg_div, natAbs_neg, natAbs_neg]"
},
{
"state_after": "no goals",
"state_before": "a b : Int\nw✝¹ w✝ : Nat\n⊢ natAbs (div ↑w✝¹ ↑w✝) = Nat.div (natAbs ↑w✝¹) (natAbs ↑w✝)",
"tactic": "rfl"
},
{
"state_after": "a b : Int\nw✝¹ w✝ : Nat\n⊢ natAbs (div ↑w✝¹ ↑w✝) = Nat.div (natAbs ↑w✝¹) (natAbs ↑w✝)",
"state_before": "a b : Int\nw✝¹ w✝ : Nat\n⊢ natAbs (div (-↑w✝¹) (-↑w✝)) = Nat.div (natAbs (-↑w✝¹)) (natAbs (-↑w✝))",
"tactic": "rw [Int.neg_div_neg, natAbs_neg, natAbs_neg]"
},
{
"state_after": "no goals",
"state_before": "a b : Int\nw✝¹ w✝ : Nat\n⊢ natAbs (div ↑w✝¹ ↑w✝) = Nat.div (natAbs ↑w✝¹) (natAbs ↑w✝)",
"tactic": "rfl"
}
] |
[
563,
95
] |
e68aa8f5fe47aad78987df45f99094afbcb5e936
|
https://github.com/leanprover/std4
|
[
558,
9
] |
Mathlib/Combinatorics/SimpleGraph/AdjMatrix.lean
|
SimpleGraph.adjMatrix_mulVec_const_apply_of_regular
|
[
{
"state_after": "no goals",
"state_before": "V : Type u_2\nα : Type u_1\nβ : Type ?u.66478\nG : SimpleGraph V\ninst✝² : DecidableRel G.Adj\ninst✝¹ : Fintype V\ninst✝ : Semiring α\nd : ℕ\na : α\nhd : IsRegularOfDegree G d\nv : V\n⊢ mulVec (adjMatrix α G) (Function.const V a) v = ↑d * a",
"tactic": "simp [hd v]"
}
] |
[
261,
17
] |
5a919533f110b7d76410134a237ee374f24eaaad
|
https://github.com/leanprover-community/mathlib4
|
[
259,
1
] |
src/lean/Init/Core.lean
|
decide_false_eq_false
|
[] |
[
700,
30
] |
d5348dfac847a56a4595fb6230fd0708dcb4e7e9
|
https://github.com/leanprover/lean4
|
[
697,
1
] |
Mathlib/GroupTheory/Subsemigroup/Operations.lean
|
Subsemigroup.srange_snd
|
[] |
[
919,
60
] |
5a919533f110b7d76410134a237ee374f24eaaad
|
https://github.com/leanprover-community/mathlib4
|
[
918,
1
] |
Mathlib/Analysis/BoxIntegral/Partition/Tagged.lean
|
BoxIntegral.Prepartition.mem_biUnionTagged
|
[] |
[
140,
16
] |
5a919533f110b7d76410134a237ee374f24eaaad
|
https://github.com/leanprover-community/mathlib4
|
[
138,
1
] |
Mathlib/Data/List/Pairwise.lean
|
List.pairwise_pair
|
[
{
"state_after": "no goals",
"state_before": "α : Type u_1\nβ : Type ?u.9008\nR S T : α → α → Prop\na✝ : α\nl : List α\na b : α\n⊢ Pairwise R [a, b] ↔ R a b",
"tactic": "simp only [pairwise_cons, mem_singleton, forall_eq, forall_prop_of_false (not_mem_nil _),\n forall_true_iff, Pairwise.nil, and_true_iff]"
}
] |
[
161,
49
] |
5a919533f110b7d76410134a237ee374f24eaaad
|
https://github.com/leanprover-community/mathlib4
|
[
159,
1
] |
Mathlib/NumberTheory/Zsqrtd/Basic.lean
|
Zsqrtd.muld_val
|
[
{
"state_after": "no goals",
"state_before": "d x y : ℤ\n⊢ sqrtd * { re := x, im := y } = { re := d * y, im := x }",
"tactic": "simp [ext]"
}
] |
[
326,
83
] |
5a919533f110b7d76410134a237ee374f24eaaad
|
https://github.com/leanprover-community/mathlib4
|
[
326,
1
] |
Mathlib/Algebra/Order/Hom/Ring.lean
|
OrderRingIso.symm_trans_self
|
[] |
[
505,
18
] |
5a919533f110b7d76410134a237ee374f24eaaad
|
https://github.com/leanprover-community/mathlib4
|
[
504,
1
] |
Mathlib/Order/Filter/Basic.lean
|
Filter.comap_fst_neBot_iff
|
[
{
"state_after": "case inl\nα : Type u\nβ : Type v\nγ : Type w\nδ : Type ?u.265787\nι : Sort x\nf✝ f₁ f₂ : Filter α\ng g₁ g₂ : Filter β\nm : α → β\nm' : β → γ\ns : Set α\nt : Set β\nf : Filter α\nh✝ : IsEmpty β\n⊢ NeBot (comap Prod.fst f) ↔ NeBot f ∧ Nonempty β\n\ncase inr\nα : Type u\nβ : Type v\nγ : Type w\nδ : Type ?u.265787\nι : Sort x\nf✝ f₁ f₂ : Filter α\ng g₁ g₂ : Filter β\nm : α → β\nm' : β → γ\ns : Set α\nt : Set β\nf : Filter α\nh✝ : Nonempty β\n⊢ NeBot (comap Prod.fst f) ↔ NeBot f ∧ Nonempty β",
"state_before": "α : Type u\nβ : Type v\nγ : Type w\nδ : Type ?u.265787\nι : Sort x\nf✝ f₁ f₂ : Filter α\ng g₁ g₂ : Filter β\nm : α → β\nm' : β → γ\ns : Set α\nt : Set β\nf : Filter α\n⊢ NeBot (comap Prod.fst f) ↔ NeBot f ∧ Nonempty β",
"tactic": "cases isEmpty_or_nonempty β"
},
{
"state_after": "case inl\nα : Type u\nβ : Type v\nγ : Type w\nδ : Type ?u.265787\nι : Sort x\nf✝ f₁ f₂ : Filter α\ng g₁ g₂ : Filter β\nm : α → β\nm' : β → γ\ns : Set α\nt : Set β\nf : Filter α\nh✝ : IsEmpty β\n⊢ ¬NeBot ⊥ ↔ ¬(NeBot f ∧ Nonempty β)",
"state_before": "case inl\nα : Type u\nβ : Type v\nγ : Type w\nδ : Type ?u.265787\nι : Sort x\nf✝ f₁ f₂ : Filter α\ng g₁ g₂ : Filter β\nm : α → β\nm' : β → γ\ns : Set α\nt : Set β\nf : Filter α\nh✝ : IsEmpty β\n⊢ NeBot (comap Prod.fst f) ↔ NeBot f ∧ Nonempty β",
"tactic": "rw [filter_eq_bot_of_isEmpty (f.comap _), ← not_iff_not]"
},
{
"state_after": "no goals",
"state_before": "case inl\nα : Type u\nβ : Type v\nγ : Type w\nδ : Type ?u.265787\nι : Sort x\nf✝ f₁ f₂ : Filter α\ng g₁ g₂ : Filter β\nm : α → β\nm' : β → γ\ns : Set α\nt : Set β\nf : Filter α\nh✝ : IsEmpty β\n⊢ ¬NeBot ⊥ ↔ ¬(NeBot f ∧ Nonempty β)",
"tactic": "simp [*]"
},
{
"state_after": "no goals",
"state_before": "case inr\nα : Type u\nβ : Type v\nγ : Type w\nδ : Type ?u.265787\nι : Sort x\nf✝ f₁ f₂ : Filter α\ng g₁ g₂ : Filter β\nm : α → β\nm' : β → γ\ns : Set α\nt : Set β\nf : Filter α\nh✝ : Nonempty β\n⊢ NeBot (comap Prod.fst f) ↔ NeBot f ∧ Nonempty β",
"tactic": "simp [comap_neBot_iff_frequently, *]"
}
] |
[
2379,
41
] |
5a919533f110b7d76410134a237ee374f24eaaad
|
https://github.com/leanprover-community/mathlib4
|
[
2375,
1
] |
Mathlib/Data/Nat/Totient.lean
|
Nat.totient_eq_prod_factorization
|
[
{
"state_after": "n : ℕ\nhn : n ≠ 0\n⊢ (Finsupp.prod (factorization n) fun p k => φ (p ^ k)) =\n Finsupp.prod (factorization n) fun p k => p ^ (k - 1) * (p - 1)",
"state_before": "n : ℕ\nhn : n ≠ 0\n⊢ φ n = Finsupp.prod (factorization n) fun p k => p ^ (k - 1) * (p - 1)",
"tactic": "rw [multiplicative_factorization φ (@totient_mul) totient_one hn]"
},
{
"state_after": "n : ℕ\nhn : n ≠ 0\n⊢ ∀ (x : ℕ), x ∈ (factorization n).support → φ (x ^ ↑(factorization n) x) = x ^ (↑(factorization n) x - 1) * (x - 1)",
"state_before": "n : ℕ\nhn : n ≠ 0\n⊢ (Finsupp.prod (factorization n) fun p k => φ (p ^ k)) =\n Finsupp.prod (factorization n) fun p k => p ^ (k - 1) * (p - 1)",
"tactic": "apply Finsupp.prod_congr _"
},
{
"state_after": "n : ℕ\nhn : n ≠ 0\np : ℕ\nhp : p ∈ (factorization n).support\n⊢ φ (p ^ ↑(factorization n) p) = p ^ (↑(factorization n) p - 1) * (p - 1)",
"state_before": "n : ℕ\nhn : n ≠ 0\n⊢ ∀ (x : ℕ), x ∈ (factorization n).support → φ (x ^ ↑(factorization n) x) = x ^ (↑(factorization n) x - 1) * (x - 1)",
"tactic": "intro p hp"
},
{
"state_after": "n : ℕ\nhn : n ≠ 0\np : ℕ\nhp : p ∈ (factorization n).support\nh : 0 < ↑(factorization n) p\n⊢ φ (p ^ ↑(factorization n) p) = p ^ (↑(factorization n) p - 1) * (p - 1)",
"state_before": "n : ℕ\nhn : n ≠ 0\np : ℕ\nhp : p ∈ (factorization n).support\n⊢ φ (p ^ ↑(factorization n) p) = p ^ (↑(factorization n) p - 1) * (p - 1)",
"tactic": "have h := zero_lt_iff.mpr (Finsupp.mem_support_iff.mp hp)"
},
{
"state_after": "no goals",
"state_before": "n : ℕ\nhn : n ≠ 0\np : ℕ\nhp : p ∈ (factorization n).support\nh : 0 < ↑(factorization n) p\n⊢ φ (p ^ ↑(factorization n) p) = p ^ (↑(factorization n) p - 1) * (p - 1)",
"tactic": "rw [totient_prime_pow (prime_of_mem_factorization hp) h]"
}
] |
[
292,
59
] |
5a919533f110b7d76410134a237ee374f24eaaad
|
https://github.com/leanprover-community/mathlib4
|
[
286,
1
] |
Mathlib/Algebra/Order/ToIntervalMod.lean
|
toIocDiv_add_zsmul'
|
[
{
"state_after": "α : Type u_1\ninst✝ : LinearOrderedAddCommGroup α\nhα : Archimedean α\np : α\nhp : 0 < p\na✝ b✝ c : α\nn : ℤ\na b : α\nm : ℤ\n⊢ b - (toIocDiv hp a b - m) • p ∈ Set.Ioc (a + m • p) (a + m • p + p)",
"state_before": "α : Type u_1\ninst✝ : LinearOrderedAddCommGroup α\nhα : Archimedean α\np : α\nhp : 0 < p\na✝ b✝ c : α\nn : ℤ\na b : α\nm : ℤ\n⊢ toIocDiv hp (a + m • p) b = toIocDiv hp a b - m",
"tactic": "refine' toIocDiv_eq_of_sub_zsmul_mem_Ioc _ _"
},
{
"state_after": "α : Type u_1\ninst✝ : LinearOrderedAddCommGroup α\nhα : Archimedean α\np : α\nhp : 0 < p\na✝ b✝ c : α\nn : ℤ\na b : α\nm : ℤ\n⊢ b - toIocDiv hp a b • p + m • p ∈ Set.Ioc (a + m • p) (a + p + m • p)",
"state_before": "α : Type u_1\ninst✝ : LinearOrderedAddCommGroup α\nhα : Archimedean α\np : α\nhp : 0 < p\na✝ b✝ c : α\nn : ℤ\na b : α\nm : ℤ\n⊢ b - (toIocDiv hp a b - m) • p ∈ Set.Ioc (a + m • p) (a + m • p + p)",
"tactic": "rw [sub_smul, ← sub_add, add_right_comm]"
},
{
"state_after": "no goals",
"state_before": "α : Type u_1\ninst✝ : LinearOrderedAddCommGroup α\nhα : Archimedean α\np : α\nhp : 0 < p\na✝ b✝ c : α\nn : ℤ\na b : α\nm : ℤ\n⊢ b - toIocDiv hp a b • p + m • p ∈ Set.Ioc (a + m • p) (a + p + m • p)",
"tactic": "simpa using sub_toIocDiv_zsmul_mem_Ioc hp a b"
}
] |
[
259,
48
] |
5a919533f110b7d76410134a237ee374f24eaaad
|
https://github.com/leanprover-community/mathlib4
|
[
255,
1
] |
Mathlib/Data/Polynomial/FieldDivision.lean
|
Polynomial.map_dvd_map'
|
[
{
"state_after": "no goals",
"state_before": "R : Type u\nS : Type v\nk : Type y\nA : Type z\na b : R\nn : ℕ\ninst✝¹ : Field R\np q : R[X]\ninst✝ : Field k\nf : R →+* k\nx y : R[X]\nH : x = 0\n⊢ map f x ∣ map f y ↔ x ∣ y",
"tactic": "rw [H, Polynomial.map_zero, zero_dvd_iff, zero_dvd_iff, map_eq_zero]"
},
{
"state_after": "no goals",
"state_before": "R : Type u\nS : Type v\nk : Type y\nA : Type z\na b : R\nn : ℕ\ninst✝¹ : Field R\np q : R[X]\ninst✝ : Field k\nf : R →+* k\nx y : R[X]\nH : ¬x = 0\n⊢ map f x ∣ map f y ↔ x ∣ y",
"tactic": "rw [← normalize_dvd_iff, ← @normalize_dvd_iff R[X], normalize_apply, normalize_apply,\n coe_normUnit_of_ne_zero H, coe_normUnit_of_ne_zero (mt (map_eq_zero f).1 H),\n leadingCoeff_map, ← map_inv₀ f, ← map_C, ← Polynomial.map_mul,\n map_dvd_map _ f.injective (monic_mul_leadingCoeff_inv H)]"
}
] |
[
470,
64
] |
5a919533f110b7d76410134a237ee374f24eaaad
|
https://github.com/leanprover-community/mathlib4
|
[
464,
1
] |
Mathlib/Data/Polynomial/FieldDivision.lean
|
Polynomial.mem_roots_map
|
[
{
"state_after": "no goals",
"state_before": "R : Type u\nS : Type v\nk : Type y\nA : Type z\na b : R\nn : ℕ\ninst✝² : Field R\np q : R[X]\ninst✝¹ : CommRing k\ninst✝ : IsDomain k\nf : R →+* k\nx : k\nhp : p ≠ 0\n⊢ x ∈ roots (map f p) ↔ eval₂ f x p = 0",
"tactic": "rw [mem_roots (map_ne_zero hp), IsRoot, Polynomial.eval_map]"
}
] |
[
365,
63
] |
5a919533f110b7d76410134a237ee374f24eaaad
|
https://github.com/leanprover-community/mathlib4
|
[
363,
1
] |
Mathlib/Data/List/Basic.lean
|
List.zipLeft_cons_cons
|
[] |
[
4193,
6
] |
5a919533f110b7d76410134a237ee374f24eaaad
|
https://github.com/leanprover-community/mathlib4
|
[
4192,
1
] |
Mathlib/MeasureTheory/Measure/MeasureSpace.lean
|
map_restrict_ae_le_map_indicator_ae
|
[
{
"state_after": "α : Type u_2\nβ : Type u_1\nγ : Type ?u.4605823\nδ : Type ?u.4605826\nι : Type ?u.4605829\nR : Type ?u.4605832\nR' : Type ?u.4605835\ninst✝¹ : MeasurableSpace α\nμ : MeasureTheory.Measure α\ns t✝ : Set α\nf : α → β\ninst✝ : Zero β\nhs : MeasurableSet s\nt : Set β\n⊢ t ∈ Filter.map (indicator s f) (ae μ) → t ∈ Filter.map f (ae (Measure.restrict μ s))",
"state_before": "α : Type u_2\nβ : Type u_1\nγ : Type ?u.4605823\nδ : Type ?u.4605826\nι : Type ?u.4605829\nR : Type ?u.4605832\nR' : Type ?u.4605835\ninst✝¹ : MeasurableSpace α\nμ : MeasureTheory.Measure α\ns t : Set α\nf : α → β\ninst✝ : Zero β\nhs : MeasurableSet s\n⊢ Filter.map f (ae (Measure.restrict μ s)) ≤ Filter.map (indicator s f) (ae μ)",
"tactic": "intro t"
},
{
"state_after": "case pos\nα : Type u_2\nβ : Type u_1\nγ : Type ?u.4605823\nδ : Type ?u.4605826\nι : Type ?u.4605829\nR : Type ?u.4605832\nR' : Type ?u.4605835\ninst✝¹ : MeasurableSpace α\nμ : MeasureTheory.Measure α\ns t✝ : Set α\nf : α → β\ninst✝ : Zero β\nhs : MeasurableSet s\nt : Set β\nht : 0 ∈ t\n⊢ t ∈ Filter.map (indicator s f) (ae μ) → t ∈ Filter.map f (ae (Measure.restrict μ s))\n\ncase neg\nα : Type u_2\nβ : Type u_1\nγ : Type ?u.4605823\nδ : Type ?u.4605826\nι : Type ?u.4605829\nR : Type ?u.4605832\nR' : Type ?u.4605835\ninst✝¹ : MeasurableSpace α\nμ : MeasureTheory.Measure α\ns t✝ : Set α\nf : α → β\ninst✝ : Zero β\nhs : MeasurableSet s\nt : Set β\nht : ¬0 ∈ t\n⊢ t ∈ Filter.map (indicator s f) (ae μ) → t ∈ Filter.map f (ae (Measure.restrict μ s))",
"state_before": "α : Type u_2\nβ : Type u_1\nγ : Type ?u.4605823\nδ : Type ?u.4605826\nι : Type ?u.4605829\nR : Type ?u.4605832\nR' : Type ?u.4605835\ninst✝¹ : MeasurableSpace α\nμ : MeasureTheory.Measure α\ns t✝ : Set α\nf : α → β\ninst✝ : Zero β\nhs : MeasurableSet s\nt : Set β\n⊢ t ∈ Filter.map (indicator s f) (ae μ) → t ∈ Filter.map f (ae (Measure.restrict μ s))",
"tactic": "by_cases ht : (0 : β) ∈ t"
},
{
"state_after": "case neg\nα : Type u_2\nβ : Type u_1\nγ : Type ?u.4605823\nδ : Type ?u.4605826\nι : Type ?u.4605829\nR : Type ?u.4605832\nR' : Type ?u.4605835\ninst✝¹ : MeasurableSpace α\nμ : MeasureTheory.Measure α\ns t✝ : Set α\nf : α → β\ninst✝ : Zero β\nhs : MeasurableSet s\nt : Set β\nht : ¬0 ∈ t\n⊢ ↑↑μ ((f ⁻¹' t)ᶜ ∪ sᶜ) = 0 → ↑↑μ ((f ⁻¹' t)ᶜ ∩ s) = 0",
"state_before": "case neg\nα : Type u_2\nβ : Type u_1\nγ : Type ?u.4605823\nδ : Type ?u.4605826\nι : Type ?u.4605829\nR : Type ?u.4605832\nR' : Type ?u.4605835\ninst✝¹ : MeasurableSpace α\nμ : MeasureTheory.Measure α\ns t✝ : Set α\nf : α → β\ninst✝ : Zero β\nhs : MeasurableSet s\nt : Set β\nht : ¬0 ∈ t\n⊢ t ∈ Filter.map (indicator s f) (ae μ) → t ∈ Filter.map f (ae (Measure.restrict μ s))",
"tactic": "rw [mem_map_indicator_ae_iff_of_zero_nmem ht, mem_map_restrict_ae_iff hs]"
},
{
"state_after": "no goals",
"state_before": "case neg\nα : Type u_2\nβ : Type u_1\nγ : Type ?u.4605823\nδ : Type ?u.4605826\nι : Type ?u.4605829\nR : Type ?u.4605832\nR' : Type ?u.4605835\ninst✝¹ : MeasurableSpace α\nμ : MeasureTheory.Measure α\ns t✝ : Set α\nf : α → β\ninst✝ : Zero β\nhs : MeasurableSet s\nt : Set β\nht : ¬0 ∈ t\n⊢ ↑↑μ ((f ⁻¹' t)ᶜ ∪ sᶜ) = 0 → ↑↑μ ((f ⁻¹' t)ᶜ ∩ s) = 0",
"tactic": "exact fun h => measure_mono_null ((Set.inter_subset_left _ _).trans (Set.subset_union_left _ _)) h"
},
{
"state_after": "case pos\nα : Type u_2\nβ : Type u_1\nγ : Type ?u.4605823\nδ : Type ?u.4605826\nι : Type ?u.4605829\nR : Type ?u.4605832\nR' : Type ?u.4605835\ninst✝¹ : MeasurableSpace α\nμ : MeasureTheory.Measure α\ns t✝ : Set α\nf : α → β\ninst✝ : Zero β\nhs : MeasurableSet s\nt : Set β\nht : 0 ∈ t\n⊢ t ∈ Filter.map f (ae (Measure.restrict μ s)) → t ∈ Filter.map f (ae (Measure.restrict μ s))",
"state_before": "case pos\nα : Type u_2\nβ : Type u_1\nγ : Type ?u.4605823\nδ : Type ?u.4605826\nι : Type ?u.4605829\nR : Type ?u.4605832\nR' : Type ?u.4605835\ninst✝¹ : MeasurableSpace α\nμ : MeasureTheory.Measure α\ns t✝ : Set α\nf : α → β\ninst✝ : Zero β\nhs : MeasurableSet s\nt : Set β\nht : 0 ∈ t\n⊢ t ∈ Filter.map (indicator s f) (ae μ) → t ∈ Filter.map f (ae (Measure.restrict μ s))",
"tactic": "rw [mem_map_indicator_ae_iff_mem_map_restrict_ae_of_zero_mem ht hs]"
},
{
"state_after": "no goals",
"state_before": "case pos\nα : Type u_2\nβ : Type u_1\nγ : Type ?u.4605823\nδ : Type ?u.4605826\nι : Type ?u.4605829\nR : Type ?u.4605832\nR' : Type ?u.4605835\ninst✝¹ : MeasurableSpace α\nμ : MeasureTheory.Measure α\ns t✝ : Set α\nf : α → β\ninst✝ : Zero β\nhs : MeasurableSet s\nt : Set β\nht : 0 ∈ t\n⊢ t ∈ Filter.map f (ae (Measure.restrict μ s)) → t ∈ Filter.map f (ae (Measure.restrict μ s))",
"tactic": "exact id"
}
] |
[
4658,
101
] |
5a919533f110b7d76410134a237ee374f24eaaad
|
https://github.com/leanprover-community/mathlib4
|
[
4651,
1
] |
Mathlib/MeasureTheory/Integral/Layercake.lean
|
MeasureTheory.lintegral_rpow_eq_lintegral_meas_le_mul
|
[
{
"state_after": "α : Type u_1\ninst✝¹ : MeasurableSpace α\nf : α → ℝ\ng : ℝ → ℝ\ns : Set α\nμ : Measure α\ninst✝ : SigmaFinite μ\nf_nn : 0 ≤ f\nf_mble : Measurable f\np : ℝ\np_pos : 0 < p\none_lt_p : -1 < p - 1\n⊢ (∫⁻ (ω : α), ENNReal.ofReal (f ω ^ p) ∂μ) =\n ENNReal.ofReal p * ∫⁻ (t : ℝ) in Ioi 0, ↑↑μ {a | t ≤ f a} * ENNReal.ofReal (t ^ (p - 1))",
"state_before": "α : Type u_1\ninst✝¹ : MeasurableSpace α\nf : α → ℝ\ng : ℝ → ℝ\ns : Set α\nμ : Measure α\ninst✝ : SigmaFinite μ\nf_nn : 0 ≤ f\nf_mble : Measurable f\np : ℝ\np_pos : 0 < p\n⊢ (∫⁻ (ω : α), ENNReal.ofReal (f ω ^ p) ∂μ) =\n ENNReal.ofReal p * ∫⁻ (t : ℝ) in Ioi 0, ↑↑μ {a | t ≤ f a} * ENNReal.ofReal (t ^ (p - 1))",
"tactic": "have one_lt_p : -1 < p - 1 := by linarith"
},
{
"state_after": "α : Type u_1\ninst✝¹ : MeasurableSpace α\nf : α → ℝ\ng : ℝ → ℝ\ns : Set α\nμ : Measure α\ninst✝ : SigmaFinite μ\nf_nn : 0 ≤ f\nf_mble : Measurable f\np : ℝ\np_pos : 0 < p\none_lt_p : -1 < p - 1\nobs : ∀ (x : ℝ), (∫ (t : ℝ) in 0 ..x, t ^ (p - 1)) = x ^ p / p\n⊢ (∫⁻ (ω : α), ENNReal.ofReal (f ω ^ p) ∂μ) =\n ENNReal.ofReal p * ∫⁻ (t : ℝ) in Ioi 0, ↑↑μ {a | t ≤ f a} * ENNReal.ofReal (t ^ (p - 1))",
"state_before": "α : Type u_1\ninst✝¹ : MeasurableSpace α\nf : α → ℝ\ng : ℝ → ℝ\ns : Set α\nμ : Measure α\ninst✝ : SigmaFinite μ\nf_nn : 0 ≤ f\nf_mble : Measurable f\np : ℝ\np_pos : 0 < p\none_lt_p : -1 < p - 1\n⊢ (∫⁻ (ω : α), ENNReal.ofReal (f ω ^ p) ∂μ) =\n ENNReal.ofReal p * ∫⁻ (t : ℝ) in Ioi 0, ↑↑μ {a | t ≤ f a} * ENNReal.ofReal (t ^ (p - 1))",
"tactic": "have obs : ∀ x : ℝ, (∫ t : ℝ in (0)..x, t ^ (p - 1)) = x ^ p / p := by\n intro x\n rw [integral_rpow (Or.inl one_lt_p)]\n simp [Real.zero_rpow p_pos.ne.symm]"
},
{
"state_after": "α : Type u_1\ninst✝¹ : MeasurableSpace α\nf : α → ℝ\ng✝ : ℝ → ℝ\ns : Set α\nμ : Measure α\ninst✝ : SigmaFinite μ\nf_nn : 0 ≤ f\nf_mble : Measurable f\np : ℝ\np_pos : 0 < p\none_lt_p : -1 < p - 1\ng : ℝ → ℝ := fun t => t ^ (p - 1)\nobs : ∀ (x : ℝ), intervalIntegral g 0 x volume = x ^ p / p\n⊢ (∫⁻ (ω : α), ENNReal.ofReal (f ω ^ p) ∂μ) =\n ENNReal.ofReal p * ∫⁻ (t : ℝ) in Ioi 0, ↑↑μ {a | t ≤ f a} * ENNReal.ofReal (t ^ (p - 1))",
"state_before": "α : Type u_1\ninst✝¹ : MeasurableSpace α\nf : α → ℝ\ng : ℝ → ℝ\ns : Set α\nμ : Measure α\ninst✝ : SigmaFinite μ\nf_nn : 0 ≤ f\nf_mble : Measurable f\np : ℝ\np_pos : 0 < p\none_lt_p : -1 < p - 1\nobs : ∀ (x : ℝ), (∫ (t : ℝ) in 0 ..x, t ^ (p - 1)) = x ^ p / p\n⊢ (∫⁻ (ω : α), ENNReal.ofReal (f ω ^ p) ∂μ) =\n ENNReal.ofReal p * ∫⁻ (t : ℝ) in Ioi 0, ↑↑μ {a | t ≤ f a} * ENNReal.ofReal (t ^ (p - 1))",
"tactic": "set g := fun t : ℝ => t ^ (p - 1)"
},
{
"state_after": "α : Type u_1\ninst✝¹ : MeasurableSpace α\nf : α → ℝ\ng✝ : ℝ → ℝ\ns : Set α\nμ : Measure α\ninst✝ : SigmaFinite μ\nf_nn : 0 ≤ f\nf_mble : Measurable f\np : ℝ\np_pos : 0 < p\none_lt_p : -1 < p - 1\ng : ℝ → ℝ := fun t => t ^ (p - 1)\nobs : ∀ (x : ℝ), intervalIntegral g 0 x volume = x ^ p / p\ng_nn : ∀ᵐ (t : ℝ) ∂Measure.restrict volume (Ioi 0), 0 ≤ g t\n⊢ (∫⁻ (ω : α), ENNReal.ofReal (f ω ^ p) ∂μ) =\n ENNReal.ofReal p * ∫⁻ (t : ℝ) in Ioi 0, ↑↑μ {a | t ≤ f a} * ENNReal.ofReal (t ^ (p - 1))",
"state_before": "α : Type u_1\ninst✝¹ : MeasurableSpace α\nf : α → ℝ\ng✝ : ℝ → ℝ\ns : Set α\nμ : Measure α\ninst✝ : SigmaFinite μ\nf_nn : 0 ≤ f\nf_mble : Measurable f\np : ℝ\np_pos : 0 < p\none_lt_p : -1 < p - 1\ng : ℝ → ℝ := fun t => t ^ (p - 1)\nobs : ∀ (x : ℝ), intervalIntegral g 0 x volume = x ^ p / p\n⊢ (∫⁻ (ω : α), ENNReal.ofReal (f ω ^ p) ∂μ) =\n ENNReal.ofReal p * ∫⁻ (t : ℝ) in Ioi 0, ↑↑μ {a | t ≤ f a} * ENNReal.ofReal (t ^ (p - 1))",
"tactic": "have g_nn : ∀ᵐ t ∂volume.restrict (Ioi (0 : ℝ)), 0 ≤ g t := by\n filter_upwards [self_mem_ae_restrict (measurableSet_Ioi : MeasurableSet (Ioi (0 : ℝ)))]\n intro t t_pos\n exact Real.rpow_nonneg_of_nonneg (mem_Ioi.mp t_pos).le (p - 1)"
},
{
"state_after": "α : Type u_1\ninst✝¹ : MeasurableSpace α\nf : α → ℝ\ng✝ : ℝ → ℝ\ns : Set α\nμ : Measure α\ninst✝ : SigmaFinite μ\nf_nn : 0 ≤ f\nf_mble : Measurable f\np : ℝ\np_pos : 0 < p\none_lt_p : -1 < p - 1\ng : ℝ → ℝ := fun t => t ^ (p - 1)\nobs : ∀ (x : ℝ), intervalIntegral g 0 x volume = x ^ p / p\ng_nn : ∀ᵐ (t : ℝ) ∂Measure.restrict volume (Ioi 0), 0 ≤ g t\ng_intble : ∀ (t : ℝ), t > 0 → IntervalIntegrable g volume 0 t\n⊢ (∫⁻ (ω : α), ENNReal.ofReal (f ω ^ p) ∂μ) =\n ENNReal.ofReal p * ∫⁻ (t : ℝ) in Ioi 0, ↑↑μ {a | t ≤ f a} * ENNReal.ofReal (t ^ (p - 1))",
"state_before": "α : Type u_1\ninst✝¹ : MeasurableSpace α\nf : α → ℝ\ng✝ : ℝ → ℝ\ns : Set α\nμ : Measure α\ninst✝ : SigmaFinite μ\nf_nn : 0 ≤ f\nf_mble : Measurable f\np : ℝ\np_pos : 0 < p\none_lt_p : -1 < p - 1\ng : ℝ → ℝ := fun t => t ^ (p - 1)\nobs : ∀ (x : ℝ), intervalIntegral g 0 x volume = x ^ p / p\ng_nn : ∀ᵐ (t : ℝ) ∂Measure.restrict volume (Ioi 0), 0 ≤ g t\n⊢ (∫⁻ (ω : α), ENNReal.ofReal (f ω ^ p) ∂μ) =\n ENNReal.ofReal p * ∫⁻ (t : ℝ) in Ioi 0, ↑↑μ {a | t ≤ f a} * ENNReal.ofReal (t ^ (p - 1))",
"tactic": "have g_intble : ∀ t > 0, IntervalIntegrable g volume 0 t := fun _ _ =>\n intervalIntegral.intervalIntegrable_rpow' one_lt_p"
},
{
"state_after": "α : Type u_1\ninst✝¹ : MeasurableSpace α\nf : α → ℝ\ng✝ : ℝ → ℝ\ns : Set α\nμ : Measure α\ninst✝ : SigmaFinite μ\nf_nn : 0 ≤ f\nf_mble : Measurable f\np : ℝ\np_pos : 0 < p\none_lt_p : -1 < p - 1\ng : ℝ → ℝ := fun t => t ^ (p - 1)\nobs : ∀ (x : ℝ), intervalIntegral g 0 x volume = x ^ p / p\ng_nn : ∀ᵐ (t : ℝ) ∂Measure.restrict volume (Ioi 0), 0 ≤ g t\ng_intble : ∀ (t : ℝ), t > 0 → IntervalIntegrable g volume 0 t\nkey :\n (∫⁻ (ω : α), ENNReal.ofReal (∫ (t : ℝ) in 0 ..f ω, g t) ∂μ) =\n ∫⁻ (t : ℝ) in Ioi 0, ↑↑μ {a | t ≤ f a} * ENNReal.ofReal (g t)\n⊢ (∫⁻ (ω : α), ENNReal.ofReal (f ω ^ p) ∂μ) =\n ENNReal.ofReal p * ∫⁻ (t : ℝ) in Ioi 0, ↑↑μ {a | t ≤ f a} * ENNReal.ofReal (t ^ (p - 1))",
"state_before": "α : Type u_1\ninst✝¹ : MeasurableSpace α\nf : α → ℝ\ng✝ : ℝ → ℝ\ns : Set α\nμ : Measure α\ninst✝ : SigmaFinite μ\nf_nn : 0 ≤ f\nf_mble : Measurable f\np : ℝ\np_pos : 0 < p\none_lt_p : -1 < p - 1\ng : ℝ → ℝ := fun t => t ^ (p - 1)\nobs : ∀ (x : ℝ), intervalIntegral g 0 x volume = x ^ p / p\ng_nn : ∀ᵐ (t : ℝ) ∂Measure.restrict volume (Ioi 0), 0 ≤ g t\ng_intble : ∀ (t : ℝ), t > 0 → IntervalIntegrable g volume 0 t\n⊢ (∫⁻ (ω : α), ENNReal.ofReal (f ω ^ p) ∂μ) =\n ENNReal.ofReal p * ∫⁻ (t : ℝ) in Ioi 0, ↑↑μ {a | t ≤ f a} * ENNReal.ofReal (t ^ (p - 1))",
"tactic": "have key := lintegral_comp_eq_lintegral_meas_le_mul μ f_nn f_mble g_intble g_nn"
},
{
"state_after": "α : Type u_1\ninst✝¹ : MeasurableSpace α\nf : α → ℝ\ng✝ : ℝ → ℝ\ns : Set α\nμ : Measure α\ninst✝ : SigmaFinite μ\nf_nn : 0 ≤ f\nf_mble : Measurable f\np : ℝ\np_pos : 0 < p\none_lt_p : -1 < p - 1\ng : ℝ → ℝ := fun t => t ^ (p - 1)\nobs : ∀ (x : ℝ), intervalIntegral g 0 x volume = x ^ p / p\ng_nn : ∀ᵐ (t : ℝ) ∂Measure.restrict volume (Ioi 0), 0 ≤ g t\ng_intble : ∀ (t : ℝ), t > 0 → IntervalIntegrable g volume 0 t\nkey :\n (∫⁻ (ω : α), ENNReal.ofReal (∫ (t : ℝ) in 0 ..f ω, g t) ∂μ) =\n ∫⁻ (t : ℝ) in Ioi 0, ↑↑μ {a | t ≤ f a} * ENNReal.ofReal (g t)\n⊢ (∫⁻ (ω : α), ENNReal.ofReal (f ω ^ p) ∂μ) = ∫⁻ (a : α), ENNReal.ofReal p * ENNReal.ofReal (f a ^ p / p) ∂μ\n\nα : Type u_1\ninst✝¹ : MeasurableSpace α\nf : α → ℝ\ng✝ : ℝ → ℝ\ns : Set α\nμ : Measure α\ninst✝ : SigmaFinite μ\nf_nn : 0 ≤ f\nf_mble : Measurable f\np : ℝ\np_pos : 0 < p\none_lt_p : -1 < p - 1\ng : ℝ → ℝ := fun t => t ^ (p - 1)\nobs : ∀ (x : ℝ), intervalIntegral g 0 x volume = x ^ p / p\ng_nn : ∀ᵐ (t : ℝ) ∂Measure.restrict volume (Ioi 0), 0 ≤ g t\ng_intble : ∀ (t : ℝ), t > 0 → IntervalIntegrable g volume 0 t\nkey :\n (∫⁻ (ω : α), ENNReal.ofReal (∫ (t : ℝ) in 0 ..f ω, g t) ∂μ) =\n ∫⁻ (t : ℝ) in Ioi 0, ↑↑μ {a | t ≤ f a} * ENNReal.ofReal (g t)\n⊢ Measurable fun ω => ENNReal.ofReal (f ω ^ p / p)",
"state_before": "α : Type u_1\ninst✝¹ : MeasurableSpace α\nf : α → ℝ\ng✝ : ℝ → ℝ\ns : Set α\nμ : Measure α\ninst✝ : SigmaFinite μ\nf_nn : 0 ≤ f\nf_mble : Measurable f\np : ℝ\np_pos : 0 < p\none_lt_p : -1 < p - 1\ng : ℝ → ℝ := fun t => t ^ (p - 1)\nobs : ∀ (x : ℝ), intervalIntegral g 0 x volume = x ^ p / p\ng_nn : ∀ᵐ (t : ℝ) ∂Measure.restrict volume (Ioi 0), 0 ≤ g t\ng_intble : ∀ (t : ℝ), t > 0 → IntervalIntegrable g volume 0 t\nkey :\n (∫⁻ (ω : α), ENNReal.ofReal (∫ (t : ℝ) in 0 ..f ω, g t) ∂μ) =\n ∫⁻ (t : ℝ) in Ioi 0, ↑↑μ {a | t ≤ f a} * ENNReal.ofReal (g t)\n⊢ (∫⁻ (ω : α), ENNReal.ofReal (f ω ^ p) ∂μ) =\n ENNReal.ofReal p * ∫⁻ (t : ℝ) in Ioi 0, ↑↑μ {a | t ≤ f a} * ENNReal.ofReal (t ^ (p - 1))",
"tactic": "rw [← key, ← lintegral_const_mul (ENNReal.ofReal p)] <;> simp_rw [obs]"
},
{
"state_after": "no goals",
"state_before": "α : Type u_1\ninst✝¹ : MeasurableSpace α\nf : α → ℝ\ng : ℝ → ℝ\ns : Set α\nμ : Measure α\ninst✝ : SigmaFinite μ\nf_nn : 0 ≤ f\nf_mble : Measurable f\np : ℝ\np_pos : 0 < p\n⊢ -1 < p - 1",
"tactic": "linarith"
},
{
"state_after": "α : Type u_1\ninst✝¹ : MeasurableSpace α\nf : α → ℝ\ng : ℝ → ℝ\ns : Set α\nμ : Measure α\ninst✝ : SigmaFinite μ\nf_nn : 0 ≤ f\nf_mble : Measurable f\np : ℝ\np_pos : 0 < p\none_lt_p : -1 < p - 1\nx : ℝ\n⊢ (∫ (t : ℝ) in 0 ..x, t ^ (p - 1)) = x ^ p / p",
"state_before": "α : Type u_1\ninst✝¹ : MeasurableSpace α\nf : α → ℝ\ng : ℝ → ℝ\ns : Set α\nμ : Measure α\ninst✝ : SigmaFinite μ\nf_nn : 0 ≤ f\nf_mble : Measurable f\np : ℝ\np_pos : 0 < p\none_lt_p : -1 < p - 1\n⊢ ∀ (x : ℝ), (∫ (t : ℝ) in 0 ..x, t ^ (p - 1)) = x ^ p / p",
"tactic": "intro x"
},
{
"state_after": "α : Type u_1\ninst✝¹ : MeasurableSpace α\nf : α → ℝ\ng : ℝ → ℝ\ns : Set α\nμ : Measure α\ninst✝ : SigmaFinite μ\nf_nn : 0 ≤ f\nf_mble : Measurable f\np : ℝ\np_pos : 0 < p\none_lt_p : -1 < p - 1\nx : ℝ\n⊢ (x ^ (p - 1 + 1) - 0 ^ (p - 1 + 1)) / (p - 1 + 1) = x ^ p / p",
"state_before": "α : Type u_1\ninst✝¹ : MeasurableSpace α\nf : α → ℝ\ng : ℝ → ℝ\ns : Set α\nμ : Measure α\ninst✝ : SigmaFinite μ\nf_nn : 0 ≤ f\nf_mble : Measurable f\np : ℝ\np_pos : 0 < p\none_lt_p : -1 < p - 1\nx : ℝ\n⊢ (∫ (t : ℝ) in 0 ..x, t ^ (p - 1)) = x ^ p / p",
"tactic": "rw [integral_rpow (Or.inl one_lt_p)]"
},
{
"state_after": "no goals",
"state_before": "α : Type u_1\ninst✝¹ : MeasurableSpace α\nf : α → ℝ\ng : ℝ → ℝ\ns : Set α\nμ : Measure α\ninst✝ : SigmaFinite μ\nf_nn : 0 ≤ f\nf_mble : Measurable f\np : ℝ\np_pos : 0 < p\none_lt_p : -1 < p - 1\nx : ℝ\n⊢ (x ^ (p - 1 + 1) - 0 ^ (p - 1 + 1)) / (p - 1 + 1) = x ^ p / p",
"tactic": "simp [Real.zero_rpow p_pos.ne.symm]"
},
{
"state_after": "case h\nα : Type u_1\ninst✝¹ : MeasurableSpace α\nf : α → ℝ\ng✝ : ℝ → ℝ\ns : Set α\nμ : Measure α\ninst✝ : SigmaFinite μ\nf_nn : 0 ≤ f\nf_mble : Measurable f\np : ℝ\np_pos : 0 < p\none_lt_p : -1 < p - 1\ng : ℝ → ℝ := fun t => t ^ (p - 1)\nobs : ∀ (x : ℝ), intervalIntegral g 0 x volume = x ^ p / p\n⊢ ∀ (a : ℝ), a ∈ Ioi 0 → 0 ≤ a ^ (p - 1)",
"state_before": "α : Type u_1\ninst✝¹ : MeasurableSpace α\nf : α → ℝ\ng✝ : ℝ → ℝ\ns : Set α\nμ : Measure α\ninst✝ : SigmaFinite μ\nf_nn : 0 ≤ f\nf_mble : Measurable f\np : ℝ\np_pos : 0 < p\none_lt_p : -1 < p - 1\ng : ℝ → ℝ := fun t => t ^ (p - 1)\nobs : ∀ (x : ℝ), intervalIntegral g 0 x volume = x ^ p / p\n⊢ ∀ᵐ (t : ℝ) ∂Measure.restrict volume (Ioi 0), 0 ≤ g t",
"tactic": "filter_upwards [self_mem_ae_restrict (measurableSet_Ioi : MeasurableSet (Ioi (0 : ℝ)))]"
},
{
"state_after": "case h\nα : Type u_1\ninst✝¹ : MeasurableSpace α\nf : α → ℝ\ng✝ : ℝ → ℝ\ns : Set α\nμ : Measure α\ninst✝ : SigmaFinite μ\nf_nn : 0 ≤ f\nf_mble : Measurable f\np : ℝ\np_pos : 0 < p\none_lt_p : -1 < p - 1\ng : ℝ → ℝ := fun t => t ^ (p - 1)\nobs : ∀ (x : ℝ), intervalIntegral g 0 x volume = x ^ p / p\nt : ℝ\nt_pos : t ∈ Ioi 0\n⊢ 0 ≤ t ^ (p - 1)",
"state_before": "case h\nα : Type u_1\ninst✝¹ : MeasurableSpace α\nf : α → ℝ\ng✝ : ℝ → ℝ\ns : Set α\nμ : Measure α\ninst✝ : SigmaFinite μ\nf_nn : 0 ≤ f\nf_mble : Measurable f\np : ℝ\np_pos : 0 < p\none_lt_p : -1 < p - 1\ng : ℝ → ℝ := fun t => t ^ (p - 1)\nobs : ∀ (x : ℝ), intervalIntegral g 0 x volume = x ^ p / p\n⊢ ∀ (a : ℝ), a ∈ Ioi 0 → 0 ≤ a ^ (p - 1)",
"tactic": "intro t t_pos"
},
{
"state_after": "no goals",
"state_before": "case h\nα : Type u_1\ninst✝¹ : MeasurableSpace α\nf : α → ℝ\ng✝ : ℝ → ℝ\ns : Set α\nμ : Measure α\ninst✝ : SigmaFinite μ\nf_nn : 0 ≤ f\nf_mble : Measurable f\np : ℝ\np_pos : 0 < p\none_lt_p : -1 < p - 1\ng : ℝ → ℝ := fun t => t ^ (p - 1)\nobs : ∀ (x : ℝ), intervalIntegral g 0 x volume = x ^ p / p\nt : ℝ\nt_pos : t ∈ Ioi 0\n⊢ 0 ≤ t ^ (p - 1)",
"tactic": "exact Real.rpow_nonneg_of_nonneg (mem_Ioi.mp t_pos).le (p - 1)"
},
{
"state_after": "case e_f.h\nα : Type u_1\ninst✝¹ : MeasurableSpace α\nf : α → ℝ\ng✝ : ℝ → ℝ\ns : Set α\nμ : Measure α\ninst✝ : SigmaFinite μ\nf_nn : 0 ≤ f\nf_mble : Measurable f\np : ℝ\np_pos : 0 < p\none_lt_p : -1 < p - 1\ng : ℝ → ℝ := fun t => t ^ (p - 1)\nobs : ∀ (x : ℝ), intervalIntegral g 0 x volume = x ^ p / p\ng_nn : ∀ᵐ (t : ℝ) ∂Measure.restrict volume (Ioi 0), 0 ≤ g t\ng_intble : ∀ (t : ℝ), t > 0 → IntervalIntegrable g volume 0 t\nkey :\n (∫⁻ (ω : α), ENNReal.ofReal (∫ (t : ℝ) in 0 ..f ω, g t) ∂μ) =\n ∫⁻ (t : ℝ) in Ioi 0, ↑↑μ {a | t ≤ f a} * ENNReal.ofReal (g t)\nω : α\n⊢ ENNReal.ofReal (f ω ^ p) = ENNReal.ofReal p * ENNReal.ofReal (f ω ^ p / p)",
"state_before": "α : Type u_1\ninst✝¹ : MeasurableSpace α\nf : α → ℝ\ng✝ : ℝ → ℝ\ns : Set α\nμ : Measure α\ninst✝ : SigmaFinite μ\nf_nn : 0 ≤ f\nf_mble : Measurable f\np : ℝ\np_pos : 0 < p\none_lt_p : -1 < p - 1\ng : ℝ → ℝ := fun t => t ^ (p - 1)\nobs : ∀ (x : ℝ), intervalIntegral g 0 x volume = x ^ p / p\ng_nn : ∀ᵐ (t : ℝ) ∂Measure.restrict volume (Ioi 0), 0 ≤ g t\ng_intble : ∀ (t : ℝ), t > 0 → IntervalIntegrable g volume 0 t\nkey :\n (∫⁻ (ω : α), ENNReal.ofReal (∫ (t : ℝ) in 0 ..f ω, g t) ∂μ) =\n ∫⁻ (t : ℝ) in Ioi 0, ↑↑μ {a | t ≤ f a} * ENNReal.ofReal (g t)\n⊢ (∫⁻ (ω : α), ENNReal.ofReal (f ω ^ p) ∂μ) = ∫⁻ (a : α), ENNReal.ofReal p * ENNReal.ofReal (f a ^ p / p) ∂μ",
"tactic": "congr with ω"
},
{
"state_after": "no goals",
"state_before": "case e_f.h\nα : Type u_1\ninst✝¹ : MeasurableSpace α\nf : α → ℝ\ng✝ : ℝ → ℝ\ns : Set α\nμ : Measure α\ninst✝ : SigmaFinite μ\nf_nn : 0 ≤ f\nf_mble : Measurable f\np : ℝ\np_pos : 0 < p\none_lt_p : -1 < p - 1\ng : ℝ → ℝ := fun t => t ^ (p - 1)\nobs : ∀ (x : ℝ), intervalIntegral g 0 x volume = x ^ p / p\ng_nn : ∀ᵐ (t : ℝ) ∂Measure.restrict volume (Ioi 0), 0 ≤ g t\ng_intble : ∀ (t : ℝ), t > 0 → IntervalIntegrable g volume 0 t\nkey :\n (∫⁻ (ω : α), ENNReal.ofReal (∫ (t : ℝ) in 0 ..f ω, g t) ∂μ) =\n ∫⁻ (t : ℝ) in Ioi 0, ↑↑μ {a | t ≤ f a} * ENNReal.ofReal (g t)\nω : α\n⊢ ENNReal.ofReal (f ω ^ p) = ENNReal.ofReal p * ENNReal.ofReal (f ω ^ p / p)",
"tactic": "rw [← ENNReal.ofReal_mul p_pos.le, mul_div_cancel' (f ω ^ p) p_pos.ne.symm]"
},
{
"state_after": "no goals",
"state_before": "α : Type u_1\ninst✝¹ : MeasurableSpace α\nf : α → ℝ\ng✝ : ℝ → ℝ\ns : Set α\nμ : Measure α\ninst✝ : SigmaFinite μ\nf_nn : 0 ≤ f\nf_mble : Measurable f\np : ℝ\np_pos : 0 < p\none_lt_p : -1 < p - 1\ng : ℝ → ℝ := fun t => t ^ (p - 1)\nobs : ∀ (x : ℝ), intervalIntegral g 0 x volume = x ^ p / p\ng_nn : ∀ᵐ (t : ℝ) ∂Measure.restrict volume (Ioi 0), 0 ≤ g t\ng_intble : ∀ (t : ℝ), t > 0 → IntervalIntegrable g volume 0 t\nkey :\n (∫⁻ (ω : α), ENNReal.ofReal (∫ (t : ℝ) in 0 ..f ω, g t) ∂μ) =\n ∫⁻ (t : ℝ) in Ioi 0, ↑↑μ {a | t ≤ f a} * ENNReal.ofReal (g t)\n⊢ Measurable fun ω => ENNReal.ofReal (f ω ^ p / p)",
"tactic": "exact ((f_mble.pow measurable_const).div_const p).ennreal_ofReal"
}
] |
[
259,
69
] |
5a919533f110b7d76410134a237ee374f24eaaad
|
https://github.com/leanprover-community/mathlib4
|
[
239,
1
] |
Mathlib/Topology/Order.lean
|
isOpen_induced
|
[] |
[
871,
14
] |
5a919533f110b7d76410134a237ee374f24eaaad
|
https://github.com/leanprover-community/mathlib4
|
[
870,
1
] |
Mathlib/Order/WellFoundedSet.lean
|
Set.isPwo_union
|
[] |
[
441,
31
] |
5a919533f110b7d76410134a237ee374f24eaaad
|
https://github.com/leanprover-community/mathlib4
|
[
440,
1
] |
Mathlib/Data/Polynomial/Basic.lean
|
Polynomial.support_monomial
|
[
{
"state_after": "R : Type u\na✝ b : R\nm n✝ : ℕ\ninst✝ : Semiring R\np q : R[X]\nn : ℕ\na : R\nH : a ≠ 0\n⊢ (match { toFinsupp := Finsupp.single n a } with\n | { toFinsupp := p } => p.support) =\n {n}",
"state_before": "R : Type u\na✝ b : R\nm n✝ : ℕ\ninst✝ : Semiring R\np q : R[X]\nn : ℕ\na : R\nH : a ≠ 0\n⊢ support (↑(monomial n) a) = {n}",
"tactic": "rw [← ofFinsupp_single, support]"
},
{
"state_after": "no goals",
"state_before": "R : Type u\na✝ b : R\nm n✝ : ℕ\ninst✝ : Semiring R\np q : R[X]\nn : ℕ\na : R\nH : a ≠ 0\n⊢ (match { toFinsupp := Finsupp.single n a } with\n | { toFinsupp := p } => p.support) =\n {n}",
"tactic": "exact Finsupp.support_single_ne_zero _ H"
}
] |
[
836,
77
] |
5a919533f110b7d76410134a237ee374f24eaaad
|
https://github.com/leanprover-community/mathlib4
|
[
835,
1
] |
Mathlib/Data/Polynomial/Reverse.lean
|
Polynomial.eval₂_reverse_mul_pow
|
[] |
[
354,
39
] |
5a919533f110b7d76410134a237ee374f24eaaad
|
https://github.com/leanprover-community/mathlib4
|
[
352,
1
] |
Mathlib/Analysis/InnerProductSpace/Orthogonal.lean
|
Submodule.isOrtho_sSup_left
|
[] |
[
356,
14
] |
5a919533f110b7d76410134a237ee374f24eaaad
|
https://github.com/leanprover-community/mathlib4
|
[
354,
1
] |
Mathlib/FieldTheory/Adjoin.lean
|
IntermediateField.adjoin_adjoin_left
|
[
{
"state_after": "F : Type u_2\ninst✝² : Field F\nE : Type u_1\ninst✝¹ : Field E\ninst✝ : Algebra F E\nS T : Set E\n⊢ ↑(restrictScalars F (adjoin { x // x ∈ adjoin F S } T)) = ↑(adjoin F (S ∪ T))",
"state_before": "F : Type u_2\ninst✝² : Field F\nE : Type u_1\ninst✝¹ : Field E\ninst✝ : Algebra F E\nS T : Set E\n⊢ restrictScalars F (adjoin { x // x ∈ adjoin F S } T) = adjoin F (S ∪ T)",
"tactic": "rw [SetLike.ext'_iff]"
},
{
"state_after": "F : Type u_2\ninst✝² : Field F\nE : Type u_1\ninst✝¹ : Field E\ninst✝ : Algebra F E\nS T : Set E\n⊢ ↑(adjoin { x // x ∈ adjoin F S } T) = ↑(adjoin F (S ∪ T))",
"state_before": "F : Type u_2\ninst✝² : Field F\nE : Type u_1\ninst✝¹ : Field E\ninst✝ : Algebra F E\nS T : Set E\n⊢ ↑(restrictScalars F (adjoin { x // x ∈ adjoin F S } T)) = ↑(adjoin F (S ∪ T))",
"tactic": "change (↑(adjoin (adjoin F S) T) : Set E) = _"
},
{
"state_after": "case a.left\nF : Type u_2\ninst✝² : Field F\nE : Type u_1\ninst✝¹ : Field E\ninst✝ : Algebra F E\nS T : Set E\n⊢ Set.range ↑(algebraMap { x // x ∈ adjoin F S } E) ⊆ ↑(adjoin F (S ∪ T))\n\ncase a.right\nF : Type u_2\ninst✝² : Field F\nE : Type u_1\ninst✝¹ : Field E\ninst✝ : Algebra F E\nS T : Set E\n⊢ T ⊆ ↑(adjoin F (S ∪ T))\n\ncase a.left\nF : Type u_2\ninst✝² : Field F\nE : Type u_1\ninst✝¹ : Field E\ninst✝ : Algebra F E\nS T : Set E\n⊢ Set.range ↑(algebraMap F E) ⊆ ↑(adjoin { x // x ∈ adjoin F S } T)\n\ncase a.right\nF : Type u_2\ninst✝² : Field F\nE : Type u_1\ninst✝¹ : Field E\ninst✝ : Algebra F E\nS T : Set E\n⊢ S ∪ T ⊆ ↑(adjoin { x // x ∈ adjoin F S } T)",
"state_before": "F : Type u_2\ninst✝² : Field F\nE : Type u_1\ninst✝¹ : Field E\ninst✝ : Algebra F E\nS T : Set E\n⊢ ↑(adjoin { x // x ∈ adjoin F S } T) = ↑(adjoin F (S ∪ T))",
"tactic": "apply Set.eq_of_subset_of_subset <;> rw [adjoin_subset_adjoin_iff] <;> constructor"
},
{
"state_after": "case a.left.intro.mk\nF : Type u_2\ninst✝² : Field F\nE : Type u_1\ninst✝¹ : Field E\ninst✝ : Algebra F E\nS T : Set E\nx : E\nhx : x ∈ adjoin F S\n⊢ ↑(algebraMap { x // x ∈ adjoin F S } E) { val := x, property := hx } ∈ ↑(adjoin F (S ∪ T))",
"state_before": "case a.left\nF : Type u_2\ninst✝² : Field F\nE : Type u_1\ninst✝¹ : Field E\ninst✝ : Algebra F E\nS T : Set E\n⊢ Set.range ↑(algebraMap { x // x ∈ adjoin F S } E) ⊆ ↑(adjoin F (S ∪ T))",
"tactic": "rintro _ ⟨⟨x, hx⟩, rfl⟩"
},
{
"state_after": "no goals",
"state_before": "case a.left.intro.mk\nF : Type u_2\ninst✝² : Field F\nE : Type u_1\ninst✝¹ : Field E\ninst✝ : Algebra F E\nS T : Set E\nx : E\nhx : x ∈ adjoin F S\n⊢ ↑(algebraMap { x // x ∈ adjoin F S } E) { val := x, property := hx } ∈ ↑(adjoin F (S ∪ T))",
"tactic": "exact adjoin.mono _ _ _ (Set.subset_union_left _ _) hx"
},
{
"state_after": "no goals",
"state_before": "case a.right\nF : Type u_2\ninst✝² : Field F\nE : Type u_1\ninst✝¹ : Field E\ninst✝ : Algebra F E\nS T : Set E\n⊢ T ⊆ ↑(adjoin F (S ∪ T))",
"tactic": "exact subset_adjoin_of_subset_right _ _ (Set.subset_union_right _ _)"
},
{
"state_after": "case a.left.intro\nF : Type u_2\ninst✝² : Field F\nE : Type u_1\ninst✝¹ : Field E\ninst✝ : Algebra F E\nS T : Set E\nf : F\n⊢ ↑(algebraMap F E) f ∈ ↑(adjoin { x // x ∈ adjoin F S } T)",
"state_before": "case a.left\nF : Type u_2\ninst✝² : Field F\nE : Type u_1\ninst✝¹ : Field E\ninst✝ : Algebra F E\nS T : Set E\n⊢ Set.range ↑(algebraMap F E) ⊆ ↑(adjoin { x // x ∈ adjoin F S } T)",
"tactic": "rintro x ⟨f, rfl⟩"
},
{
"state_after": "case a.left.intro\nF : Type u_2\ninst✝² : Field F\nE : Type u_1\ninst✝¹ : Field E\ninst✝ : Algebra F E\nS T : Set E\nf : F\n⊢ ↑(algebraMap F E) f ∈ Set.range ↑(algebraMap { x // x ∈ adjoin F S } E) ∪ T",
"state_before": "case a.left.intro\nF : Type u_2\ninst✝² : Field F\nE : Type u_1\ninst✝¹ : Field E\ninst✝ : Algebra F E\nS T : Set E\nf : F\n⊢ ↑(algebraMap F E) f ∈ ↑(adjoin { x // x ∈ adjoin F S } T)",
"tactic": "refine' Subfield.subset_closure _"
},
{
"state_after": "case a.left.intro.h\nF : Type u_2\ninst✝² : Field F\nE : Type u_1\ninst✝¹ : Field E\ninst✝ : Algebra F E\nS T : Set E\nf : F\n⊢ ↑(algebraMap F E) f ∈ Set.range ↑(algebraMap { x // x ∈ adjoin F S } E)",
"state_before": "case a.left.intro\nF : Type u_2\ninst✝² : Field F\nE : Type u_1\ninst✝¹ : Field E\ninst✝ : Algebra F E\nS T : Set E\nf : F\n⊢ ↑(algebraMap F E) f ∈ Set.range ↑(algebraMap { x // x ∈ adjoin F S } E) ∪ T",
"tactic": "left"
},
{
"state_after": "no goals",
"state_before": "case a.left.intro.h\nF : Type u_2\ninst✝² : Field F\nE : Type u_1\ninst✝¹ : Field E\ninst✝ : Algebra F E\nS T : Set E\nf : F\n⊢ ↑(algebraMap F E) f ∈ Set.range ↑(algebraMap { x // x ∈ adjoin F S } E)",
"tactic": "exact ⟨f, rfl⟩"
},
{
"state_after": "case a.right.refine'_1\nF : Type u_2\ninst✝² : Field F\nE : Type u_1\ninst✝¹ : Field E\ninst✝ : Algebra F E\nS T : Set E\nx : E\nhx : x ∈ S\n⊢ x ∈ Set.range ↑(algebraMap { x // x ∈ adjoin F S } E) ∪ T\n\ncase a.right.refine'_2\nF : Type u_2\ninst✝² : Field F\nE : Type u_1\ninst✝¹ : Field E\ninst✝ : Algebra F E\nS T : Set E\nx : E\nhx : x ∈ T\n⊢ x ∈ Set.range ↑(algebraMap { x // x ∈ adjoin F S } E) ∪ T",
"state_before": "case a.right\nF : Type u_2\ninst✝² : Field F\nE : Type u_1\ninst✝¹ : Field E\ninst✝ : Algebra F E\nS T : Set E\n⊢ S ∪ T ⊆ ↑(adjoin { x // x ∈ adjoin F S } T)",
"tactic": "refine' Set.union_subset (fun x hx => Subfield.subset_closure _)\n (fun x hx => Subfield.subset_closure _)"
},
{
"state_after": "case a.right.refine'_1.h\nF : Type u_2\ninst✝² : Field F\nE : Type u_1\ninst✝¹ : Field E\ninst✝ : Algebra F E\nS T : Set E\nx : E\nhx : x ∈ S\n⊢ x ∈ Set.range ↑(algebraMap { x // x ∈ adjoin F S } E)",
"state_before": "case a.right.refine'_1\nF : Type u_2\ninst✝² : Field F\nE : Type u_1\ninst✝¹ : Field E\ninst✝ : Algebra F E\nS T : Set E\nx : E\nhx : x ∈ S\n⊢ x ∈ Set.range ↑(algebraMap { x // x ∈ adjoin F S } E) ∪ T",
"tactic": "left"
},
{
"state_after": "case a.right.refine'_1.h\nF : Type u_2\ninst✝² : Field F\nE : Type u_1\ninst✝¹ : Field E\ninst✝ : Algebra F E\nS T : Set E\nx : E\nhx : x ∈ S\n⊢ x ∈ Set.range ↑(algebraMap F E) ∪ S",
"state_before": "case a.right.refine'_1.h\nF : Type u_2\ninst✝² : Field F\nE : Type u_1\ninst✝¹ : Field E\ninst✝ : Algebra F E\nS T : Set E\nx : E\nhx : x ∈ S\n⊢ x ∈ Set.range ↑(algebraMap { x // x ∈ adjoin F S } E)",
"tactic": "refine' ⟨⟨x, Subfield.subset_closure _⟩, rfl⟩"
},
{
"state_after": "case a.right.refine'_1.h.h\nF : Type u_2\ninst✝² : Field F\nE : Type u_1\ninst✝¹ : Field E\ninst✝ : Algebra F E\nS T : Set E\nx : E\nhx : x ∈ S\n⊢ x ∈ S",
"state_before": "case a.right.refine'_1.h\nF : Type u_2\ninst✝² : Field F\nE : Type u_1\ninst✝¹ : Field E\ninst✝ : Algebra F E\nS T : Set E\nx : E\nhx : x ∈ S\n⊢ x ∈ Set.range ↑(algebraMap F E) ∪ S",
"tactic": "right"
},
{
"state_after": "no goals",
"state_before": "case a.right.refine'_1.h.h\nF : Type u_2\ninst✝² : Field F\nE : Type u_1\ninst✝¹ : Field E\ninst✝ : Algebra F E\nS T : Set E\nx : E\nhx : x ∈ S\n⊢ x ∈ S",
"tactic": "exact hx"
},
{
"state_after": "case a.right.refine'_2.h\nF : Type u_2\ninst✝² : Field F\nE : Type u_1\ninst✝¹ : Field E\ninst✝ : Algebra F E\nS T : Set E\nx : E\nhx : x ∈ T\n⊢ x ∈ T",
"state_before": "case a.right.refine'_2\nF : Type u_2\ninst✝² : Field F\nE : Type u_1\ninst✝¹ : Field E\ninst✝ : Algebra F E\nS T : Set E\nx : E\nhx : x ∈ T\n⊢ x ∈ Set.range ↑(algebraMap { x // x ∈ adjoin F S } E) ∪ T",
"tactic": "right"
},
{
"state_after": "no goals",
"state_before": "case a.right.refine'_2.h\nF : Type u_2\ninst✝² : Field F\nE : Type u_1\ninst✝¹ : Field E\ninst✝ : Algebra F E\nS T : Set E\nx : E\nhx : x ∈ T\n⊢ x ∈ T",
"tactic": "exact hx"
}
] |
[
392,
15
] |
5a919533f110b7d76410134a237ee374f24eaaad
|
https://github.com/leanprover-community/mathlib4
|
[
372,
1
] |
Mathlib/Data/Seq/WSeq.lean
|
Stream'.WSeq.dropn_tail
|
[
{
"state_after": "α : Type u\nβ : Type v\nγ : Type w\ns : WSeq α\nn : ℕ\n⊢ drop (tail s) n = drop s (1 + n)",
"state_before": "α : Type u\nβ : Type v\nγ : Type w\ns : WSeq α\nn : ℕ\n⊢ drop (tail s) n = drop s (n + 1)",
"tactic": "rw [add_comm]"
},
{
"state_after": "α : Type u\nβ : Type v\nγ : Type w\ns : WSeq α\nn : ℕ\n⊢ drop s (1 + n) = drop (tail s) n",
"state_before": "α : Type u\nβ : Type v\nγ : Type w\ns : WSeq α\nn : ℕ\n⊢ drop (tail s) n = drop s (1 + n)",
"tactic": "symm"
},
{
"state_after": "no goals",
"state_before": "α : Type u\nβ : Type v\nγ : Type w\ns : WSeq α\nn : ℕ\n⊢ drop s (1 + n) = drop (tail s) n",
"tactic": "apply dropn_add"
}
] |
[
743,
18
] |
5a919533f110b7d76410134a237ee374f24eaaad
|
https://github.com/leanprover-community/mathlib4
|
[
740,
1
] |
src/lean/Init/Data/Nat/Basic.lean
|
Nat.add_eq
|
[] |
[
84,
52
] |
d5348dfac847a56a4595fb6230fd0708dcb4e7e9
|
https://github.com/leanprover/lean4
|
[
84,
9
] |
Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean
|
affineSpan_induction
|
[] |
[
1184,
52
] |
5a919533f110b7d76410134a237ee374f24eaaad
|
https://github.com/leanprover-community/mathlib4
|
[
1181,
1
] |
Mathlib/Data/Set/Intervals/Basic.lean
|
Set.Iic_def
|
[] |
[
104,
6
] |
5a919533f110b7d76410134a237ee374f24eaaad
|
https://github.com/leanprover-community/mathlib4
|
[
103,
1
] |
Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean
|
Real.cos_add_pi_div_two
|
[
{
"state_after": "no goals",
"state_before": "x : ℝ\n⊢ cos (x + π / 2) = -sin x",
"tactic": "simp [cos_add]"
}
] |
[
454,
83
] |
5a919533f110b7d76410134a237ee374f24eaaad
|
https://github.com/leanprover-community/mathlib4
|
[
454,
1
] |
Mathlib/RingTheory/HahnSeries.lean
|
HahnSeries.SummableFamily.hsum_sub
|
[
{
"state_after": "no goals",
"state_before": "Γ : Type u_2\nR✝ : Type ?u.2750260\ninst✝² : OrderedCancelAddCommMonoid Γ\ninst✝¹ : Semiring R✝\nα : Type u_3\nR : Type u_1\ninst✝ : Ring R\ns t : SummableFamily Γ R α\n⊢ hsum (s - t) = hsum s - hsum t",
"tactic": "rw [← lsum_apply, LinearMap.map_sub, lsum_apply, lsum_apply]"
}
] |
[
1651,
63
] |
5a919533f110b7d76410134a237ee374f24eaaad
|
https://github.com/leanprover-community/mathlib4
|
[
1649,
1
] |
Mathlib/Algebra/Lie/Semisimple.lean
|
LieAlgebra.subsingleton_of_semisimple_lie_abelian
|
[
{
"state_after": "R : Type u\nL : Type v\ninst✝³ : CommRing R\ninst✝² : LieRing L\ninst✝¹ : LieAlgebra R L\ninst✝ : IsSemisimple R L\nh : ⊥ = ⊤\n⊢ Subsingleton L",
"state_before": "R : Type u\nL : Type v\ninst✝³ : CommRing R\ninst✝² : LieRing L\ninst✝¹ : LieAlgebra R L\ninst✝ : IsSemisimple R L\nh : IsLieAbelian L\n⊢ Subsingleton L",
"tactic": "rw [isLieAbelian_iff_center_eq_top R L, center_eq_bot_of_semisimple] at h"
},
{
"state_after": "no goals",
"state_before": "R : Type u\nL : Type v\ninst✝³ : CommRing R\ninst✝² : LieRing L\ninst✝¹ : LieAlgebra R L\ninst✝ : IsSemisimple R L\nh : ⊥ = ⊤\n⊢ Subsingleton L",
"tactic": "exact (LieSubmodule.subsingleton_iff R L L).mp (subsingleton_of_bot_eq_top h)"
}
] |
[
100,
80
] |
5a919533f110b7d76410134a237ee374f24eaaad
|
https://github.com/leanprover-community/mathlib4
|
[
97,
1
] |
Mathlib/RingTheory/Polynomial/Opposites.lean
|
Polynomial.opRingEquiv_op_C
|
[] |
[
50,
30
] |
5a919533f110b7d76410134a237ee374f24eaaad
|
https://github.com/leanprover-community/mathlib4
|
[
49,
1
] |
Mathlib/Data/Set/Prod.lean
|
Set.eval_image_pi_subset
|
[] |
[
799,
41
] |
5a919533f110b7d76410134a237ee374f24eaaad
|
https://github.com/leanprover-community/mathlib4
|
[
798,
1
] |
Mathlib/Data/Polynomial/Eval.lean
|
Polynomial.eval₂_add
|
[
{
"state_after": "R : Type u\nS : Type v\nT : Type w\nι : Type y\na b : R\nm n : ℕ\ninst✝¹ : Semiring R\np q r : R[X]\ninst✝ : Semiring S\nf : R →+* S\nx : S\n⊢ (sum (p + q) fun e a => ↑f a * x ^ e) = (sum p fun e a => ↑f a * x ^ e) + sum q fun e a => ↑f a * x ^ e",
"state_before": "R : Type u\nS : Type v\nT : Type w\nι : Type y\na b : R\nm n : ℕ\ninst✝¹ : Semiring R\np q r : R[X]\ninst✝ : Semiring S\nf : R →+* S\nx : S\n⊢ eval₂ f x (p + q) = eval₂ f x p + eval₂ f x q",
"tactic": "simp only [eval₂_eq_sum]"
},
{
"state_after": "no goals",
"state_before": "R : Type u\nS : Type v\nT : Type w\nι : Type y\na b : R\nm n : ℕ\ninst✝¹ : Semiring R\np q r : R[X]\ninst✝ : Semiring S\nf : R →+* S\nx : S\n⊢ (sum (p + q) fun e a => ↑f a * x ^ e) = (sum p fun e a => ↑f a * x ^ e) + sum q fun e a => ↑f a * x ^ e",
"tactic": "apply sum_add_index <;> simp [add_mul]"
}
] |
[
95,
41
] |
5a919533f110b7d76410134a237ee374f24eaaad
|
https://github.com/leanprover-community/mathlib4
|
[
93,
1
] |
Mathlib/Data/Nat/Factorial/Basic.lean
|
Nat.pow_sub_lt_descFactorial'
|
[
{
"state_after": "n : ℕ\nh : 0 + 2 ≤ n\n⊢ (n - (0 + 1)) * (n - (0 + 1)) < (n - 1) * n",
"state_before": "n : ℕ\nh : 0 + 2 ≤ n\n⊢ (n - (0 + 1)) ^ (0 + 2) < descFactorial n (0 + 2)",
"tactic": "rw [descFactorial_succ, pow_succ, pow_one, descFactorial_one]"
},
{
"state_after": "no goals",
"state_before": "n : ℕ\nh : 0 + 2 ≤ n\n⊢ (n - (0 + 1)) * (n - (0 + 1)) < (n - 1) * n",
"tactic": "exact\n Nat.mul_lt_mul_of_pos_left (tsub_lt_self (lt_of_lt_of_le zero_lt_two h) zero_lt_one)\n (tsub_pos_of_lt h)"
},
{
"state_after": "n k : ℕ\nh : k + 1 + 2 ≤ n\n⊢ (n - (k + 1 + 1)) * (n - (k + 1 + 1)) ^ (k + 2) < (n - (k + 2)) * descFactorial n (k + 2)",
"state_before": "n k : ℕ\nh : k + 1 + 2 ≤ n\n⊢ (n - (k + 1 + 1)) ^ (k + 1 + 2) < descFactorial n (k + 1 + 2)",
"tactic": "rw [descFactorial_succ, pow_succ, mul_comm]"
},
{
"state_after": "case h\nn k : ℕ\nh : k + 1 + 2 ≤ n\n⊢ (n - (k + 1 + 1)) ^ (k + 2) < descFactorial n (k + 2)\n\ncase hk\nn k : ℕ\nh : k + 1 + 2 ≤ n\n⊢ n - (k + 1 + 1) > 0",
"state_before": "n k : ℕ\nh : k + 1 + 2 ≤ n\n⊢ (n - (k + 1 + 1)) * (n - (k + 1 + 1)) ^ (k + 2) < (n - (k + 2)) * descFactorial n (k + 2)",
"tactic": "apply Nat.mul_lt_mul_of_pos_left"
},
{
"state_after": "case h\nn k : ℕ\nh : k + 1 + 2 ≤ n\n⊢ (succ n - (k + 1 + 1)) ^ (k + 2) < descFactorial n (k + 2)",
"state_before": "case h\nn k : ℕ\nh : k + 1 + 2 ≤ n\n⊢ (n - (k + 1 + 1)) ^ (k + 2) < descFactorial n (k + 2)",
"tactic": "refine' ((Nat.pow_le_pow_of_le_left (tsub_le_tsub_right (le_succ n) _) _).trans_lt _)"
},
{
"state_after": "case h\nn k : ℕ\nh : k + 1 + 2 ≤ n\n⊢ (n - (k + 1)) ^ (k + 2) < descFactorial n (k + 2)",
"state_before": "case h\nn k : ℕ\nh : k + 1 + 2 ≤ n\n⊢ (succ n - (k + 1 + 1)) ^ (k + 2) < descFactorial n (k + 2)",
"tactic": "rw [succ_sub_succ]"
},
{
"state_after": "no goals",
"state_before": "case h\nn k : ℕ\nh : k + 1 + 2 ≤ n\n⊢ (n - (k + 1)) ^ (k + 2) < descFactorial n (k + 2)",
"tactic": "exact pow_sub_lt_descFactorial' ((le_succ _).trans h)"
},
{
"state_after": "case hk.h\nn k : ℕ\nh : k + 1 + 2 ≤ n\n⊢ k + 1 + 1 < n",
"state_before": "case hk\nn k : ℕ\nh : k + 1 + 2 ≤ n\n⊢ n - (k + 1 + 1) > 0",
"tactic": "apply tsub_pos_of_lt"
},
{
"state_after": "no goals",
"state_before": "case hk.h\nn k : ℕ\nh : k + 1 + 2 ≤ n\n⊢ k + 1 + 1 < n",
"tactic": "apply h"
}
] |
[
457,
36
] |
5a919533f110b7d76410134a237ee374f24eaaad
|
https://github.com/leanprover-community/mathlib4
|
[
444,
1
] |
Mathlib/Topology/MetricSpace/PartitionOfUnity.lean
|
EMetric.eventually_nhds_zero_forall_closedBall_subset
|
[
{
"state_after": "ι : Type u_2\nX : Type u_1\ninst✝ : EMetricSpace X\nK U : ι → Set X\nhK : ∀ (i : ι), IsClosed (K i)\nhU : ∀ (i : ι), IsOpen (U i)\nhKU : ∀ (i : ι), K i ⊆ U i\nhfin : LocallyFinite K\nx : X\n⊢ ∀ (i : ι), x ∈ K i → ∀ᶠ (p : ℝ≥0∞ × X) in 𝓝 0 ×ˢ 𝓝 x, closedBall p.snd p.fst ⊆ U i",
"state_before": "ι : Type u_2\nX : Type u_1\ninst✝ : EMetricSpace X\nK U : ι → Set X\nhK : ∀ (i : ι), IsClosed (K i)\nhU : ∀ (i : ι), IsOpen (U i)\nhKU : ∀ (i : ι), K i ⊆ U i\nhfin : LocallyFinite K\nx : X\n⊢ ∀ᶠ (p : ℝ≥0∞ × X) in 𝓝 0 ×ˢ 𝓝 x, ∀ (i : ι), p.snd ∈ K i → closedBall p.snd p.fst ⊆ U i",
"tactic": "suffices ∀ i, x ∈ K i → ∀ᶠ p : ℝ≥0∞ × X in 𝓝 0 ×ˢ 𝓝 x, closedBall p.2 p.1 ⊆ U i by\n apply mp_mem ((eventually_all_finite (hfin.point_finite x)).2 this)\n (mp_mem (@tendsto_snd ℝ≥0∞ _ (𝓝 0) _ _ (hfin.iInter_compl_mem_nhds hK x)) _)\n apply univ_mem'\n rintro ⟨r, y⟩ hxy hyU i hi\n simp only [mem_iInter, mem_compl_iff, not_imp_not, mem_preimage] at hxy\n exact hyU _ (hxy _ hi)"
},
{
"state_after": "ι : Type u_2\nX : Type u_1\ninst✝ : EMetricSpace X\nK U : ι → Set X\nhK : ∀ (i : ι), IsClosed (K i)\nhU : ∀ (i : ι), IsOpen (U i)\nhKU : ∀ (i : ι), K i ⊆ U i\nhfin : LocallyFinite K\nx : X\ni : ι\nhi : x ∈ K i\n⊢ ∀ᶠ (p : ℝ≥0∞ × X) in 𝓝 0 ×ˢ 𝓝 x, closedBall p.snd p.fst ⊆ U i",
"state_before": "ι : Type u_2\nX : Type u_1\ninst✝ : EMetricSpace X\nK U : ι → Set X\nhK : ∀ (i : ι), IsClosed (K i)\nhU : ∀ (i : ι), IsOpen (U i)\nhKU : ∀ (i : ι), K i ⊆ U i\nhfin : LocallyFinite K\nx : X\n⊢ ∀ (i : ι), x ∈ K i → ∀ᶠ (p : ℝ≥0∞ × X) in 𝓝 0 ×ˢ 𝓝 x, closedBall p.snd p.fst ⊆ U i",
"tactic": "intro i hi"
},
{
"state_after": "case intro.intro\nι : Type u_2\nX : Type u_1\ninst✝ : EMetricSpace X\nK U : ι → Set X\nhK : ∀ (i : ι), IsClosed (K i)\nhU : ∀ (i : ι), IsOpen (U i)\nhKU : ∀ (i : ι), K i ⊆ U i\nhfin : LocallyFinite K\nx : X\ni : ι\nhi : x ∈ K i\nR : ℝ≥0∞\nhR₀ : 0 < R\nhR : closedBall x R ⊆ U i\n⊢ ∀ᶠ (p : ℝ≥0∞ × X) in 𝓝 0 ×ˢ 𝓝 x, closedBall p.snd p.fst ⊆ U i",
"state_before": "ι : Type u_2\nX : Type u_1\ninst✝ : EMetricSpace X\nK U : ι → Set X\nhK : ∀ (i : ι), IsClosed (K i)\nhU : ∀ (i : ι), IsOpen (U i)\nhKU : ∀ (i : ι), K i ⊆ U i\nhfin : LocallyFinite K\nx : X\ni : ι\nhi : x ∈ K i\n⊢ ∀ᶠ (p : ℝ≥0∞ × X) in 𝓝 0 ×ˢ 𝓝 x, closedBall p.snd p.fst ⊆ U i",
"tactic": "rcases nhds_basis_closed_eball.mem_iff.1 ((hU i).mem_nhds <| hKU i hi) with ⟨R, hR₀, hR⟩"
},
{
"state_after": "case intro.intro.intro.intro\nι : Type u_2\nX : Type u_1\ninst✝ : EMetricSpace X\nK U : ι → Set X\nhK : ∀ (i : ι), IsClosed (K i)\nhU : ∀ (i : ι), IsOpen (U i)\nhKU : ∀ (i : ι), K i ⊆ U i\nhfin : LocallyFinite K\nx : X\ni : ι\nhi : x ∈ K i\nR : ℝ≥0∞\nhR₀ : 0 < R\nhR : closedBall x R ⊆ U i\nr : ℝ≥0\nhr₀ : 0 < ↑r\nhrR : ↑r < R\n⊢ ∀ᶠ (p : ℝ≥0∞ × X) in 𝓝 0 ×ˢ 𝓝 x, closedBall p.snd p.fst ⊆ U i",
"state_before": "case intro.intro\nι : Type u_2\nX : Type u_1\ninst✝ : EMetricSpace X\nK U : ι → Set X\nhK : ∀ (i : ι), IsClosed (K i)\nhU : ∀ (i : ι), IsOpen (U i)\nhKU : ∀ (i : ι), K i ⊆ U i\nhfin : LocallyFinite K\nx : X\ni : ι\nhi : x ∈ K i\nR : ℝ≥0∞\nhR₀ : 0 < R\nhR : closedBall x R ⊆ U i\n⊢ ∀ᶠ (p : ℝ≥0∞ × X) in 𝓝 0 ×ˢ 𝓝 x, closedBall p.snd p.fst ⊆ U i",
"tactic": "rcases ENNReal.lt_iff_exists_nnreal_btwn.mp hR₀ with ⟨r, hr₀, hrR⟩"
},
{
"state_after": "case h\nι : Type u_2\nX : Type u_1\ninst✝ : EMetricSpace X\nK U : ι → Set X\nhK : ∀ (i : ι), IsClosed (K i)\nhU : ∀ (i : ι), IsOpen (U i)\nhKU : ∀ (i : ι), K i ⊆ U i\nhfin : LocallyFinite K\nx : X\ni : ι\nhi : x ∈ K i\nR : ℝ≥0∞\nhR₀ : 0 < R\nhR : closedBall x R ⊆ U i\nr : ℝ≥0\nhr₀ : 0 < ↑r\nhrR : ↑r < R\np : ℝ≥0∞ × X\nhp : p ∈ {x | x < ↑r} ×ˢ closedBall x (R - ↑r)\nz : X\nhz : z ∈ closedBall p.snd p.fst\n⊢ z ∈ U i",
"state_before": "case intro.intro.intro.intro\nι : Type u_2\nX : Type u_1\ninst✝ : EMetricSpace X\nK U : ι → Set X\nhK : ∀ (i : ι), IsClosed (K i)\nhU : ∀ (i : ι), IsOpen (U i)\nhKU : ∀ (i : ι), K i ⊆ U i\nhfin : LocallyFinite K\nx : X\ni : ι\nhi : x ∈ K i\nR : ℝ≥0∞\nhR₀ : 0 < R\nhR : closedBall x R ⊆ U i\nr : ℝ≥0\nhr₀ : 0 < ↑r\nhrR : ↑r < R\n⊢ ∀ᶠ (p : ℝ≥0∞ × X) in 𝓝 0 ×ˢ 𝓝 x, closedBall p.snd p.fst ⊆ U i",
"tactic": "filter_upwards [prod_mem_prod (eventually_lt_nhds hr₀)\n (closedBall_mem_nhds x (tsub_pos_iff_lt.2 hrR))] with p hp z hz"
},
{
"state_after": "case h.a\nι : Type u_2\nX : Type u_1\ninst✝ : EMetricSpace X\nK U : ι → Set X\nhK : ∀ (i : ι), IsClosed (K i)\nhU : ∀ (i : ι), IsOpen (U i)\nhKU : ∀ (i : ι), K i ⊆ U i\nhfin : LocallyFinite K\nx : X\ni : ι\nhi : x ∈ K i\nR : ℝ≥0∞\nhR₀ : 0 < R\nhR : closedBall x R ⊆ U i\nr : ℝ≥0\nhr₀ : 0 < ↑r\nhrR : ↑r < R\np : ℝ≥0∞ × X\nhp : p ∈ {x | x < ↑r} ×ˢ closedBall x (R - ↑r)\nz : X\nhz : z ∈ closedBall p.snd p.fst\n⊢ z ∈ closedBall x R",
"state_before": "case h\nι : Type u_2\nX : Type u_1\ninst✝ : EMetricSpace X\nK U : ι → Set X\nhK : ∀ (i : ι), IsClosed (K i)\nhU : ∀ (i : ι), IsOpen (U i)\nhKU : ∀ (i : ι), K i ⊆ U i\nhfin : LocallyFinite K\nx : X\ni : ι\nhi : x ∈ K i\nR : ℝ≥0∞\nhR₀ : 0 < R\nhR : closedBall x R ⊆ U i\nr : ℝ≥0\nhr₀ : 0 < ↑r\nhrR : ↑r < R\np : ℝ≥0∞ × X\nhp : p ∈ {x | x < ↑r} ×ˢ closedBall x (R - ↑r)\nz : X\nhz : z ∈ closedBall p.snd p.fst\n⊢ z ∈ U i",
"tactic": "apply hR"
},
{
"state_after": "no goals",
"state_before": "case h.a\nι : Type u_2\nX : Type u_1\ninst✝ : EMetricSpace X\nK U : ι → Set X\nhK : ∀ (i : ι), IsClosed (K i)\nhU : ∀ (i : ι), IsOpen (U i)\nhKU : ∀ (i : ι), K i ⊆ U i\nhfin : LocallyFinite K\nx : X\ni : ι\nhi : x ∈ K i\nR : ℝ≥0∞\nhR₀ : 0 < R\nhR : closedBall x R ⊆ U i\nr : ℝ≥0\nhr₀ : 0 < ↑r\nhrR : ↑r < R\np : ℝ≥0∞ × X\nhp : p ∈ {x | x < ↑r} ×ˢ closedBall x (R - ↑r)\nz : X\nhz : z ∈ closedBall p.snd p.fst\n⊢ z ∈ closedBall x R",
"tactic": "calc\n edist z x ≤ edist z p.2 + edist p.2 x := edist_triangle _ _ _\n _ ≤ p.1 + (R - p.1) := (add_le_add hz <| le_trans hp.2 <| tsub_le_tsub_left hp.1.out.le _)\n _ = R := add_tsub_cancel_of_le (lt_trans (by exact hp.1) hrR).le"
},
{
"state_after": "ι : Type u_2\nX : Type u_1\ninst✝ : EMetricSpace X\nK U : ι → Set X\nhK : ∀ (i : ι), IsClosed (K i)\nhU : ∀ (i : ι), IsOpen (U i)\nhKU : ∀ (i : ι), K i ⊆ U i\nhfin : LocallyFinite K\nx : X\nthis : ∀ (i : ι), x ∈ K i → ∀ᶠ (p : ℝ≥0∞ × X) in 𝓝 0 ×ˢ 𝓝 x, closedBall p.snd p.fst ⊆ U i\n⊢ {x_1 |\n (x_1 ∈ Prod.snd ⁻¹' ⋂ (i : ι) (_ : ¬x ∈ K i), K iᶜ) →\n x_1 ∈\n {x_2 |\n x_2 ∈ {x_3 | (fun x_4 => ∀ (i : ι), i ∈ {b | x ∈ K b} → closedBall x_4.snd x_4.fst ⊆ U i) x_3} →\n x_2 ∈ {x | (fun p => ∀ (i : ι), p.snd ∈ K i → closedBall p.snd p.fst ⊆ U i) x}}} ∈\n 𝓝 0 ×ˢ 𝓝 x",
"state_before": "ι : Type u_2\nX : Type u_1\ninst✝ : EMetricSpace X\nK U : ι → Set X\nhK : ∀ (i : ι), IsClosed (K i)\nhU : ∀ (i : ι), IsOpen (U i)\nhKU : ∀ (i : ι), K i ⊆ U i\nhfin : LocallyFinite K\nx : X\nthis : ∀ (i : ι), x ∈ K i → ∀ᶠ (p : ℝ≥0∞ × X) in 𝓝 0 ×ˢ 𝓝 x, closedBall p.snd p.fst ⊆ U i\n⊢ ∀ᶠ (p : ℝ≥0∞ × X) in 𝓝 0 ×ˢ 𝓝 x, ∀ (i : ι), p.snd ∈ K i → closedBall p.snd p.fst ⊆ U i",
"tactic": "apply mp_mem ((eventually_all_finite (hfin.point_finite x)).2 this)\n (mp_mem (@tendsto_snd ℝ≥0∞ _ (𝓝 0) _ _ (hfin.iInter_compl_mem_nhds hK x)) _)"
},
{
"state_after": "case h\nι : Type u_2\nX : Type u_1\ninst✝ : EMetricSpace X\nK U : ι → Set X\nhK : ∀ (i : ι), IsClosed (K i)\nhU : ∀ (i : ι), IsOpen (U i)\nhKU : ∀ (i : ι), K i ⊆ U i\nhfin : LocallyFinite K\nx : X\nthis : ∀ (i : ι), x ∈ K i → ∀ᶠ (p : ℝ≥0∞ × X) in 𝓝 0 ×ˢ 𝓝 x, closedBall p.snd p.fst ⊆ U i\n⊢ ∀ (a : ℝ≥0∞ × X),\n a ∈\n {x_1 |\n (x_1 ∈ Prod.snd ⁻¹' ⋂ (i : ι) (_ : ¬x ∈ K i), K iᶜ) →\n x_1 ∈\n {x_2 |\n x_2 ∈ {x_3 | (fun x_4 => ∀ (i : ι), i ∈ {b | x ∈ K b} → closedBall x_4.snd x_4.fst ⊆ U i) x_3} →\n x_2 ∈ {x | (fun p => ∀ (i : ι), p.snd ∈ K i → closedBall p.snd p.fst ⊆ U i) x}}}",
"state_before": "ι : Type u_2\nX : Type u_1\ninst✝ : EMetricSpace X\nK U : ι → Set X\nhK : ∀ (i : ι), IsClosed (K i)\nhU : ∀ (i : ι), IsOpen (U i)\nhKU : ∀ (i : ι), K i ⊆ U i\nhfin : LocallyFinite K\nx : X\nthis : ∀ (i : ι), x ∈ K i → ∀ᶠ (p : ℝ≥0∞ × X) in 𝓝 0 ×ˢ 𝓝 x, closedBall p.snd p.fst ⊆ U i\n⊢ {x_1 |\n (x_1 ∈ Prod.snd ⁻¹' ⋂ (i : ι) (_ : ¬x ∈ K i), K iᶜ) →\n x_1 ∈\n {x_2 |\n x_2 ∈ {x_3 | (fun x_4 => ∀ (i : ι), i ∈ {b | x ∈ K b} → closedBall x_4.snd x_4.fst ⊆ U i) x_3} →\n x_2 ∈ {x | (fun p => ∀ (i : ι), p.snd ∈ K i → closedBall p.snd p.fst ⊆ U i) x}}} ∈\n 𝓝 0 ×ˢ 𝓝 x",
"tactic": "apply univ_mem'"
},
{
"state_after": "case h.mk\nι : Type u_2\nX : Type u_1\ninst✝ : EMetricSpace X\nK U : ι → Set X\nhK : ∀ (i : ι), IsClosed (K i)\nhU : ∀ (i : ι), IsOpen (U i)\nhKU : ∀ (i : ι), K i ⊆ U i\nhfin : LocallyFinite K\nx : X\nthis : ∀ (i : ι), x ∈ K i → ∀ᶠ (p : ℝ≥0∞ × X) in 𝓝 0 ×ˢ 𝓝 x, closedBall p.snd p.fst ⊆ U i\nr : ℝ≥0∞\ny : X\nhxy : (r, y) ∈ Prod.snd ⁻¹' ⋂ (i : ι) (_ : ¬x ∈ K i), K iᶜ\nhyU : (r, y) ∈ {x_1 | (fun x_2 => ∀ (i : ι), i ∈ {b | x ∈ K b} → closedBall x_2.snd x_2.fst ⊆ U i) x_1}\ni : ι\nhi : (r, y).snd ∈ K i\n⊢ closedBall (r, y).snd (r, y).fst ⊆ U i",
"state_before": "case h\nι : Type u_2\nX : Type u_1\ninst✝ : EMetricSpace X\nK U : ι → Set X\nhK : ∀ (i : ι), IsClosed (K i)\nhU : ∀ (i : ι), IsOpen (U i)\nhKU : ∀ (i : ι), K i ⊆ U i\nhfin : LocallyFinite K\nx : X\nthis : ∀ (i : ι), x ∈ K i → ∀ᶠ (p : ℝ≥0∞ × X) in 𝓝 0 ×ˢ 𝓝 x, closedBall p.snd p.fst ⊆ U i\n⊢ ∀ (a : ℝ≥0∞ × X),\n a ∈\n {x_1 |\n (x_1 ∈ Prod.snd ⁻¹' ⋂ (i : ι) (_ : ¬x ∈ K i), K iᶜ) →\n x_1 ∈\n {x_2 |\n x_2 ∈ {x_3 | (fun x_4 => ∀ (i : ι), i ∈ {b | x ∈ K b} → closedBall x_4.snd x_4.fst ⊆ U i) x_3} →\n x_2 ∈ {x | (fun p => ∀ (i : ι), p.snd ∈ K i → closedBall p.snd p.fst ⊆ U i) x}}}",
"tactic": "rintro ⟨r, y⟩ hxy hyU i hi"
},
{
"state_after": "case h.mk\nι : Type u_2\nX : Type u_1\ninst✝ : EMetricSpace X\nK U : ι → Set X\nhK : ∀ (i : ι), IsClosed (K i)\nhU : ∀ (i : ι), IsOpen (U i)\nhKU : ∀ (i : ι), K i ⊆ U i\nhfin : LocallyFinite K\nx : X\nthis : ∀ (i : ι), x ∈ K i → ∀ᶠ (p : ℝ≥0∞ × X) in 𝓝 0 ×ˢ 𝓝 x, closedBall p.snd p.fst ⊆ U i\nr : ℝ≥0∞\ny : X\nhyU : (r, y) ∈ {x_1 | (fun x_2 => ∀ (i : ι), i ∈ {b | x ∈ K b} → closedBall x_2.snd x_2.fst ⊆ U i) x_1}\ni : ι\nhi : (r, y).snd ∈ K i\nhxy : ∀ (i : ι), y ∈ K i → x ∈ K i\n⊢ closedBall (r, y).snd (r, y).fst ⊆ U i",
"state_before": "case h.mk\nι : Type u_2\nX : Type u_1\ninst✝ : EMetricSpace X\nK U : ι → Set X\nhK : ∀ (i : ι), IsClosed (K i)\nhU : ∀ (i : ι), IsOpen (U i)\nhKU : ∀ (i : ι), K i ⊆ U i\nhfin : LocallyFinite K\nx : X\nthis : ∀ (i : ι), x ∈ K i → ∀ᶠ (p : ℝ≥0∞ × X) in 𝓝 0 ×ˢ 𝓝 x, closedBall p.snd p.fst ⊆ U i\nr : ℝ≥0∞\ny : X\nhxy : (r, y) ∈ Prod.snd ⁻¹' ⋂ (i : ι) (_ : ¬x ∈ K i), K iᶜ\nhyU : (r, y) ∈ {x_1 | (fun x_2 => ∀ (i : ι), i ∈ {b | x ∈ K b} → closedBall x_2.snd x_2.fst ⊆ U i) x_1}\ni : ι\nhi : (r, y).snd ∈ K i\n⊢ closedBall (r, y).snd (r, y).fst ⊆ U i",
"tactic": "simp only [mem_iInter, mem_compl_iff, not_imp_not, mem_preimage] at hxy"
},
{
"state_after": "no goals",
"state_before": "case h.mk\nι : Type u_2\nX : Type u_1\ninst✝ : EMetricSpace X\nK U : ι → Set X\nhK : ∀ (i : ι), IsClosed (K i)\nhU : ∀ (i : ι), IsOpen (U i)\nhKU : ∀ (i : ι), K i ⊆ U i\nhfin : LocallyFinite K\nx : X\nthis : ∀ (i : ι), x ∈ K i → ∀ᶠ (p : ℝ≥0∞ × X) in 𝓝 0 ×ˢ 𝓝 x, closedBall p.snd p.fst ⊆ U i\nr : ℝ≥0∞\ny : X\nhyU : (r, y) ∈ {x_1 | (fun x_2 => ∀ (i : ι), i ∈ {b | x ∈ K b} → closedBall x_2.snd x_2.fst ⊆ U i) x_1}\ni : ι\nhi : (r, y).snd ∈ K i\nhxy : ∀ (i : ι), y ∈ K i → x ∈ K i\n⊢ closedBall (r, y).snd (r, y).fst ⊆ U i",
"tactic": "exact hyU _ (hxy _ hi)"
},
{
"state_after": "no goals",
"state_before": "ι : Type u_2\nX : Type u_1\ninst✝ : EMetricSpace X\nK U : ι → Set X\nhK : ∀ (i : ι), IsClosed (K i)\nhU : ∀ (i : ι), IsOpen (U i)\nhKU : ∀ (i : ι), K i ⊆ U i\nhfin : LocallyFinite K\nx : X\ni : ι\nhi : x ∈ K i\nR : ℝ≥0∞\nhR₀ : 0 < R\nhR : closedBall x R ⊆ U i\nr : ℝ≥0\nhr₀ : 0 < ↑r\nhrR : ↑r < R\np : ℝ≥0∞ × X\nhp : p ∈ {x | x < ↑r} ×ˢ closedBall x (R - ↑r)\nz : X\nhz : z ∈ closedBall p.snd p.fst\n⊢ p.fst < ↑r",
"tactic": "exact hp.1"
}
] |
[
63,
69
] |
5a919533f110b7d76410134a237ee374f24eaaad
|
https://github.com/leanprover-community/mathlib4
|
[
44,
1
] |
Mathlib/Geometry/Euclidean/Basic.lean
|
EuclideanGeometry.inner_weightedVSub
|
[
{
"state_after": "V : Type u_3\nP : Type u_4\ninst✝³ : NormedAddCommGroup V\ninst✝² : InnerProductSpace ℝ V\ninst✝¹ : MetricSpace P\ninst✝ : NormedAddTorsor V P\nι₁ : Type u_1\ns₁ : Finset ι₁\nw₁ : ι₁ → ℝ\np₁ : ι₁ → P\nh₁ : ∑ i in s₁, w₁ i = 0\nι₂ : Type u_2\ns₂ : Finset ι₂\nw₂ : ι₂ → ℝ\np₂ : ι₂ → P\nh₂ : ∑ i in s₂, w₂ i = 0\n⊢ (-∑ i₁ in s₁,\n ∑ i₂ in s₂,\n w₁ i₁ * w₂ i₂ *\n (‖p₁ i₁ -ᵥ choice (_ : Nonempty P) - (p₂ i₂ -ᵥ choice (_ : Nonempty P))‖ *\n ‖p₁ i₁ -ᵥ choice (_ : Nonempty P) - (p₂ i₂ -ᵥ choice (_ : Nonempty P))‖)) /\n 2 =\n (-∑ i₁ in s₁, ∑ i₂ in s₂, w₁ i₁ * w₂ i₂ * (dist (p₁ i₁) (p₂ i₂) * dist (p₁ i₁) (p₂ i₂))) / 2",
"state_before": "V : Type u_3\nP : Type u_4\ninst✝³ : NormedAddCommGroup V\ninst✝² : InnerProductSpace ℝ V\ninst✝¹ : MetricSpace P\ninst✝ : NormedAddTorsor V P\nι₁ : Type u_1\ns₁ : Finset ι₁\nw₁ : ι₁ → ℝ\np₁ : ι₁ → P\nh₁ : ∑ i in s₁, w₁ i = 0\nι₂ : Type u_2\ns₂ : Finset ι₂\nw₂ : ι₂ → ℝ\np₂ : ι₂ → P\nh₂ : ∑ i in s₂, w₂ i = 0\n⊢ inner (↑(Finset.weightedVSub s₁ p₁) w₁) (↑(Finset.weightedVSub s₂ p₂) w₂) =\n (-∑ i₁ in s₁, ∑ i₂ in s₂, w₁ i₁ * w₂ i₂ * (dist (p₁ i₁) (p₂ i₂) * dist (p₁ i₁) (p₂ i₂))) / 2",
"tactic": "rw [Finset.weightedVSub_apply, Finset.weightedVSub_apply,\n inner_sum_smul_sum_smul_of_sum_eq_zero _ h₁ _ h₂]"
},
{
"state_after": "V : Type u_3\nP : Type u_4\ninst✝³ : NormedAddCommGroup V\ninst✝² : InnerProductSpace ℝ V\ninst✝¹ : MetricSpace P\ninst✝ : NormedAddTorsor V P\nι₁ : Type u_1\ns₁ : Finset ι₁\nw₁ : ι₁ → ℝ\np₁ : ι₁ → P\nh₁ : ∑ i in s₁, w₁ i = 0\nι₂ : Type u_2\ns₂ : Finset ι₂\nw₂ : ι₂ → ℝ\np₂ : ι₂ → P\nh₂ : ∑ i in s₂, w₂ i = 0\n⊢ (-∑ x in s₁, ∑ x_1 in s₂, w₁ x * w₂ x_1 * (‖p₁ x -ᵥ p₂ x_1‖ * ‖p₁ x -ᵥ p₂ x_1‖)) / 2 =\n (-∑ i₁ in s₁, ∑ i₂ in s₂, w₁ i₁ * w₂ i₂ * (dist (p₁ i₁) (p₂ i₂) * dist (p₁ i₁) (p₂ i₂))) / 2",
"state_before": "V : Type u_3\nP : Type u_4\ninst✝³ : NormedAddCommGroup V\ninst✝² : InnerProductSpace ℝ V\ninst✝¹ : MetricSpace P\ninst✝ : NormedAddTorsor V P\nι₁ : Type u_1\ns₁ : Finset ι₁\nw₁ : ι₁ → ℝ\np₁ : ι₁ → P\nh₁ : ∑ i in s₁, w₁ i = 0\nι₂ : Type u_2\ns₂ : Finset ι₂\nw₂ : ι₂ → ℝ\np₂ : ι₂ → P\nh₂ : ∑ i in s₂, w₂ i = 0\n⊢ (-∑ i₁ in s₁,\n ∑ i₂ in s₂,\n w₁ i₁ * w₂ i₂ *\n (‖p₁ i₁ -ᵥ choice (_ : Nonempty P) - (p₂ i₂ -ᵥ choice (_ : Nonempty P))‖ *\n ‖p₁ i₁ -ᵥ choice (_ : Nonempty P) - (p₂ i₂ -ᵥ choice (_ : Nonempty P))‖)) /\n 2 =\n (-∑ i₁ in s₁, ∑ i₂ in s₂, w₁ i₁ * w₂ i₂ * (dist (p₁ i₁) (p₂ i₂) * dist (p₁ i₁) (p₂ i₂))) / 2",
"tactic": "simp_rw [vsub_sub_vsub_cancel_right]"
},
{
"state_after": "no goals",
"state_before": "V : Type u_3\nP : Type u_4\ninst✝³ : NormedAddCommGroup V\ninst✝² : InnerProductSpace ℝ V\ninst✝¹ : MetricSpace P\ninst✝ : NormedAddTorsor V P\nι₁ : Type u_1\ns₁ : Finset ι₁\nw₁ : ι₁ → ℝ\np₁ : ι₁ → P\nh₁ : ∑ i in s₁, w₁ i = 0\nι₂ : Type u_2\ns₂ : Finset ι₂\nw₂ : ι₂ → ℝ\np₂ : ι₂ → P\nh₂ : ∑ i in s₂, w₂ i = 0\n⊢ (-∑ x in s₁, ∑ x_1 in s₂, w₁ x * w₂ x_1 * (‖p₁ x -ᵥ p₂ x_1‖ * ‖p₁ x -ᵥ p₂ x_1‖)) / 2 =\n (-∑ i₁ in s₁, ∑ i₂ in s₂, w₁ i₁ * w₂ i₂ * (dist (p₁ i₁) (p₂ i₂) * dist (p₁ i₁) (p₂ i₂))) / 2",
"tactic": "rcongr (i₁ i₂) <;> rw [dist_eq_norm_vsub V (p₁ i₁) (p₂ i₂)]"
}
] |
[
93,
62
] |
5a919533f110b7d76410134a237ee374f24eaaad
|
https://github.com/leanprover-community/mathlib4
|
[
84,
1
] |
Mathlib/Data/MvPolynomial/PDeriv.lean
|
MvPolynomial.pderiv_X
|
[
{
"state_after": "no goals",
"state_before": "R : Type u\nσ : Type v\na a' a₁ a₂ : R\ns : σ →₀ ℕ\ninst✝¹ : CommSemiring R\ninst✝ : DecidableEq σ\ni j : σ\n⊢ ↑(pderiv i) (X j) = Pi.single i 1 j",
"tactic": "rw [pderiv_def, mkDerivation_X]"
}
] |
[
96,
34
] |
5a919533f110b7d76410134a237ee374f24eaaad
|
https://github.com/leanprover-community/mathlib4
|
[
94,
1
] |
Mathlib/Algebra/Lie/Submodule.lean
|
LieSubmodule.comap_incl_eq_top
|
[
{
"state_after": "no goals",
"state_before": "R : Type u\nL : Type v\nL' : Type w₂\nM : Type w\nM' : Type w₁\ninst✝¹² : CommRing R\ninst✝¹¹ : LieRing L\ninst✝¹⁰ : LieAlgebra R L\ninst✝⁹ : LieRing L'\ninst✝⁸ : LieAlgebra R L'\ninst✝⁷ : AddCommGroup M\ninst✝⁶ : Module R M\ninst✝⁵ : LieRingModule L M\ninst✝⁴ : LieModule R L M\ninst✝³ : AddCommGroup M'\ninst✝² : Module R M'\ninst✝¹ : LieRingModule L M'\ninst✝ : LieModule R L M'\nf : M →ₗ⁅R,L⁆ M'\nN N₂ : LieSubmodule R L M\nN' : LieSubmodule R L M'\n⊢ comap (incl N) N₂ = ⊤ ↔ N ≤ N₂",
"tactic": "rw [← LieSubmodule.coe_toSubmodule_eq_iff, LieSubmodule.coeSubmodule_comap, LieSubmodule.incl_coe,\n LieSubmodule.top_coeSubmodule, Submodule.comap_subtype_eq_top, coeSubmodule_le_coeSubmodule]"
}
] |
[
762,
97
] |
5a919533f110b7d76410134a237ee374f24eaaad
|
https://github.com/leanprover-community/mathlib4
|
[
760,
1
] |
Mathlib/RingTheory/Localization/Away/Basic.lean
|
IsLocalization.Away.mul_invSelf
|
[
{
"state_after": "case h.e'_2.h.e'_5\nR : Type u_2\ninst✝⁴ : CommSemiring R\nM : Submonoid R\nS : Type u_1\ninst✝³ : CommSemiring S\ninst✝² : Algebra R S\nP : Type ?u.3731\ninst✝¹ : CommSemiring P\nx : R\ninst✝ : Away x S\n⊢ ↑(algebraMap R S) x = mk' S (↑{ val := x, property := (_ : x ∈ Submonoid.powers x) }) 1",
"state_before": "R : Type u_2\ninst✝⁴ : CommSemiring R\nM : Submonoid R\nS : Type u_1\ninst✝³ : CommSemiring S\ninst✝² : Algebra R S\nP : Type ?u.3731\ninst✝¹ : CommSemiring P\nx : R\ninst✝ : Away x S\n⊢ ↑(algebraMap R S) x * invSelf x = 1",
"tactic": "convert IsLocalization.mk'_mul_mk'_eq_one (M := Submonoid.powers x) (S := S) _ 1"
},
{
"state_after": "case h.e'_2.h.e'_5\nR : Type u_2\ninst✝⁴ : CommSemiring R\nM : Submonoid R\nS : Type u_1\ninst✝³ : CommSemiring S\ninst✝² : Algebra R S\nP : Type ?u.3731\ninst✝¹ : CommSemiring P\nx : R\ninst✝ : Away x S\n⊢ mk' S (↑{ val := x, property := (_ : x ∈ Submonoid.powers x) }) 1 = ↑(algebraMap R S) x",
"state_before": "case h.e'_2.h.e'_5\nR : Type u_2\ninst✝⁴ : CommSemiring R\nM : Submonoid R\nS : Type u_1\ninst✝³ : CommSemiring S\ninst✝² : Algebra R S\nP : Type ?u.3731\ninst✝¹ : CommSemiring P\nx : R\ninst✝ : Away x S\n⊢ ↑(algebraMap R S) x = mk' S (↑{ val := x, property := (_ : x ∈ Submonoid.powers x) }) 1",
"tactic": "symm"
},
{
"state_after": "no goals",
"state_before": "case h.e'_2.h.e'_5\nR : Type u_2\ninst✝⁴ : CommSemiring R\nM : Submonoid R\nS : Type u_1\ninst✝³ : CommSemiring S\ninst✝² : Algebra R S\nP : Type ?u.3731\ninst✝¹ : CommSemiring P\nx : R\ninst✝ : Away x S\n⊢ mk' S (↑{ val := x, property := (_ : x ∈ Submonoid.powers x) }) 1 = ↑(algebraMap R S) x",
"tactic": "apply IsLocalization.mk'_one"
}
] |
[
65,
31
] |
5a919533f110b7d76410134a237ee374f24eaaad
|
https://github.com/leanprover-community/mathlib4
|
[
62,
1
] |
Mathlib/FieldTheory/Normal.lean
|
Normal.of_algEquiv
|
[
{
"state_after": "case intro\nF : Type u_1\nK : Type ?u.73378\ninst✝¹¹ : Field F\ninst✝¹⁰ : Field K\ninst✝⁹ : Algebra F K\nE : Type u_2\ninst✝⁸ : Field E\ninst✝⁷ : Algebra F E\ninst✝⁶ : Algebra K E\ninst✝⁵ : IsScalarTower F K E\nE' : Type u_3\ninst✝⁴ : Field F\ninst✝³ : Field E\ninst✝² : Algebra F E\ninst✝¹ : Field E'\ninst✝ : Algebra F E'\nh : Normal F E\nf : E ≃ₐ[F] E'\nx : E'\nhx : IsIntegral F (↑(AlgEquiv.symm f) x)\nhhx : Splits (algebraMap F E) (minpoly F (↑(AlgEquiv.symm f) x))\n⊢ IsIntegral F x ∧ Splits (algebraMap F E') (minpoly F x)",
"state_before": "F : Type u_1\nK : Type ?u.73378\ninst✝¹¹ : Field F\ninst✝¹⁰ : Field K\ninst✝⁹ : Algebra F K\nE : Type u_2\ninst✝⁸ : Field E\ninst✝⁷ : Algebra F E\ninst✝⁶ : Algebra K E\ninst✝⁵ : IsScalarTower F K E\nE' : Type u_3\ninst✝⁴ : Field F\ninst✝³ : Field E\ninst✝² : Algebra F E\ninst✝¹ : Field E'\ninst✝ : Algebra F E'\nh : Normal F E\nf : E ≃ₐ[F] E'\nx : E'\n⊢ IsIntegral F x ∧ Splits (algebraMap F E') (minpoly F x)",
"tactic": "cases' h.out (f.symm x) with hx hhx"
},
{
"state_after": "case intro\nF : Type u_1\nK : Type ?u.73378\ninst✝¹¹ : Field F\ninst✝¹⁰ : Field K\ninst✝⁹ : Algebra F K\nE : Type u_2\ninst✝⁸ : Field E\ninst✝⁷ : Algebra F E\ninst✝⁶ : Algebra K E\ninst✝⁵ : IsScalarTower F K E\nE' : Type u_3\ninst✝⁴ : Field F\ninst✝³ : Field E\ninst✝² : Algebra F E\ninst✝¹ : Field E'\ninst✝ : Algebra F E'\nh : Normal F E\nf : E ≃ₐ[F] E'\nx : E'\nhx : IsIntegral F (↑(AlgEquiv.symm f) x)\nhhx : Splits (algebraMap F E) (minpoly F (↑(AlgEquiv.symm f) x))\nH : IsIntegral F (↑↑f (↑(AlgEquiv.symm f) x))\n⊢ IsIntegral F x ∧ Splits (algebraMap F E') (minpoly F x)",
"state_before": "case intro\nF : Type u_1\nK : Type ?u.73378\ninst✝¹¹ : Field F\ninst✝¹⁰ : Field K\ninst✝⁹ : Algebra F K\nE : Type u_2\ninst✝⁸ : Field E\ninst✝⁷ : Algebra F E\ninst✝⁶ : Algebra K E\ninst✝⁵ : IsScalarTower F K E\nE' : Type u_3\ninst✝⁴ : Field F\ninst✝³ : Field E\ninst✝² : Algebra F E\ninst✝¹ : Field E'\ninst✝ : Algebra F E'\nh : Normal F E\nf : E ≃ₐ[F] E'\nx : E'\nhx : IsIntegral F (↑(AlgEquiv.symm f) x)\nhhx : Splits (algebraMap F E) (minpoly F (↑(AlgEquiv.symm f) x))\n⊢ IsIntegral F x ∧ Splits (algebraMap F E') (minpoly F x)",
"tactic": "have H := map_isIntegral f.toAlgHom hx"
},
{
"state_after": "case intro\nF : Type u_1\nK : Type ?u.73378\ninst✝¹¹ : Field F\ninst✝¹⁰ : Field K\ninst✝⁹ : Algebra F K\nE : Type u_2\ninst✝⁸ : Field E\ninst✝⁷ : Algebra F E\ninst✝⁶ : Algebra K E\ninst✝⁵ : IsScalarTower F K E\nE' : Type u_3\ninst✝⁴ : Field F\ninst✝³ : Field E\ninst✝² : Algebra F E\ninst✝¹ : Field E'\ninst✝ : Algebra F E'\nh : Normal F E\nf : E ≃ₐ[F] E'\nx : E'\nhx : IsIntegral F (↑(AlgEquiv.symm f) x)\nhhx : Splits (algebraMap F E) (minpoly F (↑(AlgEquiv.symm f) x))\nH : IsIntegral F x\n⊢ IsIntegral F x ∧ Splits (algebraMap F E') (minpoly F x)",
"state_before": "case intro\nF : Type u_1\nK : Type ?u.73378\ninst✝¹¹ : Field F\ninst✝¹⁰ : Field K\ninst✝⁹ : Algebra F K\nE : Type u_2\ninst✝⁸ : Field E\ninst✝⁷ : Algebra F E\ninst✝⁶ : Algebra K E\ninst✝⁵ : IsScalarTower F K E\nE' : Type u_3\ninst✝⁴ : Field F\ninst✝³ : Field E\ninst✝² : Algebra F E\ninst✝¹ : Field E'\ninst✝ : Algebra F E'\nh : Normal F E\nf : E ≃ₐ[F] E'\nx : E'\nhx : IsIntegral F (↑(AlgEquiv.symm f) x)\nhhx : Splits (algebraMap F E) (minpoly F (↑(AlgEquiv.symm f) x))\nH : IsIntegral F (↑↑f (↑(AlgEquiv.symm f) x))\n⊢ IsIntegral F x ∧ Splits (algebraMap F E') (minpoly F x)",
"tactic": "simp [AlgEquiv.toAlgHom_eq_coe] at H"
},
{
"state_after": "case intro\nF : Type u_1\nK : Type ?u.73378\ninst✝¹¹ : Field F\ninst✝¹⁰ : Field K\ninst✝⁹ : Algebra F K\nE : Type u_2\ninst✝⁸ : Field E\ninst✝⁷ : Algebra F E\ninst✝⁶ : Algebra K E\ninst✝⁵ : IsScalarTower F K E\nE' : Type u_3\ninst✝⁴ : Field F\ninst✝³ : Field E\ninst✝² : Algebra F E\ninst✝¹ : Field E'\ninst✝ : Algebra F E'\nh : Normal F E\nf : E ≃ₐ[F] E'\nx : E'\nhx : IsIntegral F (↑(AlgEquiv.symm f) x)\nhhx : Splits (algebraMap F E) (minpoly F (↑(AlgEquiv.symm f) x))\nH : IsIntegral F x\n⊢ Splits (algebraMap F E') (minpoly F x)",
"state_before": "case intro\nF : Type u_1\nK : Type ?u.73378\ninst✝¹¹ : Field F\ninst✝¹⁰ : Field K\ninst✝⁹ : Algebra F K\nE : Type u_2\ninst✝⁸ : Field E\ninst✝⁷ : Algebra F E\ninst✝⁶ : Algebra K E\ninst✝⁵ : IsScalarTower F K E\nE' : Type u_3\ninst✝⁴ : Field F\ninst✝³ : Field E\ninst✝² : Algebra F E\ninst✝¹ : Field E'\ninst✝ : Algebra F E'\nh : Normal F E\nf : E ≃ₐ[F] E'\nx : E'\nhx : IsIntegral F (↑(AlgEquiv.symm f) x)\nhhx : Splits (algebraMap F E) (minpoly F (↑(AlgEquiv.symm f) x))\nH : IsIntegral F x\n⊢ IsIntegral F x ∧ Splits (algebraMap F E') (minpoly F x)",
"tactic": "use H"
},
{
"state_after": "case intro.hf\nF : Type u_1\nK : Type ?u.73378\ninst✝¹¹ : Field F\ninst✝¹⁰ : Field K\ninst✝⁹ : Algebra F K\nE : Type u_2\ninst✝⁸ : Field E\ninst✝⁷ : Algebra F E\ninst✝⁶ : Algebra K E\ninst✝⁵ : IsScalarTower F K E\nE' : Type u_3\ninst✝⁴ : Field F\ninst✝³ : Field E\ninst✝² : Algebra F E\ninst✝¹ : Field E'\ninst✝ : Algebra F E'\nh : Normal F E\nf : E ≃ₐ[F] E'\nx : E'\nhx : IsIntegral F (↑(AlgEquiv.symm f) x)\nhhx : Splits (algebraMap F E) (minpoly F (↑(AlgEquiv.symm f) x))\nH : IsIntegral F x\n⊢ Splits (algebraMap F E') (minpoly F (↑(AlgEquiv.symm f) x))\n\ncase intro.hgf\nF : Type u_1\nK : Type ?u.73378\ninst✝¹¹ : Field F\ninst✝¹⁰ : Field K\ninst✝⁹ : Algebra F K\nE : Type u_2\ninst✝⁸ : Field E\ninst✝⁷ : Algebra F E\ninst✝⁶ : Algebra K E\ninst✝⁵ : IsScalarTower F K E\nE' : Type u_3\ninst✝⁴ : Field F\ninst✝³ : Field E\ninst✝² : Algebra F E\ninst✝¹ : Field E'\ninst✝ : Algebra F E'\nh : Normal F E\nf : E ≃ₐ[F] E'\nx : E'\nhx : IsIntegral F (↑(AlgEquiv.symm f) x)\nhhx : Splits (algebraMap F E) (minpoly F (↑(AlgEquiv.symm f) x))\nH : IsIntegral F x\n⊢ minpoly F x ∣ minpoly F (↑(AlgEquiv.symm f) x)",
"state_before": "case intro\nF : Type u_1\nK : Type ?u.73378\ninst✝¹¹ : Field F\ninst✝¹⁰ : Field K\ninst✝⁹ : Algebra F K\nE : Type u_2\ninst✝⁸ : Field E\ninst✝⁷ : Algebra F E\ninst✝⁶ : Algebra K E\ninst✝⁵ : IsScalarTower F K E\nE' : Type u_3\ninst✝⁴ : Field F\ninst✝³ : Field E\ninst✝² : Algebra F E\ninst✝¹ : Field E'\ninst✝ : Algebra F E'\nh : Normal F E\nf : E ≃ₐ[F] E'\nx : E'\nhx : IsIntegral F (↑(AlgEquiv.symm f) x)\nhhx : Splits (algebraMap F E) (minpoly F (↑(AlgEquiv.symm f) x))\nH : IsIntegral F x\n⊢ Splits (algebraMap F E') (minpoly F x)",
"tactic": "apply Polynomial.splits_of_splits_of_dvd (algebraMap F E') (minpoly.ne_zero hx)"
},
{
"state_after": "case intro.hf\nF : Type u_1\nK : Type ?u.73378\ninst✝¹¹ : Field F\ninst✝¹⁰ : Field K\ninst✝⁹ : Algebra F K\nE : Type u_2\ninst✝⁸ : Field E\ninst✝⁷ : Algebra F E\ninst✝⁶ : Algebra K E\ninst✝⁵ : IsScalarTower F K E\nE' : Type u_3\ninst✝⁴ : Field F\ninst✝³ : Field E\ninst✝² : Algebra F E\ninst✝¹ : Field E'\ninst✝ : Algebra F E'\nh : Normal F E\nf : E ≃ₐ[F] E'\nx : E'\nhx : IsIntegral F (↑(AlgEquiv.symm f) x)\nhhx : Splits (algebraMap F E) (minpoly F (↑(AlgEquiv.symm f) x))\nH : IsIntegral F x\n⊢ Splits (RingHom.comp (↑↑f) (algebraMap F E)) (minpoly F (↑(AlgEquiv.symm f) x))",
"state_before": "case intro.hf\nF : Type u_1\nK : Type ?u.73378\ninst✝¹¹ : Field F\ninst✝¹⁰ : Field K\ninst✝⁹ : Algebra F K\nE : Type u_2\ninst✝⁸ : Field E\ninst✝⁷ : Algebra F E\ninst✝⁶ : Algebra K E\ninst✝⁵ : IsScalarTower F K E\nE' : Type u_3\ninst✝⁴ : Field F\ninst✝³ : Field E\ninst✝² : Algebra F E\ninst✝¹ : Field E'\ninst✝ : Algebra F E'\nh : Normal F E\nf : E ≃ₐ[F] E'\nx : E'\nhx : IsIntegral F (↑(AlgEquiv.symm f) x)\nhhx : Splits (algebraMap F E) (minpoly F (↑(AlgEquiv.symm f) x))\nH : IsIntegral F x\n⊢ Splits (algebraMap F E') (minpoly F (↑(AlgEquiv.symm f) x))",
"tactic": "rw [← AlgHom.comp_algebraMap f.toAlgHom]"
},
{
"state_after": "no goals",
"state_before": "case intro.hf\nF : Type u_1\nK : Type ?u.73378\ninst✝¹¹ : Field F\ninst✝¹⁰ : Field K\ninst✝⁹ : Algebra F K\nE : Type u_2\ninst✝⁸ : Field E\ninst✝⁷ : Algebra F E\ninst✝⁶ : Algebra K E\ninst✝⁵ : IsScalarTower F K E\nE' : Type u_3\ninst✝⁴ : Field F\ninst✝³ : Field E\ninst✝² : Algebra F E\ninst✝¹ : Field E'\ninst✝ : Algebra F E'\nh : Normal F E\nf : E ≃ₐ[F] E'\nx : E'\nhx : IsIntegral F (↑(AlgEquiv.symm f) x)\nhhx : Splits (algebraMap F E) (minpoly F (↑(AlgEquiv.symm f) x))\nH : IsIntegral F x\n⊢ Splits (RingHom.comp (↑↑f) (algebraMap F E)) (minpoly F (↑(AlgEquiv.symm f) x))",
"tactic": "exact Polynomial.splits_comp_of_splits (algebraMap F E) f.toAlgHom.toRingHom hhx"
},
{
"state_after": "case intro.hgf\nF : Type u_1\nK : Type ?u.73378\ninst✝¹¹ : Field F\ninst✝¹⁰ : Field K\ninst✝⁹ : Algebra F K\nE : Type u_2\ninst✝⁸ : Field E\ninst✝⁷ : Algebra F E\ninst✝⁶ : Algebra K E\ninst✝⁵ : IsScalarTower F K E\nE' : Type u_3\ninst✝⁴ : Field F\ninst✝³ : Field E\ninst✝² : Algebra F E\ninst✝¹ : Field E'\ninst✝ : Algebra F E'\nh : Normal F E\nf : E ≃ₐ[F] E'\nx : E'\nhx : IsIntegral F (↑(AlgEquiv.symm f) x)\nhhx : Splits (algebraMap F E) (minpoly F (↑(AlgEquiv.symm f) x))\nH : IsIntegral F x\n⊢ ↑(aeval x) (minpoly F (↑(AlgEquiv.symm f) x)) = 0",
"state_before": "case intro.hgf\nF : Type u_1\nK : Type ?u.73378\ninst✝¹¹ : Field F\ninst✝¹⁰ : Field K\ninst✝⁹ : Algebra F K\nE : Type u_2\ninst✝⁸ : Field E\ninst✝⁷ : Algebra F E\ninst✝⁶ : Algebra K E\ninst✝⁵ : IsScalarTower F K E\nE' : Type u_3\ninst✝⁴ : Field F\ninst✝³ : Field E\ninst✝² : Algebra F E\ninst✝¹ : Field E'\ninst✝ : Algebra F E'\nh : Normal F E\nf : E ≃ₐ[F] E'\nx : E'\nhx : IsIntegral F (↑(AlgEquiv.symm f) x)\nhhx : Splits (algebraMap F E) (minpoly F (↑(AlgEquiv.symm f) x))\nH : IsIntegral F x\n⊢ minpoly F x ∣ minpoly F (↑(AlgEquiv.symm f) x)",
"tactic": "apply minpoly.dvd _ _"
},
{
"state_after": "case intro.hgf\nF : Type u_1\nK : Type ?u.73378\ninst✝¹¹ : Field F\ninst✝¹⁰ : Field K\ninst✝⁹ : Algebra F K\nE : Type u_2\ninst✝⁸ : Field E\ninst✝⁷ : Algebra F E\ninst✝⁶ : Algebra K E\ninst✝⁵ : IsScalarTower F K E\nE' : Type u_3\ninst✝⁴ : Field F\ninst✝³ : Field E\ninst✝² : Algebra F E\ninst✝¹ : Field E'\ninst✝ : Algebra F E'\nh : Normal F E\nf : E ≃ₐ[F] E'\nx : E'\nhx : IsIntegral F (↑(AlgEquiv.symm f) x)\nhhx : Splits (algebraMap F E) (minpoly F (↑(AlgEquiv.symm f) x))\nH : IsIntegral F x\n⊢ ↑(AlgEquiv.toAddEquiv (AlgEquiv.symm f)) (↑(aeval x) (minpoly F (↑(AlgEquiv.symm f) x))) = 0",
"state_before": "case intro.hgf\nF : Type u_1\nK : Type ?u.73378\ninst✝¹¹ : Field F\ninst✝¹⁰ : Field K\ninst✝⁹ : Algebra F K\nE : Type u_2\ninst✝⁸ : Field E\ninst✝⁷ : Algebra F E\ninst✝⁶ : Algebra K E\ninst✝⁵ : IsScalarTower F K E\nE' : Type u_3\ninst✝⁴ : Field F\ninst✝³ : Field E\ninst✝² : Algebra F E\ninst✝¹ : Field E'\ninst✝ : Algebra F E'\nh : Normal F E\nf : E ≃ₐ[F] E'\nx : E'\nhx : IsIntegral F (↑(AlgEquiv.symm f) x)\nhhx : Splits (algebraMap F E) (minpoly F (↑(AlgEquiv.symm f) x))\nH : IsIntegral F x\n⊢ ↑(aeval x) (minpoly F (↑(AlgEquiv.symm f) x)) = 0",
"tactic": "rw [← AddEquiv.map_eq_zero_iff f.symm.toAddEquiv]"
},
{
"state_after": "no goals",
"state_before": "case intro.hgf\nF : Type u_1\nK : Type ?u.73378\ninst✝¹¹ : Field F\ninst✝¹⁰ : Field K\ninst✝⁹ : Algebra F K\nE : Type u_2\ninst✝⁸ : Field E\ninst✝⁷ : Algebra F E\ninst✝⁶ : Algebra K E\ninst✝⁵ : IsScalarTower F K E\nE' : Type u_3\ninst✝⁴ : Field F\ninst✝³ : Field E\ninst✝² : Algebra F E\ninst✝¹ : Field E'\ninst✝ : Algebra F E'\nh : Normal F E\nf : E ≃ₐ[F] E'\nx : E'\nhx : IsIntegral F (↑(AlgEquiv.symm f) x)\nhhx : Splits (algebraMap F E) (minpoly F (↑(AlgEquiv.symm f) x))\nH : IsIntegral F x\n⊢ ↑(AlgEquiv.toAddEquiv (AlgEquiv.symm f)) (↑(aeval x) (minpoly F (↑(AlgEquiv.symm f) x))) = 0",
"tactic": "exact\n Eq.trans (Polynomial.aeval_algHom_apply f.symm.toAlgHom x (minpoly F (f.symm x))).symm\n (minpoly.aeval _ _)"
}
] |
[
150,
30
] |
5a919533f110b7d76410134a237ee374f24eaaad
|
https://github.com/leanprover-community/mathlib4
|
[
137,
1
] |
Mathlib/SetTheory/Cardinal/Basic.lean
|
Cardinal.cast_toNat_of_lt_aleph0
|
[
{
"state_after": "no goals",
"state_before": "α β : Type u\nc : Cardinal\nh : c < ℵ₀\n⊢ ↑(↑toNat c) = c",
"tactic": "rw [toNat_apply_of_lt_aleph0 h, ← Classical.choose_spec (lt_aleph0.1 h)]"
}
] |
[
1686,
75
] |
5a919533f110b7d76410134a237ee374f24eaaad
|
https://github.com/leanprover-community/mathlib4
|
[
1685,
1
] |
Mathlib/Topology/Category/TopCat/Opens.lean
|
TopologicalSpace.Opens.adjunction_counit_app_self
|
[
{
"state_after": "no goals",
"state_before": "X : TopCat\nU : Opens ↑X\n⊢ (map (inclusion U) ⋙ IsOpenMap.functor (_ : IsOpenMap ((forget TopCat).map (inclusion U)))).obj U =\n (𝟭 (Opens ↑X)).obj U",
"tactic": "simp"
}
] |
[
352,
99
] |
5a919533f110b7d76410134a237ee374f24eaaad
|
https://github.com/leanprover-community/mathlib4
|
[
351,
1
] |
Mathlib/Data/Nat/Totient.lean
|
Nat.totient_prime_pow
|
[
{
"state_after": "case intro\np : ℕ\nhp : Prime p\nm : ℕ\nhn : 0 < succ m\n⊢ φ (p ^ succ m) = p ^ (succ m - 1) * (p - 1)",
"state_before": "p : ℕ\nhp : Prime p\nn : ℕ\nhn : 0 < n\n⊢ φ (p ^ n) = p ^ (n - 1) * (p - 1)",
"tactic": "rcases exists_eq_succ_of_ne_zero (pos_iff_ne_zero.1 hn) with ⟨m, rfl⟩"
},
{
"state_after": "no goals",
"state_before": "case intro\np : ℕ\nhp : Prime p\nm : ℕ\nhn : 0 < succ m\n⊢ φ (p ^ succ m) = p ^ (succ m - 1) * (p - 1)",
"tactic": "exact totient_prime_pow_succ hp _"
}
] |
[
225,
36
] |
5a919533f110b7d76410134a237ee374f24eaaad
|
https://github.com/leanprover-community/mathlib4
|
[
222,
1
] |
Mathlib/Topology/Basic.lean
|
IsClosed.interior_union_right
|
[
{
"state_after": "no goals",
"state_before": "α : Type u\nβ : Type v\nι : Sort w\na : α\ns✝ s₁ s₂ t✝ : Set α\np p₁ p₂ : α → Prop\ninst✝ : TopologicalSpace α\ns t : Set α\nh : IsClosed t\n⊢ interior (s ∪ t) ⊆ interior s ∪ t",
"tactic": "simpa only [union_comm _ t] using h.interior_union_left"
}
] |
[
1385,
58
] |
5a919533f110b7d76410134a237ee374f24eaaad
|
https://github.com/leanprover-community/mathlib4
|
[
1383,
1
] |
Mathlib/Algebra/Algebra/Subalgebra/Basic.lean
|
Subalgebra.inclusion_mk
|
[] |
[
1057,
6
] |
5a919533f110b7d76410134a237ee374f24eaaad
|
https://github.com/leanprover-community/mathlib4
|
[
1055,
1
] |
Mathlib/Geometry/Euclidean/Angle/Unoriented/Affine.lean
|
EuclideanGeometry.angle_eq_left
|
[
{
"state_after": "V : Type u_1\nP : Type u_2\ninst✝³ : NormedAddCommGroup V\ninst✝² : InnerProductSpace ℝ V\ninst✝¹ : MetricSpace P\ninst✝ : NormedAddTorsor V P\np1 p2 : P\n⊢ InnerProductGeometry.angle (p1 -ᵥ p1) (p2 -ᵥ p1) = π / 2",
"state_before": "V : Type u_1\nP : Type u_2\ninst✝³ : NormedAddCommGroup V\ninst✝² : InnerProductSpace ℝ V\ninst✝¹ : MetricSpace P\ninst✝ : NormedAddTorsor V P\np1 p2 : P\n⊢ ∠ p1 p1 p2 = π / 2",
"tactic": "unfold angle"
},
{
"state_after": "V : Type u_1\nP : Type u_2\ninst✝³ : NormedAddCommGroup V\ninst✝² : InnerProductSpace ℝ V\ninst✝¹ : MetricSpace P\ninst✝ : NormedAddTorsor V P\np1 p2 : P\n⊢ InnerProductGeometry.angle 0 (p2 -ᵥ p1) = π / 2",
"state_before": "V : Type u_1\nP : Type u_2\ninst✝³ : NormedAddCommGroup V\ninst✝² : InnerProductSpace ℝ V\ninst✝¹ : MetricSpace P\ninst✝ : NormedAddTorsor V P\np1 p2 : P\n⊢ InnerProductGeometry.angle (p1 -ᵥ p1) (p2 -ᵥ p1) = π / 2",
"tactic": "rw [vsub_self]"
},
{
"state_after": "no goals",
"state_before": "V : Type u_1\nP : Type u_2\ninst✝³ : NormedAddCommGroup V\ninst✝² : InnerProductSpace ℝ V\ninst✝¹ : MetricSpace P\ninst✝ : NormedAddTorsor V P\np1 p2 : P\n⊢ InnerProductGeometry.angle 0 (p2 -ᵥ p1) = π / 2",
"tactic": "exact angle_zero_left _"
}
] |
[
147,
26
] |
5a919533f110b7d76410134a237ee374f24eaaad
|
https://github.com/leanprover-community/mathlib4
|
[
144,
1
] |
Mathlib/Topology/Constructions.lean
|
ContinuousAt.snd
|
[] |
[
384,
27
] |
5a919533f110b7d76410134a237ee374f24eaaad
|
https://github.com/leanprover-community/mathlib4
|
[
382,
1
] |
Mathlib/MeasureTheory/Function/SimpleFunc.lean
|
MeasureTheory.SimpleFunc.coe_injective
|
[
{
"state_after": "case mk\nα : Type u_1\nβ : Type u_2\nγ : Type ?u.9713\nδ : Type ?u.9716\ninst✝ : MeasurableSpace α\ng : α →ₛ β\ntoFun✝ : α → β\nmeasurableSet_fiber'✝ : ∀ (x : β), MeasurableSet (toFun✝ ⁻¹' {x})\nfinite_range'✝ : Set.Finite (range toFun✝)\nH : ↑{ toFun := toFun✝, measurableSet_fiber' := measurableSet_fiber'✝, finite_range' := finite_range'✝ } = ↑g\n⊢ { toFun := toFun✝, measurableSet_fiber' := measurableSet_fiber'✝, finite_range' := finite_range'✝ } = g",
"state_before": "α : Type u_1\nβ : Type u_2\nγ : Type ?u.9713\nδ : Type ?u.9716\ninst✝ : MeasurableSpace α\nf g : α →ₛ β\nH : ↑f = ↑g\n⊢ f = g",
"tactic": "cases f"
},
{
"state_after": "case mk.mk\nα : Type u_1\nβ : Type u_2\nγ : Type ?u.9713\nδ : Type ?u.9716\ninst✝ : MeasurableSpace α\ntoFun✝¹ : α → β\nmeasurableSet_fiber'✝¹ : ∀ (x : β), MeasurableSet (toFun✝¹ ⁻¹' {x})\nfinite_range'✝¹ : Set.Finite (range toFun✝¹)\ntoFun✝ : α → β\nmeasurableSet_fiber'✝ : ∀ (x : β), MeasurableSet (toFun✝ ⁻¹' {x})\nfinite_range'✝ : Set.Finite (range toFun✝)\nH :\n ↑{ toFun := toFun✝¹, measurableSet_fiber' := measurableSet_fiber'✝¹, finite_range' := finite_range'✝¹ } =\n ↑{ toFun := toFun✝, measurableSet_fiber' := measurableSet_fiber'✝, finite_range' := finite_range'✝ }\n⊢ { toFun := toFun✝¹, measurableSet_fiber' := measurableSet_fiber'✝¹, finite_range' := finite_range'✝¹ } =\n { toFun := toFun✝, measurableSet_fiber' := measurableSet_fiber'✝, finite_range' := finite_range'✝ }",
"state_before": "case mk\nα : Type u_1\nβ : Type u_2\nγ : Type ?u.9713\nδ : Type ?u.9716\ninst✝ : MeasurableSpace α\ng : α →ₛ β\ntoFun✝ : α → β\nmeasurableSet_fiber'✝ : ∀ (x : β), MeasurableSet (toFun✝ ⁻¹' {x})\nfinite_range'✝ : Set.Finite (range toFun✝)\nH : ↑{ toFun := toFun✝, measurableSet_fiber' := measurableSet_fiber'✝, finite_range' := finite_range'✝ } = ↑g\n⊢ { toFun := toFun✝, measurableSet_fiber' := measurableSet_fiber'✝, finite_range' := finite_range'✝ } = g",
"tactic": "cases g"
},
{
"state_after": "no goals",
"state_before": "case mk.mk\nα : Type u_1\nβ : Type u_2\nγ : Type ?u.9713\nδ : Type ?u.9716\ninst✝ : MeasurableSpace α\ntoFun✝¹ : α → β\nmeasurableSet_fiber'✝¹ : ∀ (x : β), MeasurableSet (toFun✝¹ ⁻¹' {x})\nfinite_range'✝¹ : Set.Finite (range toFun✝¹)\ntoFun✝ : α → β\nmeasurableSet_fiber'✝ : ∀ (x : β), MeasurableSet (toFun✝ ⁻¹' {x})\nfinite_range'✝ : Set.Finite (range toFun✝)\nH :\n ↑{ toFun := toFun✝¹, measurableSet_fiber' := measurableSet_fiber'✝¹, finite_range' := finite_range'✝¹ } =\n ↑{ toFun := toFun✝, measurableSet_fiber' := measurableSet_fiber'✝, finite_range' := finite_range'✝ }\n⊢ { toFun := toFun✝¹, measurableSet_fiber' := measurableSet_fiber'✝¹, finite_range' := finite_range'✝¹ } =\n { toFun := toFun✝, measurableSet_fiber' := measurableSet_fiber'✝, finite_range' := finite_range'✝ }",
"tactic": "congr"
}
] |
[
72,
26
] |
5a919533f110b7d76410134a237ee374f24eaaad
|
https://github.com/leanprover-community/mathlib4
|
[
71,
1
] |
Mathlib/RingTheory/Subring/Basic.lean
|
Subring.coe_prod
|
[] |
[
1099,
6
] |
5a919533f110b7d76410134a237ee374f24eaaad
|
https://github.com/leanprover-community/mathlib4
|
[
1097,
1
] |
Mathlib/Topology/Basic.lean
|
isOpen_sUnion
|
[] |
[
130,
37
] |
5a919533f110b7d76410134a237ee374f24eaaad
|
https://github.com/leanprover-community/mathlib4
|
[
129,
1
] |
Mathlib/RingTheory/AlgebraicIndependent.lean
|
AlgebraicIndependent.ne_zero
|
[] |
[
133,
33
] |
5a919533f110b7d76410134a237ee374f24eaaad
|
https://github.com/leanprover-community/mathlib4
|
[
132,
1
] |
Mathlib/GroupTheory/Subgroup/Basic.lean
|
Subgroup.mem_toSubmonoid
|
[] |
[
445,
10
] |
5a919533f110b7d76410134a237ee374f24eaaad
|
https://github.com/leanprover-community/mathlib4
|
[
444,
1
] |
Mathlib/Data/Finset/Basic.lean
|
Finset.Nonempty.ne_empty
|
[] |
[
570,
44
] |
5a919533f110b7d76410134a237ee374f24eaaad
|
https://github.com/leanprover-community/mathlib4
|
[
569,
1
] |
Mathlib/RingTheory/AlgebraicIndependent.lean
|
algebraicIndependent_equiv
|
[] |
[
187,
35
] |
5a919533f110b7d76410134a237ee374f24eaaad
|
https://github.com/leanprover-community/mathlib4
|
[
184,
1
] |
Mathlib/LinearAlgebra/Matrix/Adjugate.lean
|
Matrix.isRegular_of_isLeftRegular_det
|
[
{
"state_after": "case left\nm : Type u\nn : Type v\nα : Type w\ninst✝⁴ : DecidableEq n\ninst✝³ : Fintype n\ninst✝² : DecidableEq m\ninst✝¹ : Fintype m\ninst✝ : CommRing α\nA : Matrix n n α\nhA : IsLeftRegular (det A)\n⊢ IsLeftRegular A\n\ncase right\nm : Type u\nn : Type v\nα : Type w\ninst✝⁴ : DecidableEq n\ninst✝³ : Fintype n\ninst✝² : DecidableEq m\ninst✝¹ : Fintype m\ninst✝ : CommRing α\nA : Matrix n n α\nhA : IsLeftRegular (det A)\n⊢ IsRightRegular A",
"state_before": "m : Type u\nn : Type v\nα : Type w\ninst✝⁴ : DecidableEq n\ninst✝³ : Fintype n\ninst✝² : DecidableEq m\ninst✝¹ : Fintype m\ninst✝ : CommRing α\nA : Matrix n n α\nhA : IsLeftRegular (det A)\n⊢ IsRegular A",
"tactic": "constructor"
},
{
"state_after": "case left\nm : Type u\nn : Type v\nα : Type w\ninst✝⁴ : DecidableEq n\ninst✝³ : Fintype n\ninst✝² : DecidableEq m\ninst✝¹ : Fintype m\ninst✝ : CommRing α\nA : Matrix n n α\nhA : IsLeftRegular (det A)\nB C : Matrix n n α\nh : (fun x => A * x) B = (fun x => A * x) C\n⊢ B = C",
"state_before": "case left\nm : Type u\nn : Type v\nα : Type w\ninst✝⁴ : DecidableEq n\ninst✝³ : Fintype n\ninst✝² : DecidableEq m\ninst✝¹ : Fintype m\ninst✝ : CommRing α\nA : Matrix n n α\nhA : IsLeftRegular (det A)\n⊢ IsLeftRegular A",
"tactic": "intro B C h"
},
{
"state_after": "case left\nm : Type u\nn : Type v\nα : Type w\ninst✝⁴ : DecidableEq n\ninst✝³ : Fintype n\ninst✝² : DecidableEq m\ninst✝¹ : Fintype m\ninst✝ : CommRing α\nA : Matrix n n α\nhA : IsLeftRegular (det A)\nB C : Matrix n n α\nh : (fun x => A * x) B = (fun x => A * x) C\n⊢ (fun x => det A • x) B = (fun x => det A • x) C",
"state_before": "case left\nm : Type u\nn : Type v\nα : Type w\ninst✝⁴ : DecidableEq n\ninst✝³ : Fintype n\ninst✝² : DecidableEq m\ninst✝¹ : Fintype m\ninst✝ : CommRing α\nA : Matrix n n α\nhA : IsLeftRegular (det A)\nB C : Matrix n n α\nh : (fun x => A * x) B = (fun x => A * x) C\n⊢ B = C",
"tactic": "refine' hA.matrix _"
},
{
"state_after": "case left\nm : Type u\nn : Type v\nα : Type w\ninst✝⁴ : DecidableEq n\ninst✝³ : Fintype n\ninst✝² : DecidableEq m\ninst✝¹ : Fintype m\ninst✝ : CommRing α\nA : Matrix n n α\nhA : IsLeftRegular (det A)\nB C : Matrix n n α\nh : A * B = A * C\n⊢ det A • B = det A • C",
"state_before": "case left\nm : Type u\nn : Type v\nα : Type w\ninst✝⁴ : DecidableEq n\ninst✝³ : Fintype n\ninst✝² : DecidableEq m\ninst✝¹ : Fintype m\ninst✝ : CommRing α\nA : Matrix n n α\nhA : IsLeftRegular (det A)\nB C : Matrix n n α\nh : (fun x => A * x) B = (fun x => A * x) C\n⊢ (fun x => det A • x) B = (fun x => det A • x) C",
"tactic": "simp only at h ⊢"
},
{
"state_after": "no goals",
"state_before": "case left\nm : Type u\nn : Type v\nα : Type w\ninst✝⁴ : DecidableEq n\ninst✝³ : Fintype n\ninst✝² : DecidableEq m\ninst✝¹ : Fintype m\ninst✝ : CommRing α\nA : Matrix n n α\nhA : IsLeftRegular (det A)\nB C : Matrix n n α\nh : A * B = A * C\n⊢ det A • B = det A • C",
"tactic": "rw [← Matrix.one_mul B, ← Matrix.one_mul C, ← Matrix.smul_mul, ← Matrix.smul_mul, ←\n adjugate_mul, Matrix.mul_assoc, Matrix.mul_assoc, ← mul_eq_mul A, h, mul_eq_mul]"
},
{
"state_after": "case right\nm : Type u\nn : Type v\nα : Type w\ninst✝⁴ : DecidableEq n\ninst✝³ : Fintype n\ninst✝² : DecidableEq m\ninst✝¹ : Fintype m\ninst✝ : CommRing α\nA : Matrix n n α\nhA : IsLeftRegular (det A)\nB C : Matrix n n α\nh : (fun x => x * A) B = (fun x => x * A) C\n⊢ B = C",
"state_before": "case right\nm : Type u\nn : Type v\nα : Type w\ninst✝⁴ : DecidableEq n\ninst✝³ : Fintype n\ninst✝² : DecidableEq m\ninst✝¹ : Fintype m\ninst✝ : CommRing α\nA : Matrix n n α\nhA : IsLeftRegular (det A)\n⊢ IsRightRegular A",
"tactic": "intro B C h"
},
{
"state_after": "case right\nm : Type u\nn : Type v\nα : Type w\ninst✝⁴ : DecidableEq n\ninst✝³ : Fintype n\ninst✝² : DecidableEq m\ninst✝¹ : Fintype m\ninst✝ : CommRing α\nA : Matrix n n α\nhA : IsLeftRegular (det A)\nB C : Matrix n n α\nh : B ⬝ A = C ⬝ A\n⊢ B = C",
"state_before": "case right\nm : Type u\nn : Type v\nα : Type w\ninst✝⁴ : DecidableEq n\ninst✝³ : Fintype n\ninst✝² : DecidableEq m\ninst✝¹ : Fintype m\ninst✝ : CommRing α\nA : Matrix n n α\nhA : IsLeftRegular (det A)\nB C : Matrix n n α\nh : (fun x => x * A) B = (fun x => x * A) C\n⊢ B = C",
"tactic": "simp only [mul_eq_mul] at h"
},
{
"state_after": "case right\nm : Type u\nn : Type v\nα : Type w\ninst✝⁴ : DecidableEq n\ninst✝³ : Fintype n\ninst✝² : DecidableEq m\ninst✝¹ : Fintype m\ninst✝ : CommRing α\nA : Matrix n n α\nhA : IsLeftRegular (det A)\nB C : Matrix n n α\nh : B ⬝ A = C ⬝ A\n⊢ (fun x => det A • x) B = (fun x => det A • x) C",
"state_before": "case right\nm : Type u\nn : Type v\nα : Type w\ninst✝⁴ : DecidableEq n\ninst✝³ : Fintype n\ninst✝² : DecidableEq m\ninst✝¹ : Fintype m\ninst✝ : CommRing α\nA : Matrix n n α\nhA : IsLeftRegular (det A)\nB C : Matrix n n α\nh : B ⬝ A = C ⬝ A\n⊢ B = C",
"tactic": "refine' hA.matrix _"
},
{
"state_after": "case right\nm : Type u\nn : Type v\nα : Type w\ninst✝⁴ : DecidableEq n\ninst✝³ : Fintype n\ninst✝² : DecidableEq m\ninst✝¹ : Fintype m\ninst✝ : CommRing α\nA : Matrix n n α\nhA : IsLeftRegular (det A)\nB C : Matrix n n α\nh : B ⬝ A = C ⬝ A\n⊢ det A • B = det A • C",
"state_before": "case right\nm : Type u\nn : Type v\nα : Type w\ninst✝⁴ : DecidableEq n\ninst✝³ : Fintype n\ninst✝² : DecidableEq m\ninst✝¹ : Fintype m\ninst✝ : CommRing α\nA : Matrix n n α\nhA : IsLeftRegular (det A)\nB C : Matrix n n α\nh : B ⬝ A = C ⬝ A\n⊢ (fun x => det A • x) B = (fun x => det A • x) C",
"tactic": "simp only"
},
{
"state_after": "no goals",
"state_before": "case right\nm : Type u\nn : Type v\nα : Type w\ninst✝⁴ : DecidableEq n\ninst✝³ : Fintype n\ninst✝² : DecidableEq m\ninst✝¹ : Fintype m\ninst✝ : CommRing α\nA : Matrix n n α\nhA : IsLeftRegular (det A)\nB C : Matrix n n α\nh : B ⬝ A = C ⬝ A\n⊢ det A • B = det A • C",
"tactic": "rw [← Matrix.mul_one B, ← Matrix.mul_one C, ← Matrix.mul_smul, ← Matrix.mul_smul, ←\n mul_adjugate, ← Matrix.mul_assoc, ← Matrix.mul_assoc, h]"
}
] |
[
470,
63
] |
5a919533f110b7d76410134a237ee374f24eaaad
|
https://github.com/leanprover-community/mathlib4
|
[
457,
1
] |
Std/Data/List/Lemmas.lean
|
List.erase_cons_tail
|
[
{
"state_after": "no goals",
"state_before": "α : Type u_1\ninst✝ : DecidableEq α\na b : α\nl : List α\nh : b ≠ a\n⊢ List.erase (b :: l) a = b :: List.erase l a",
"tactic": "simp only [erase_cons, if_neg h]"
}
] |
[
1040,
77
] |
e68aa8f5fe47aad78987df45f99094afbcb5e936
|
https://github.com/leanprover/std4
|
[
1039,
9
] |
Mathlib/Algebra/Hom/Units.lean
|
MonoidHom.coe_toHomUnits
|
[] |
[
208,
36
] |
5a919533f110b7d76410134a237ee374f24eaaad
|
https://github.com/leanprover-community/mathlib4
|
[
207,
1
] |
Mathlib/Order/Atoms.lean
|
IsAtom.Iic
|
[] |
[
71,
96
] |
5a919533f110b7d76410134a237ee374f24eaaad
|
https://github.com/leanprover-community/mathlib4
|
[
70,
1
] |
Mathlib/Computability/Primrec.lean
|
Primrec.dom_denumerable
|
[
{
"state_after": "no goals",
"state_before": "α✝ : Type ?u.19256\nβ✝ : Type ?u.19259\nσ : Type ?u.19262\ninst✝⁴ : Primcodable α✝\ninst✝³ : Primcodable β✝\ninst✝² : Primcodable σ\nα : Type u_1\nβ : Type u_2\ninst✝¹ : Denumerable α\ninst✝ : Primcodable β\nf : α → β\nh : Primrec f\nn : ℕ\n⊢ Nat.pred (encode (Option.map f (decode n))) = encode (f (ofNat α n))",
"tactic": "simp"
},
{
"state_after": "no goals",
"state_before": "α✝ : Type ?u.19256\nβ✝ : Type ?u.19259\nσ : Type ?u.19262\ninst✝⁴ : Primcodable α✝\ninst✝³ : Primcodable β✝\ninst✝² : Primcodable σ\nα : Type u_1\nβ : Type u_2\ninst✝¹ : Denumerable α\ninst✝ : Primcodable β\nf : α → β\nh : Nat.Primrec fun n => encode (f (ofNat α n))\nn : ℕ\n⊢ Nat.succ (encode (f (ofNat α n))) = encode (Option.map f (decode n))",
"tactic": "simp"
}
] |
[
233,
54
] |
5a919533f110b7d76410134a237ee374f24eaaad
|
https://github.com/leanprover-community/mathlib4
|
[
230,
1
] |
Mathlib/Analysis/SpecialFunctions/ExpDeriv.lean
|
HasDerivAt.exp
|
[] |
[
230,
40
] |
5a919533f110b7d76410134a237ee374f24eaaad
|
https://github.com/leanprover-community/mathlib4
|
[
228,
1
] |
Mathlib/Data/Prod/Basic.lean
|
Prod.fst_swap
|
[] |
[
168,
6
] |
5a919533f110b7d76410134a237ee374f24eaaad
|
https://github.com/leanprover-community/mathlib4
|
[
167,
1
] |
Mathlib/CategoryTheory/Limits/Types.lean
|
CategoryTheory.Limits.Types.Colimit.ι_map_apply
|
[] |
[
322,
34
] |
5a919533f110b7d76410134a237ee374f24eaaad
|
https://github.com/leanprover-community/mathlib4
|
[
320,
1
] |
Mathlib/Computability/PartrecCode.lean
|
Nat.Partrec.Code.rec_prim'
|
[
{
"state_after": "α : Type u_1\nσ : Type u_2\ninst✝¹ : Primcodable α\ninst✝ : Primcodable σ\nc : α → Code\nhc : Primrec c\nz : α → σ\nhz : Primrec z\ns : α → σ\nhs : Primrec s\nl : α → σ\nhl : Primrec l\nr : α → σ\nhr : Primrec r\npr : α → Code × Code × σ × σ → σ\nhpr : Primrec₂ pr\nco : α → Code × Code × σ × σ → σ\nhco : Primrec₂ co\npc : α → Code × Code × σ × σ → σ\nhpc : Primrec₂ pc\nrf : α → Code × σ → σ\nhrf : Primrec₂ rf\nPR✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pr a (cf, cg, hf, hg)\nCO✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => co a (cf, cg, hf, hg)\nPC✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pc a (cf, cg, hf, hg)\nRF✝ : α → Code → σ → σ := fun a cf hf => rf a (cf, hf)\nF : α → Code → σ := fun a c => Code.recOn c (z a) (s a) (l a) (r a) (PR✝ a) (CO✝ a) (PC✝ a) (RF✝ a)\n⊢ Primrec fun a => F a (c a)",
"state_before": "α : Type u_1\nσ : Type u_2\ninst✝¹ : Primcodable α\ninst✝ : Primcodable σ\nc : α → Code\nhc : Primrec c\nz : α → σ\nhz : Primrec z\ns : α → σ\nhs : Primrec s\nl : α → σ\nhl : Primrec l\nr : α → σ\nhr : Primrec r\npr : α → Code × Code × σ × σ → σ\nhpr : Primrec₂ pr\nco : α → Code × Code × σ × σ → σ\nhco : Primrec₂ co\npc : α → Code × Code × σ × σ → σ\nhpc : Primrec₂ pc\nrf : α → Code × σ → σ\nhrf : Primrec₂ rf\n⊢ let PR := fun a cf cg hf hg => pr a (cf, cg, hf, hg);\n let CO := fun a cf cg hf hg => co a (cf, cg, hf, hg);\n let PC := fun a cf cg hf hg => pc a (cf, cg, hf, hg);\n let RF := fun a cf hf => rf a (cf, hf);\n let F := fun a c => Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a);\n Primrec fun a => F a (c a)",
"tactic": "intros _ _ _ _ F"
},
{
"state_after": "α : Type u_1\nσ : Type u_2\ninst✝¹ : Primcodable α\ninst✝ : Primcodable σ\nc : α → Code\nhc : Primrec c\nz : α → σ\nhz : Primrec z\ns : α → σ\nhs : Primrec s\nl : α → σ\nhl : Primrec l\nr : α → σ\nhr : Primrec r\npr : α → Code × Code × σ × σ → σ\nhpr : Primrec₂ pr\nco : α → Code × Code × σ × σ → σ\nhco : Primrec₂ co\npc : α → Code × Code × σ × σ → σ\nhpc : Primrec₂ pc\nrf : α → Code × σ → σ\nhrf : Primrec₂ rf\nPR✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pr a (cf, cg, hf, hg)\nCO✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => co a (cf, cg, hf, hg)\nPC✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pc a (cf, cg, hf, hg)\nRF✝ : α → Code → σ → σ := fun a cf hf => rf a (cf, hf)\nF : α → Code → σ := fun a c => Code.recOn c (z a) (s a) (l a) (r a) (PR✝ a) (CO✝ a) (PC✝ a) (RF✝ a)\nG₁ : (α × List σ) × ℕ × ℕ → Option σ :=\n fun p =>\n let a := p.fst.fst;\n let IH := p.fst.snd;\n let n := p.snd.fst;\n let m := p.snd.snd;\n Option.bind (List.get? IH m) fun s =>\n Option.bind (List.get? IH (unpair m).fst) fun s₁ =>\n Option.map\n (fun s₂ =>\n bif bodd n then\n bif bodd (div2 n) then rf a (ofNat Code m, s)\n else pc a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else\n bif bodd (div2 n) then co a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else pr a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂))\n (List.get? IH (unpair m).snd)\n⊢ Primrec fun a => F a (c a)",
"state_before": "α : Type u_1\nσ : Type u_2\ninst✝¹ : Primcodable α\ninst✝ : Primcodable σ\nc : α → Code\nhc : Primrec c\nz : α → σ\nhz : Primrec z\ns : α → σ\nhs : Primrec s\nl : α → σ\nhl : Primrec l\nr : α → σ\nhr : Primrec r\npr : α → Code × Code × σ × σ → σ\nhpr : Primrec₂ pr\nco : α → Code × Code × σ × σ → σ\nhco : Primrec₂ co\npc : α → Code × Code × σ × σ → σ\nhpc : Primrec₂ pc\nrf : α → Code × σ → σ\nhrf : Primrec₂ rf\nPR✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pr a (cf, cg, hf, hg)\nCO✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => co a (cf, cg, hf, hg)\nPC✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pc a (cf, cg, hf, hg)\nRF✝ : α → Code → σ → σ := fun a cf hf => rf a (cf, hf)\nF : α → Code → σ := fun a c => Code.recOn c (z a) (s a) (l a) (r a) (PR✝ a) (CO✝ a) (PC✝ a) (RF✝ a)\n⊢ Primrec fun a => F a (c a)",
"tactic": "let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p =>\n let a := p.1.1\n let IH := p.1.2\n let n := p.2.1\n let m := p.2.2\n (IH.get? m).bind fun s =>\n (IH.get? m.unpair.1).bind fun s₁ =>\n (IH.get? m.unpair.2).map fun s₂ =>\n cond n.bodd\n (cond n.div2.bodd (rf a (ofNat Code m, s))\n (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)))\n (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))\n (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)))"
},
{
"state_after": "α : Type u_1\nσ : Type u_2\ninst✝¹ : Primcodable α\ninst✝ : Primcodable σ\nc : α → Code\nhc : Primrec c\nz : α → σ\nhz : Primrec z\ns : α → σ\nhs : Primrec s\nl : α → σ\nhl : Primrec l\nr : α → σ\nhr : Primrec r\npr : α → Code × Code × σ × σ → σ\nhpr : Primrec₂ pr\nco : α → Code × Code × σ × σ → σ\nhco : Primrec₂ co\npc : α → Code × Code × σ × σ → σ\nhpc : Primrec₂ pc\nrf : α → Code × σ → σ\nhrf : Primrec₂ rf\nPR✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pr a (cf, cg, hf, hg)\nCO✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => co a (cf, cg, hf, hg)\nPC✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pc a (cf, cg, hf, hg)\nRF✝ : α → Code → σ → σ := fun a cf hf => rf a (cf, hf)\nF : α → Code → σ := fun a c => Code.recOn c (z a) (s a) (l a) (r a) (PR✝ a) (CO✝ a) (PC✝ a) (RF✝ a)\nG₁ : (α × List σ) × ℕ × ℕ → Option σ :=\n fun p =>\n let a := p.fst.fst;\n let IH := p.fst.snd;\n let n := p.snd.fst;\n let m := p.snd.snd;\n Option.bind (List.get? IH m) fun s =>\n Option.bind (List.get? IH (unpair m).fst) fun s₁ =>\n Option.map\n (fun s₂ =>\n bif bodd n then\n bif bodd (div2 n) then rf a (ofNat Code m, s)\n else pc a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else\n bif bodd (div2 n) then co a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else pr a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂))\n (List.get? IH (unpair m).snd)\nthis : Primrec G₁\n⊢ Primrec fun a => F a (c a)",
"state_before": "α : Type u_1\nσ : Type u_2\ninst✝¹ : Primcodable α\ninst✝ : Primcodable σ\nc : α → Code\nhc : Primrec c\nz : α → σ\nhz : Primrec z\ns : α → σ\nhs : Primrec s\nl : α → σ\nhl : Primrec l\nr : α → σ\nhr : Primrec r\npr : α → Code × Code × σ × σ → σ\nhpr : Primrec₂ pr\nco : α → Code × Code × σ × σ → σ\nhco : Primrec₂ co\npc : α → Code × Code × σ × σ → σ\nhpc : Primrec₂ pc\nrf : α → Code × σ → σ\nhrf : Primrec₂ rf\nPR✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pr a (cf, cg, hf, hg)\nCO✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => co a (cf, cg, hf, hg)\nPC✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pc a (cf, cg, hf, hg)\nRF✝ : α → Code → σ → σ := fun a cf hf => rf a (cf, hf)\nF : α → Code → σ := fun a c => Code.recOn c (z a) (s a) (l a) (r a) (PR✝ a) (CO✝ a) (PC✝ a) (RF✝ a)\nG₁ : (α × List σ) × ℕ × ℕ → Option σ :=\n fun p =>\n let a := p.fst.fst;\n let IH := p.fst.snd;\n let n := p.snd.fst;\n let m := p.snd.snd;\n Option.bind (List.get? IH m) fun s =>\n Option.bind (List.get? IH (unpair m).fst) fun s₁ =>\n Option.map\n (fun s₂ =>\n bif bodd n then\n bif bodd (div2 n) then rf a (ofNat Code m, s)\n else pc a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else\n bif bodd (div2 n) then co a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else pr a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂))\n (List.get? IH (unpair m).snd)\n⊢ Primrec fun a => F a (c a)",
"tactic": "have : Primrec G₁ := by\n refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _\n unfold Primrec₂\n refine'\n option_bind\n ((list_get?.comp (snd.comp fst)\n (fst.comp <| Primrec.unpair.comp (snd.comp snd))).comp fst) _\n unfold Primrec₂\n refine'\n option_map\n ((list_get?.comp (snd.comp fst)\n (snd.comp <| Primrec.unpair.comp (snd.comp snd))).comp <| fst.comp fst) _\n have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) :=\n fst.comp (fst.comp <| fst.comp <| fst.comp fst)\n have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) :=\n fst.comp (snd.comp <| fst.comp <| fst.comp fst)\n have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) :=\n snd.comp (snd.comp <| fst.comp <| fst.comp fst)\n have m₁ := fst.comp (Primrec.unpair.comp m)\n have m₂ := snd.comp (Primrec.unpair.comp m)\n have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) :=\n snd.comp (fst.comp fst)\n have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) :=\n snd.comp fst\n have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) :=\n snd\n unfold Primrec₂\n exact\n (nat_bodd.comp n).cond\n ((nat_bodd.comp <| nat_div2.comp n).cond (hrf.comp a (((Primrec.ofNat Code).comp m).pair s))\n (hpc.comp a\n (((Primrec.ofNat Code).comp m₁).pair <|\n ((Primrec.ofNat Code).comp m₂).pair <| s₁.pair s₂)))\n (Primrec.cond (nat_bodd.comp <| nat_div2.comp n)\n (hco.comp a\n (((Primrec.ofNat Code).comp m₁).pair <|\n ((Primrec.ofNat Code).comp m₂).pair <| s₁.pair s₂))\n (hpr.comp a\n (((Primrec.ofNat Code).comp m₁).pair <|\n ((Primrec.ofNat Code).comp m₂).pair <| s₁.pair s₂)))"
},
{
"state_after": "α : Type u_1\nσ : Type u_2\ninst✝¹ : Primcodable α\ninst✝ : Primcodable σ\nc : α → Code\nhc : Primrec c\nz : α → σ\nhz : Primrec z\ns : α → σ\nhs : Primrec s\nl : α → σ\nhl : Primrec l\nr : α → σ\nhr : Primrec r\npr : α → Code × Code × σ × σ → σ\nhpr : Primrec₂ pr\nco : α → Code × Code × σ × σ → σ\nhco : Primrec₂ co\npc : α → Code × Code × σ × σ → σ\nhpc : Primrec₂ pc\nrf : α → Code × σ → σ\nhrf : Primrec₂ rf\nPR✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pr a (cf, cg, hf, hg)\nCO✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => co a (cf, cg, hf, hg)\nPC✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pc a (cf, cg, hf, hg)\nRF✝ : α → Code → σ → σ := fun a cf hf => rf a (cf, hf)\nF : α → Code → σ := fun a c => Code.recOn c (z a) (s a) (l a) (r a) (PR✝ a) (CO✝ a) (PC✝ a) (RF✝ a)\nG₁ : (α × List σ) × ℕ × ℕ → Option σ :=\n fun p =>\n let a := p.fst.fst;\n let IH := p.fst.snd;\n let n := p.snd.fst;\n let m := p.snd.snd;\n Option.bind (List.get? IH m) fun s =>\n Option.bind (List.get? IH (unpair m).fst) fun s₁ =>\n Option.map\n (fun s₂ =>\n bif bodd n then\n bif bodd (div2 n) then rf a (ofNat Code m, s)\n else pc a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else\n bif bodd (div2 n) then co a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else pr a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂))\n (List.get? IH (unpair m).snd)\nthis : Primrec G₁\nG : α → List σ → Option σ :=\n fun a IH =>\n Nat.casesOn (List.length IH) (some (z a)) fun n =>\n Nat.casesOn n (some (s a)) fun n =>\n Nat.casesOn n (some (l a)) fun n => Nat.casesOn n (some (r a)) fun n => G₁ ((a, IH), n, div2 (div2 n))\n⊢ Primrec fun a => F a (c a)",
"state_before": "α : Type u_1\nσ : Type u_2\ninst✝¹ : Primcodable α\ninst✝ : Primcodable σ\nc : α → Code\nhc : Primrec c\nz : α → σ\nhz : Primrec z\ns : α → σ\nhs : Primrec s\nl : α → σ\nhl : Primrec l\nr : α → σ\nhr : Primrec r\npr : α → Code × Code × σ × σ → σ\nhpr : Primrec₂ pr\nco : α → Code × Code × σ × σ → σ\nhco : Primrec₂ co\npc : α → Code × Code × σ × σ → σ\nhpc : Primrec₂ pc\nrf : α → Code × σ → σ\nhrf : Primrec₂ rf\nPR✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pr a (cf, cg, hf, hg)\nCO✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => co a (cf, cg, hf, hg)\nPC✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pc a (cf, cg, hf, hg)\nRF✝ : α → Code → σ → σ := fun a cf hf => rf a (cf, hf)\nF : α → Code → σ := fun a c => Code.recOn c (z a) (s a) (l a) (r a) (PR✝ a) (CO✝ a) (PC✝ a) (RF✝ a)\nG₁ : (α × List σ) × ℕ × ℕ → Option σ :=\n fun p =>\n let a := p.fst.fst;\n let IH := p.fst.snd;\n let n := p.snd.fst;\n let m := p.snd.snd;\n Option.bind (List.get? IH m) fun s =>\n Option.bind (List.get? IH (unpair m).fst) fun s₁ =>\n Option.map\n (fun s₂ =>\n bif bodd n then\n bif bodd (div2 n) then rf a (ofNat Code m, s)\n else pc a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else\n bif bodd (div2 n) then co a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else pr a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂))\n (List.get? IH (unpair m).snd)\nthis : Primrec G₁\n⊢ Primrec fun a => F a (c a)",
"tactic": "let G : α → List σ → Option σ := fun a IH =>\n IH.length.casesOn (some (z a)) fun n =>\n n.casesOn (some (s a)) fun n =>\n n.casesOn (some (l a)) fun n =>\n n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2)"
},
{
"state_after": "α : Type u_1\nσ : Type u_2\ninst✝¹ : Primcodable α\ninst✝ : Primcodable σ\nc : α → Code\nhc : Primrec c\nz : α → σ\nhz : Primrec z\ns : α → σ\nhs : Primrec s\nl : α → σ\nhl : Primrec l\nr : α → σ\nhr : Primrec r\npr : α → Code × Code × σ × σ → σ\nhpr : Primrec₂ pr\nco : α → Code × Code × σ × σ → σ\nhco : Primrec₂ co\npc : α → Code × Code × σ × σ → σ\nhpc : Primrec₂ pc\nrf : α → Code × σ → σ\nhrf : Primrec₂ rf\nPR✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pr a (cf, cg, hf, hg)\nCO✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => co a (cf, cg, hf, hg)\nPC✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pc a (cf, cg, hf, hg)\nRF✝ : α → Code → σ → σ := fun a cf hf => rf a (cf, hf)\nF : α → Code → σ := fun a c => Code.recOn c (z a) (s a) (l a) (r a) (PR✝ a) (CO✝ a) (PC✝ a) (RF✝ a)\nG₁ : (α × List σ) × ℕ × ℕ → Option σ :=\n fun p =>\n let a := p.fst.fst;\n let IH := p.fst.snd;\n let n := p.snd.fst;\n let m := p.snd.snd;\n Option.bind (List.get? IH m) fun s =>\n Option.bind (List.get? IH (unpair m).fst) fun s₁ =>\n Option.map\n (fun s₂ =>\n bif bodd n then\n bif bodd (div2 n) then rf a (ofNat Code m, s)\n else pc a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else\n bif bodd (div2 n) then co a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else pr a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂))\n (List.get? IH (unpair m).snd)\nthis✝ : Primrec G₁\nG : α → List σ → Option σ :=\n fun a IH =>\n Nat.casesOn (List.length IH) (some (z a)) fun n =>\n Nat.casesOn n (some (s a)) fun n =>\n Nat.casesOn n (some (l a)) fun n => Nat.casesOn n (some (r a)) fun n => G₁ ((a, IH), n, div2 (div2 n))\nthis : Primrec₂ G\n⊢ Primrec fun a => F a (c a)",
"state_before": "α : Type u_1\nσ : Type u_2\ninst✝¹ : Primcodable α\ninst✝ : Primcodable σ\nc : α → Code\nhc : Primrec c\nz : α → σ\nhz : Primrec z\ns : α → σ\nhs : Primrec s\nl : α → σ\nhl : Primrec l\nr : α → σ\nhr : Primrec r\npr : α → Code × Code × σ × σ → σ\nhpr : Primrec₂ pr\nco : α → Code × Code × σ × σ → σ\nhco : Primrec₂ co\npc : α → Code × Code × σ × σ → σ\nhpc : Primrec₂ pc\nrf : α → Code × σ → σ\nhrf : Primrec₂ rf\nPR✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pr a (cf, cg, hf, hg)\nCO✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => co a (cf, cg, hf, hg)\nPC✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pc a (cf, cg, hf, hg)\nRF✝ : α → Code → σ → σ := fun a cf hf => rf a (cf, hf)\nF : α → Code → σ := fun a c => Code.recOn c (z a) (s a) (l a) (r a) (PR✝ a) (CO✝ a) (PC✝ a) (RF✝ a)\nG₁ : (α × List σ) × ℕ × ℕ → Option σ :=\n fun p =>\n let a := p.fst.fst;\n let IH := p.fst.snd;\n let n := p.snd.fst;\n let m := p.snd.snd;\n Option.bind (List.get? IH m) fun s =>\n Option.bind (List.get? IH (unpair m).fst) fun s₁ =>\n Option.map\n (fun s₂ =>\n bif bodd n then\n bif bodd (div2 n) then rf a (ofNat Code m, s)\n else pc a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else\n bif bodd (div2 n) then co a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else pr a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂))\n (List.get? IH (unpair m).snd)\nthis : Primrec G₁\nG : α → List σ → Option σ :=\n fun a IH =>\n Nat.casesOn (List.length IH) (some (z a)) fun n =>\n Nat.casesOn n (some (s a)) fun n =>\n Nat.casesOn n (some (l a)) fun n => Nat.casesOn n (some (r a)) fun n => G₁ ((a, IH), n, div2 (div2 n))\n⊢ Primrec fun a => F a (c a)",
"tactic": "have : Primrec₂ G := by\n unfold Primrec₂\n refine nat_casesOn\n (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_\n unfold Primrec₂\n refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_\n unfold Primrec₂\n refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <| fst.comp fst))) ?_\n unfold Primrec₂\n refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <| fst.comp <| fst.comp fst))) ?_\n unfold Primrec₂\n exact this.comp <|\n ((fst.pair snd).comp <| fst.comp <| fst.comp <| fst.comp <| fst).pair <|\n snd.pair <| nat_div2.comp <| nat_div2.comp snd"
},
{
"state_after": "α : Type u_1\nσ : Type u_2\ninst✝¹ : Primcodable α\ninst✝ : Primcodable σ\nc : α → Code\nhc : Primrec c\nz : α → σ\nhz : Primrec z\ns : α → σ\nhs : Primrec s\nl : α → σ\nhl : Primrec l\nr : α → σ\nhr : Primrec r\npr : α → Code × Code × σ × σ → σ\nhpr : Primrec₂ pr\nco : α → Code × Code × σ × σ → σ\nhco : Primrec₂ co\npc : α → Code × Code × σ × σ → σ\nhpc : Primrec₂ pc\nrf : α → Code × σ → σ\nhrf : Primrec₂ rf\nPR✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pr a (cf, cg, hf, hg)\nCO✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => co a (cf, cg, hf, hg)\nPC✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pc a (cf, cg, hf, hg)\nRF✝ : α → Code → σ → σ := fun a cf hf => rf a (cf, hf)\nF : α → Code → σ := fun a c => Code.recOn c (z a) (s a) (l a) (r a) (PR✝ a) (CO✝ a) (PC✝ a) (RF✝ a)\nG₁ : (α × List σ) × ℕ × ℕ → Option σ :=\n fun p =>\n let a := p.fst.fst;\n let IH := p.fst.snd;\n let n := p.snd.fst;\n let m := p.snd.snd;\n Option.bind (List.get? IH m) fun s =>\n Option.bind (List.get? IH (unpair m).fst) fun s₁ =>\n Option.map\n (fun s₂ =>\n bif bodd n then\n bif bodd (div2 n) then rf a (ofNat Code m, s)\n else pc a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else\n bif bodd (div2 n) then co a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else pr a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂))\n (List.get? IH (unpair m).snd)\nthis✝ : Primrec G₁\nG : α → List σ → Option σ :=\n fun a IH =>\n Nat.casesOn (List.length IH) (some (z a)) fun n =>\n Nat.casesOn n (some (s a)) fun n =>\n Nat.casesOn n (some (l a)) fun n => Nat.casesOn n (some (r a)) fun n => G₁ ((a, IH), n, div2 (div2 n))\nthis : Primrec₂ G\na : α\nn : ℕ\n⊢ G (a, List.map ((fun a n => F a (ofNat Code n)) a) (List.range n)).fst\n (a, List.map ((fun a n => F a (ofNat Code n)) a) (List.range n)).snd =\n some ((fun a n => F a (ofNat Code n)) a n)",
"state_before": "α : Type u_1\nσ : Type u_2\ninst✝¹ : Primcodable α\ninst✝ : Primcodable σ\nc : α → Code\nhc : Primrec c\nz : α → σ\nhz : Primrec z\ns : α → σ\nhs : Primrec s\nl : α → σ\nhl : Primrec l\nr : α → σ\nhr : Primrec r\npr : α → Code × Code × σ × σ → σ\nhpr : Primrec₂ pr\nco : α → Code × Code × σ × σ → σ\nhco : Primrec₂ co\npc : α → Code × Code × σ × σ → σ\nhpc : Primrec₂ pc\nrf : α → Code × σ → σ\nhrf : Primrec₂ rf\nPR✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pr a (cf, cg, hf, hg)\nCO✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => co a (cf, cg, hf, hg)\nPC✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pc a (cf, cg, hf, hg)\nRF✝ : α → Code → σ → σ := fun a cf hf => rf a (cf, hf)\nF : α → Code → σ := fun a c => Code.recOn c (z a) (s a) (l a) (r a) (PR✝ a) (CO✝ a) (PC✝ a) (RF✝ a)\nG₁ : (α × List σ) × ℕ × ℕ → Option σ :=\n fun p =>\n let a := p.fst.fst;\n let IH := p.fst.snd;\n let n := p.snd.fst;\n let m := p.snd.snd;\n Option.bind (List.get? IH m) fun s =>\n Option.bind (List.get? IH (unpair m).fst) fun s₁ =>\n Option.map\n (fun s₂ =>\n bif bodd n then\n bif bodd (div2 n) then rf a (ofNat Code m, s)\n else pc a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else\n bif bodd (div2 n) then co a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else pr a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂))\n (List.get? IH (unpair m).snd)\nthis✝ : Primrec G₁\nG : α → List σ → Option σ :=\n fun a IH =>\n Nat.casesOn (List.length IH) (some (z a)) fun n =>\n Nat.casesOn n (some (s a)) fun n =>\n Nat.casesOn n (some (l a)) fun n => Nat.casesOn n (some (r a)) fun n => G₁ ((a, IH), n, div2 (div2 n))\nthis : Primrec₂ G\n⊢ Primrec fun a => F a (c a)",
"tactic": "refine'\n ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp\n _root_.Primrec.id <| encode_iff.2 hc).of_eq fun a => by simp"
},
{
"state_after": "α : Type u_1\nσ : Type u_2\ninst✝¹ : Primcodable α\ninst✝ : Primcodable σ\nc : α → Code\nhc : Primrec c\nz : α → σ\nhz : Primrec z\ns : α → σ\nhs : Primrec s\nl : α → σ\nhl : Primrec l\nr : α → σ\nhr : Primrec r\npr : α → Code × Code × σ × σ → σ\nhpr : Primrec₂ pr\nco : α → Code × Code × σ × σ → σ\nhco : Primrec₂ co\npc : α → Code × Code × σ × σ → σ\nhpc : Primrec₂ pc\nrf : α → Code × σ → σ\nhrf : Primrec₂ rf\nPR✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pr a (cf, cg, hf, hg)\nCO✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => co a (cf, cg, hf, hg)\nPC✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pc a (cf, cg, hf, hg)\nRF✝ : α → Code → σ → σ := fun a cf hf => rf a (cf, hf)\nF : α → Code → σ := fun a c => Code.recOn c (z a) (s a) (l a) (r a) (PR✝ a) (CO✝ a) (PC✝ a) (RF✝ a)\nG₁ : (α × List σ) × ℕ × ℕ → Option σ :=\n fun p =>\n let a := p.fst.fst;\n let IH := p.fst.snd;\n let n := p.snd.fst;\n let m := p.snd.snd;\n Option.bind (List.get? IH m) fun s =>\n Option.bind (List.get? IH (unpair m).fst) fun s₁ =>\n Option.map\n (fun s₂ =>\n bif bodd n then\n bif bodd (div2 n) then rf a (ofNat Code m, s)\n else pc a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else\n bif bodd (div2 n) then co a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else pr a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂))\n (List.get? IH (unpair m).snd)\nthis✝ : Primrec G₁\nG : α → List σ → Option σ :=\n fun a IH =>\n Nat.casesOn (List.length IH) (some (z a)) fun n =>\n Nat.casesOn n (some (s a)) fun n =>\n Nat.casesOn n (some (l a)) fun n => Nat.casesOn n (some (r a)) fun n => G₁ ((a, IH), n, div2 (div2 n))\nthis : Primrec₂ G\na : α\nn : ℕ\n⊢ G a (List.map (fun n => F a (ofNat Code n)) (List.range n)) = some (F a (ofNat Code n))",
"state_before": "α : Type u_1\nσ : Type u_2\ninst✝¹ : Primcodable α\ninst✝ : Primcodable σ\nc : α → Code\nhc : Primrec c\nz : α → σ\nhz : Primrec z\ns : α → σ\nhs : Primrec s\nl : α → σ\nhl : Primrec l\nr : α → σ\nhr : Primrec r\npr : α → Code × Code × σ × σ → σ\nhpr : Primrec₂ pr\nco : α → Code × Code × σ × σ → σ\nhco : Primrec₂ co\npc : α → Code × Code × σ × σ → σ\nhpc : Primrec₂ pc\nrf : α → Code × σ → σ\nhrf : Primrec₂ rf\nPR✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pr a (cf, cg, hf, hg)\nCO✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => co a (cf, cg, hf, hg)\nPC✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pc a (cf, cg, hf, hg)\nRF✝ : α → Code → σ → σ := fun a cf hf => rf a (cf, hf)\nF : α → Code → σ := fun a c => Code.recOn c (z a) (s a) (l a) (r a) (PR✝ a) (CO✝ a) (PC✝ a) (RF✝ a)\nG₁ : (α × List σ) × ℕ × ℕ → Option σ :=\n fun p =>\n let a := p.fst.fst;\n let IH := p.fst.snd;\n let n := p.snd.fst;\n let m := p.snd.snd;\n Option.bind (List.get? IH m) fun s =>\n Option.bind (List.get? IH (unpair m).fst) fun s₁ =>\n Option.map\n (fun s₂ =>\n bif bodd n then\n bif bodd (div2 n) then rf a (ofNat Code m, s)\n else pc a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else\n bif bodd (div2 n) then co a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else pr a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂))\n (List.get? IH (unpair m).snd)\nthis✝ : Primrec G₁\nG : α → List σ → Option σ :=\n fun a IH =>\n Nat.casesOn (List.length IH) (some (z a)) fun n =>\n Nat.casesOn n (some (s a)) fun n =>\n Nat.casesOn n (some (l a)) fun n => Nat.casesOn n (some (r a)) fun n => G₁ ((a, IH), n, div2 (div2 n))\nthis : Primrec₂ G\na : α\nn : ℕ\n⊢ G (a, List.map ((fun a n => F a (ofNat Code n)) a) (List.range n)).fst\n (a, List.map ((fun a n => F a (ofNat Code n)) a) (List.range n)).snd =\n some ((fun a n => F a (ofNat Code n)) a n)",
"tactic": "simp (config := { zeta := false })"
},
{
"state_after": "case succ.succ.succ.succ\nα : Type u_1\nσ : Type u_2\ninst✝¹ : Primcodable α\ninst✝ : Primcodable σ\nc : α → Code\nhc : Primrec c\nz : α → σ\nhz : Primrec z\ns : α → σ\nhs : Primrec s\nl : α → σ\nhl : Primrec l\nr : α → σ\nhr : Primrec r\npr : α → Code × Code × σ × σ → σ\nhpr : Primrec₂ pr\nco : α → Code × Code × σ × σ → σ\nhco : Primrec₂ co\npc : α → Code × Code × σ × σ → σ\nhpc : Primrec₂ pc\nrf : α → Code × σ → σ\nhrf : Primrec₂ rf\nPR✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pr a (cf, cg, hf, hg)\nCO✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => co a (cf, cg, hf, hg)\nPC✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pc a (cf, cg, hf, hg)\nRF✝ : α → Code → σ → σ := fun a cf hf => rf a (cf, hf)\nF : α → Code → σ := fun a c => Code.recOn c (z a) (s a) (l a) (r a) (PR✝ a) (CO✝ a) (PC✝ a) (RF✝ a)\nG₁ : (α × List σ) × ℕ × ℕ → Option σ :=\n fun p =>\n let a := p.fst.fst;\n let IH := p.fst.snd;\n let n := p.snd.fst;\n let m := p.snd.snd;\n Option.bind (List.get? IH m) fun s =>\n Option.bind (List.get? IH (unpair m).fst) fun s₁ =>\n Option.map\n (fun s₂ =>\n bif bodd n then\n bif bodd (div2 n) then rf a (ofNat Code m, s)\n else pc a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else\n bif bodd (div2 n) then co a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else pr a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂))\n (List.get? IH (unpair m).snd)\nthis✝ : Primrec G₁\nG : α → List σ → Option σ :=\n fun a IH =>\n Nat.casesOn (List.length IH) (some (z a)) fun n =>\n Nat.casesOn n (some (s a)) fun n =>\n Nat.casesOn n (some (l a)) fun n => Nat.casesOn n (some (r a)) fun n => G₁ ((a, IH), n, div2 (div2 n))\nthis : Primrec₂ G\na : α\nn : ℕ\n⊢ Nat.rec (some (z a))\n (fun n_1 n_ih =>\n Nat.rec (some (s a))\n (fun n_2 n_ih =>\n Nat.rec (some (l a))\n (fun n_3 n_ih =>\n Nat.rec (some (r a))\n (fun n_4 n_ih =>\n Option.bind\n (List.get?\n (List.map\n (fun n =>\n rec (z a) (s a) (l a) (r a) (fun cf cg hf hg => pr a (cf, cg, hf, hg))\n (fun cf cg hf hg => co a (cf, cg, hf, hg)) (fun cf cg hf hg => pc a (cf, cg, hf, hg))\n (fun cf hf => rf a (cf, hf)) (ofNat Code n))\n (List.range (Nat.succ (Nat.succ (Nat.succ (Nat.succ n))))))\n (div2 (div2 n_4)))\n fun s_1 =>\n Option.bind\n (List.get?\n (List.map\n (fun n =>\n rec (z a) (s a) (l a) (r a) (fun cf cg hf hg => pr a (cf, cg, hf, hg))\n (fun cf cg hf hg => co a (cf, cg, hf, hg)) (fun cf cg hf hg => pc a (cf, cg, hf, hg))\n (fun cf hf => rf a (cf, hf)) (ofNat Code n))\n (List.range (Nat.succ (Nat.succ (Nat.succ (Nat.succ n))))))\n (unpair (div2 (div2 n_4))).fst)\n fun s₁ =>\n Option.map\n (fun s₂ =>\n bif bodd n_4 then\n bif bodd (div2 n_4) then rf a (ofNat Code (div2 (div2 n_4)), s_1)\n else\n pc a\n (ofNat Code (unpair (div2 (div2 n_4))).fst, ofNat Code (unpair (div2 (div2 n_4))).snd,\n s₁, s₂)\n else\n bif bodd (div2 n_4) then\n co a\n (ofNat Code (unpair (div2 (div2 n_4))).fst, ofNat Code (unpair (div2 (div2 n_4))).snd,\n s₁, s₂)\n else\n pr a\n (ofNat Code (unpair (div2 (div2 n_4))).fst, ofNat Code (unpair (div2 (div2 n_4))).snd,\n s₁, s₂))\n (List.get?\n (List.map\n (fun n =>\n rec (z a) (s a) (l a) (r a) (fun cf cg hf hg => pr a (cf, cg, hf, hg))\n (fun cf cg hf hg => co a (cf, cg, hf, hg)) (fun cf cg hf hg => pc a (cf, cg, hf, hg))\n (fun cf hf => rf a (cf, hf)) (ofNat Code n))\n (List.range (Nat.succ (Nat.succ (Nat.succ (Nat.succ n))))))\n (unpair (div2 (div2 n_4))).snd))\n n_3)\n n_2)\n n_1)\n (List.length\n (List.map\n (fun n =>\n rec (z a) (s a) (l a) (r a) (fun cf cg hf hg => pr a (cf, cg, hf, hg))\n (fun cf cg hf hg => co a (cf, cg, hf, hg)) (fun cf cg hf hg => pc a (cf, cg, hf, hg))\n (fun cf hf => rf a (cf, hf)) (ofNat Code n))\n (List.range (Nat.succ (Nat.succ (Nat.succ (Nat.succ n))))))) =\n some\n (rec (z a) (s a) (l a) (r a) (fun cf cg hf hg => pr a (cf, cg, hf, hg)) (fun cf cg hf hg => co a (cf, cg, hf, hg))\n (fun cf cg hf hg => pc a (cf, cg, hf, hg)) (fun cf hf => rf a (cf, hf))\n (ofNat Code (Nat.succ (Nat.succ (Nat.succ (Nat.succ n))))))",
"state_before": "case succ.succ.succ.succ\nα : Type u_1\nσ : Type u_2\ninst✝¹ : Primcodable α\ninst✝ : Primcodable σ\nc : α → Code\nhc : Primrec c\nz : α → σ\nhz : Primrec z\ns : α → σ\nhs : Primrec s\nl : α → σ\nhl : Primrec l\nr : α → σ\nhr : Primrec r\npr : α → Code × Code × σ × σ → σ\nhpr : Primrec₂ pr\nco : α → Code × Code × σ × σ → σ\nhco : Primrec₂ co\npc : α → Code × Code × σ × σ → σ\nhpc : Primrec₂ pc\nrf : α → Code × σ → σ\nhrf : Primrec₂ rf\nPR✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pr a (cf, cg, hf, hg)\nCO✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => co a (cf, cg, hf, hg)\nPC✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pc a (cf, cg, hf, hg)\nRF✝ : α → Code → σ → σ := fun a cf hf => rf a (cf, hf)\nF : α → Code → σ := fun a c => Code.recOn c (z a) (s a) (l a) (r a) (PR✝ a) (CO✝ a) (PC✝ a) (RF✝ a)\nG₁ : (α × List σ) × ℕ × ℕ → Option σ :=\n fun p =>\n let a := p.fst.fst;\n let IH := p.fst.snd;\n let n := p.snd.fst;\n let m := p.snd.snd;\n Option.bind (List.get? IH m) fun s =>\n Option.bind (List.get? IH (unpair m).fst) fun s₁ =>\n Option.map\n (fun s₂ =>\n bif bodd n then\n bif bodd (div2 n) then rf a (ofNat Code m, s)\n else pc a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else\n bif bodd (div2 n) then co a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else pr a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂))\n (List.get? IH (unpair m).snd)\nthis✝ : Primrec G₁\nG : α → List σ → Option σ :=\n fun a IH =>\n Nat.casesOn (List.length IH) (some (z a)) fun n =>\n Nat.casesOn n (some (s a)) fun n =>\n Nat.casesOn n (some (l a)) fun n => Nat.casesOn n (some (r a)) fun n => G₁ ((a, IH), n, div2 (div2 n))\nthis : Primrec₂ G\na : α\nn : ℕ\n⊢ G a (List.map (fun n => F a (ofNat Code n)) (List.range (Nat.succ (Nat.succ (Nat.succ (Nat.succ n)))))) =\n some (F a (ofNat Code (Nat.succ (Nat.succ (Nat.succ (Nat.succ n))))))",
"tactic": "simp only []"
},
{
"state_after": "case succ.succ.succ.succ\nα : Type u_1\nσ : Type u_2\ninst✝¹ : Primcodable α\ninst✝ : Primcodable σ\nc : α → Code\nhc : Primrec c\nz : α → σ\nhz : Primrec z\ns : α → σ\nhs : Primrec s\nl : α → σ\nhl : Primrec l\nr : α → σ\nhr : Primrec r\npr : α → Code × Code × σ × σ → σ\nhpr : Primrec₂ pr\nco : α → Code × Code × σ × σ → σ\nhco : Primrec₂ co\npc : α → Code × Code × σ × σ → σ\nhpc : Primrec₂ pc\nrf : α → Code × σ → σ\nhrf : Primrec₂ rf\nPR✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pr a (cf, cg, hf, hg)\nCO✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => co a (cf, cg, hf, hg)\nPC✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pc a (cf, cg, hf, hg)\nRF✝ : α → Code → σ → σ := fun a cf hf => rf a (cf, hf)\nF : α → Code → σ := fun a c => Code.recOn c (z a) (s a) (l a) (r a) (PR✝ a) (CO✝ a) (PC✝ a) (RF✝ a)\nG₁ : (α × List σ) × ℕ × ℕ → Option σ :=\n fun p =>\n let a := p.fst.fst;\n let IH := p.fst.snd;\n let n := p.snd.fst;\n let m := p.snd.snd;\n Option.bind (List.get? IH m) fun s =>\n Option.bind (List.get? IH (unpair m).fst) fun s₁ =>\n Option.map\n (fun s₂ =>\n bif bodd n then\n bif bodd (div2 n) then rf a (ofNat Code m, s)\n else pc a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else\n bif bodd (div2 n) then co a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else pr a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂))\n (List.get? IH (unpair m).snd)\nthis✝ : Primrec G₁\nG : α → List σ → Option σ :=\n fun a IH =>\n Nat.casesOn (List.length IH) (some (z a)) fun n =>\n Nat.casesOn n (some (s a)) fun n =>\n Nat.casesOn n (some (l a)) fun n => Nat.casesOn n (some (r a)) fun n => G₁ ((a, IH), n, div2 (div2 n))\nthis : Primrec₂ G\na : α\nn : ℕ\n⊢ Nat.rec (some (z a))\n (fun n_1 n_ih =>\n Nat.rec (some (s a))\n (fun n_2 n_ih =>\n Nat.rec (some (l a))\n (fun n_3 n_ih =>\n Nat.rec (some (r a))\n (fun n_4 n_ih =>\n Option.bind\n (List.get?\n (List.map\n (fun n =>\n rec (z a) (s a) (l a) (r a) (fun cf cg hf hg => pr a (cf, cg, hf, hg))\n (fun cf cg hf hg => co a (cf, cg, hf, hg)) (fun cf cg hf hg => pc a (cf, cg, hf, hg))\n (fun cf hf => rf a (cf, hf)) (ofNat Code n))\n (List.range (Nat.succ (Nat.succ (Nat.succ (Nat.succ n))))))\n (div2 (div2 n_4)))\n fun s_1 =>\n Option.bind\n (List.get?\n (List.map\n (fun n =>\n rec (z a) (s a) (l a) (r a) (fun cf cg hf hg => pr a (cf, cg, hf, hg))\n (fun cf cg hf hg => co a (cf, cg, hf, hg)) (fun cf cg hf hg => pc a (cf, cg, hf, hg))\n (fun cf hf => rf a (cf, hf)) (ofNat Code n))\n (List.range (Nat.succ (Nat.succ (Nat.succ (Nat.succ n))))))\n (unpair (div2 (div2 n_4))).fst)\n fun s₁ =>\n Option.map\n (fun s₂ =>\n bif bodd n_4 then\n bif bodd (div2 n_4) then rf a (ofNat Code (div2 (div2 n_4)), s_1)\n else\n pc a\n (ofNat Code (unpair (div2 (div2 n_4))).fst, ofNat Code (unpair (div2 (div2 n_4))).snd,\n s₁, s₂)\n else\n bif bodd (div2 n_4) then\n co a\n (ofNat Code (unpair (div2 (div2 n_4))).fst, ofNat Code (unpair (div2 (div2 n_4))).snd,\n s₁, s₂)\n else\n pr a\n (ofNat Code (unpair (div2 (div2 n_4))).fst, ofNat Code (unpair (div2 (div2 n_4))).snd,\n s₁, s₂))\n (List.get?\n (List.map\n (fun n =>\n rec (z a) (s a) (l a) (r a) (fun cf cg hf hg => pr a (cf, cg, hf, hg))\n (fun cf cg hf hg => co a (cf, cg, hf, hg)) (fun cf cg hf hg => pc a (cf, cg, hf, hg))\n (fun cf hf => rf a (cf, hf)) (ofNat Code n))\n (List.range (Nat.succ (Nat.succ (Nat.succ (Nat.succ n))))))\n (unpair (div2 (div2 n_4))).snd))\n n_3)\n n_2)\n n_1)\n (Nat.succ (Nat.succ (Nat.succ (Nat.succ n)))) =\n some\n (rec (z a) (s a) (l a) (r a) (fun cf cg hf hg => pr a (cf, cg, hf, hg)) (fun cf cg hf hg => co a (cf, cg, hf, hg))\n (fun cf cg hf hg => pc a (cf, cg, hf, hg)) (fun cf hf => rf a (cf, hf))\n (ofNat Code (Nat.succ (Nat.succ (Nat.succ (Nat.succ n))))))",
"state_before": "case succ.succ.succ.succ\nα : Type u_1\nσ : Type u_2\ninst✝¹ : Primcodable α\ninst✝ : Primcodable σ\nc : α → Code\nhc : Primrec c\nz : α → σ\nhz : Primrec z\ns : α → σ\nhs : Primrec s\nl : α → σ\nhl : Primrec l\nr : α → σ\nhr : Primrec r\npr : α → Code × Code × σ × σ → σ\nhpr : Primrec₂ pr\nco : α → Code × Code × σ × σ → σ\nhco : Primrec₂ co\npc : α → Code × Code × σ × σ → σ\nhpc : Primrec₂ pc\nrf : α → Code × σ → σ\nhrf : Primrec₂ rf\nPR✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pr a (cf, cg, hf, hg)\nCO✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => co a (cf, cg, hf, hg)\nPC✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pc a (cf, cg, hf, hg)\nRF✝ : α → Code → σ → σ := fun a cf hf => rf a (cf, hf)\nF : α → Code → σ := fun a c => Code.recOn c (z a) (s a) (l a) (r a) (PR✝ a) (CO✝ a) (PC✝ a) (RF✝ a)\nG₁ : (α × List σ) × ℕ × ℕ → Option σ :=\n fun p =>\n let a := p.fst.fst;\n let IH := p.fst.snd;\n let n := p.snd.fst;\n let m := p.snd.snd;\n Option.bind (List.get? IH m) fun s =>\n Option.bind (List.get? IH (unpair m).fst) fun s₁ =>\n Option.map\n (fun s₂ =>\n bif bodd n then\n bif bodd (div2 n) then rf a (ofNat Code m, s)\n else pc a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else\n bif bodd (div2 n) then co a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else pr a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂))\n (List.get? IH (unpair m).snd)\nthis✝ : Primrec G₁\nG : α → List σ → Option σ :=\n fun a IH =>\n Nat.casesOn (List.length IH) (some (z a)) fun n =>\n Nat.casesOn n (some (s a)) fun n =>\n Nat.casesOn n (some (l a)) fun n => Nat.casesOn n (some (r a)) fun n => G₁ ((a, IH), n, div2 (div2 n))\nthis : Primrec₂ G\na : α\nn : ℕ\n⊢ Nat.rec (some (z a))\n (fun n_1 n_ih =>\n Nat.rec (some (s a))\n (fun n_2 n_ih =>\n Nat.rec (some (l a))\n (fun n_3 n_ih =>\n Nat.rec (some (r a))\n (fun n_4 n_ih =>\n Option.bind\n (List.get?\n (List.map\n (fun n =>\n rec (z a) (s a) (l a) (r a) (fun cf cg hf hg => pr a (cf, cg, hf, hg))\n (fun cf cg hf hg => co a (cf, cg, hf, hg)) (fun cf cg hf hg => pc a (cf, cg, hf, hg))\n (fun cf hf => rf a (cf, hf)) (ofNat Code n))\n (List.range (Nat.succ (Nat.succ (Nat.succ (Nat.succ n))))))\n (div2 (div2 n_4)))\n fun s_1 =>\n Option.bind\n (List.get?\n (List.map\n (fun n =>\n rec (z a) (s a) (l a) (r a) (fun cf cg hf hg => pr a (cf, cg, hf, hg))\n (fun cf cg hf hg => co a (cf, cg, hf, hg)) (fun cf cg hf hg => pc a (cf, cg, hf, hg))\n (fun cf hf => rf a (cf, hf)) (ofNat Code n))\n (List.range (Nat.succ (Nat.succ (Nat.succ (Nat.succ n))))))\n (unpair (div2 (div2 n_4))).fst)\n fun s₁ =>\n Option.map\n (fun s₂ =>\n bif bodd n_4 then\n bif bodd (div2 n_4) then rf a (ofNat Code (div2 (div2 n_4)), s_1)\n else\n pc a\n (ofNat Code (unpair (div2 (div2 n_4))).fst, ofNat Code (unpair (div2 (div2 n_4))).snd,\n s₁, s₂)\n else\n bif bodd (div2 n_4) then\n co a\n (ofNat Code (unpair (div2 (div2 n_4))).fst, ofNat Code (unpair (div2 (div2 n_4))).snd,\n s₁, s₂)\n else\n pr a\n (ofNat Code (unpair (div2 (div2 n_4))).fst, ofNat Code (unpair (div2 (div2 n_4))).snd,\n s₁, s₂))\n (List.get?\n (List.map\n (fun n =>\n rec (z a) (s a) (l a) (r a) (fun cf cg hf hg => pr a (cf, cg, hf, hg))\n (fun cf cg hf hg => co a (cf, cg, hf, hg)) (fun cf cg hf hg => pc a (cf, cg, hf, hg))\n (fun cf hf => rf a (cf, hf)) (ofNat Code n))\n (List.range (Nat.succ (Nat.succ (Nat.succ (Nat.succ n))))))\n (unpair (div2 (div2 n_4))).snd))\n n_3)\n n_2)\n n_1)\n (List.length\n (List.map\n (fun n =>\n rec (z a) (s a) (l a) (r a) (fun cf cg hf hg => pr a (cf, cg, hf, hg))\n (fun cf cg hf hg => co a (cf, cg, hf, hg)) (fun cf cg hf hg => pc a (cf, cg, hf, hg))\n (fun cf hf => rf a (cf, hf)) (ofNat Code n))\n (List.range (Nat.succ (Nat.succ (Nat.succ (Nat.succ n))))))) =\n some\n (rec (z a) (s a) (l a) (r a) (fun cf cg hf hg => pr a (cf, cg, hf, hg)) (fun cf cg hf hg => co a (cf, cg, hf, hg))\n (fun cf cg hf hg => pc a (cf, cg, hf, hg)) (fun cf hf => rf a (cf, hf))\n (ofNat Code (Nat.succ (Nat.succ (Nat.succ (Nat.succ n))))))",
"tactic": "rw [List.length_map, List.length_range]"
},
{
"state_after": "case succ.succ.succ.succ\nα : Type u_1\nσ : Type u_2\ninst✝¹ : Primcodable α\ninst✝ : Primcodable σ\nc : α → Code\nhc : Primrec c\nz : α → σ\nhz : Primrec z\ns : α → σ\nhs : Primrec s\nl : α → σ\nhl : Primrec l\nr : α → σ\nhr : Primrec r\npr : α → Code × Code × σ × σ → σ\nhpr : Primrec₂ pr\nco : α → Code × Code × σ × σ → σ\nhco : Primrec₂ co\npc : α → Code × Code × σ × σ → σ\nhpc : Primrec₂ pc\nrf : α → Code × σ → σ\nhrf : Primrec₂ rf\nPR✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pr a (cf, cg, hf, hg)\nCO✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => co a (cf, cg, hf, hg)\nPC✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pc a (cf, cg, hf, hg)\nRF✝ : α → Code → σ → σ := fun a cf hf => rf a (cf, hf)\nF : α → Code → σ := fun a c => Code.recOn c (z a) (s a) (l a) (r a) (PR✝ a) (CO✝ a) (PC✝ a) (RF✝ a)\nG₁ : (α × List σ) × ℕ × ℕ → Option σ :=\n fun p =>\n let a := p.fst.fst;\n let IH := p.fst.snd;\n let n := p.snd.fst;\n let m := p.snd.snd;\n Option.bind (List.get? IH m) fun s =>\n Option.bind (List.get? IH (unpair m).fst) fun s₁ =>\n Option.map\n (fun s₂ =>\n bif bodd n then\n bif bodd (div2 n) then rf a (ofNat Code m, s)\n else pc a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else\n bif bodd (div2 n) then co a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else pr a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂))\n (List.get? IH (unpair m).snd)\nthis✝ : Primrec G₁\nG : α → List σ → Option σ :=\n fun a IH =>\n Nat.casesOn (List.length IH) (some (z a)) fun n =>\n Nat.casesOn n (some (s a)) fun n =>\n Nat.casesOn n (some (l a)) fun n => Nat.casesOn n (some (r a)) fun n => G₁ ((a, IH), n, div2 (div2 n))\nthis : Primrec₂ G\na : α\nn : ℕ\nm : ℕ := div2 (div2 n)\n⊢ Nat.rec (some (z a))\n (fun n_1 n_ih =>\n Nat.rec (some (s a))\n (fun n_2 n_ih =>\n Nat.rec (some (l a))\n (fun n_3 n_ih =>\n Nat.rec (some (r a))\n (fun n_4 n_ih =>\n Option.bind\n (List.get?\n (List.map\n (fun n =>\n rec (z a) (s a) (l a) (r a) (fun cf cg hf hg => pr a (cf, cg, hf, hg))\n (fun cf cg hf hg => co a (cf, cg, hf, hg)) (fun cf cg hf hg => pc a (cf, cg, hf, hg))\n (fun cf hf => rf a (cf, hf)) (ofNat Code n))\n (List.range (Nat.succ (Nat.succ (Nat.succ (Nat.succ n))))))\n (div2 (div2 n_4)))\n fun s_1 =>\n Option.bind\n (List.get?\n (List.map\n (fun n =>\n rec (z a) (s a) (l a) (r a) (fun cf cg hf hg => pr a (cf, cg, hf, hg))\n (fun cf cg hf hg => co a (cf, cg, hf, hg)) (fun cf cg hf hg => pc a (cf, cg, hf, hg))\n (fun cf hf => rf a (cf, hf)) (ofNat Code n))\n (List.range (Nat.succ (Nat.succ (Nat.succ (Nat.succ n))))))\n (unpair (div2 (div2 n_4))).fst)\n fun s₁ =>\n Option.map\n (fun s₂ =>\n bif bodd n_4 then\n bif bodd (div2 n_4) then rf a (ofNat Code (div2 (div2 n_4)), s_1)\n else\n pc a\n (ofNat Code (unpair (div2 (div2 n_4))).fst, ofNat Code (unpair (div2 (div2 n_4))).snd,\n s₁, s₂)\n else\n bif bodd (div2 n_4) then\n co a\n (ofNat Code (unpair (div2 (div2 n_4))).fst, ofNat Code (unpair (div2 (div2 n_4))).snd,\n s₁, s₂)\n else\n pr a\n (ofNat Code (unpair (div2 (div2 n_4))).fst, ofNat Code (unpair (div2 (div2 n_4))).snd,\n s₁, s₂))\n (List.get?\n (List.map\n (fun n =>\n rec (z a) (s a) (l a) (r a) (fun cf cg hf hg => pr a (cf, cg, hf, hg))\n (fun cf cg hf hg => co a (cf, cg, hf, hg)) (fun cf cg hf hg => pc a (cf, cg, hf, hg))\n (fun cf hf => rf a (cf, hf)) (ofNat Code n))\n (List.range (Nat.succ (Nat.succ (Nat.succ (Nat.succ n))))))\n (unpair (div2 (div2 n_4))).snd))\n n_3)\n n_2)\n n_1)\n (Nat.succ (Nat.succ (Nat.succ (Nat.succ n)))) =\n some\n (rec (z a) (s a) (l a) (r a) (fun cf cg hf hg => pr a (cf, cg, hf, hg)) (fun cf cg hf hg => co a (cf, cg, hf, hg))\n (fun cf cg hf hg => pc a (cf, cg, hf, hg)) (fun cf hf => rf a (cf, hf))\n (ofNat Code (Nat.succ (Nat.succ (Nat.succ (Nat.succ n))))))",
"state_before": "case succ.succ.succ.succ\nα : Type u_1\nσ : Type u_2\ninst✝¹ : Primcodable α\ninst✝ : Primcodable σ\nc : α → Code\nhc : Primrec c\nz : α → σ\nhz : Primrec z\ns : α → σ\nhs : Primrec s\nl : α → σ\nhl : Primrec l\nr : α → σ\nhr : Primrec r\npr : α → Code × Code × σ × σ → σ\nhpr : Primrec₂ pr\nco : α → Code × Code × σ × σ → σ\nhco : Primrec₂ co\npc : α → Code × Code × σ × σ → σ\nhpc : Primrec₂ pc\nrf : α → Code × σ → σ\nhrf : Primrec₂ rf\nPR✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pr a (cf, cg, hf, hg)\nCO✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => co a (cf, cg, hf, hg)\nPC✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pc a (cf, cg, hf, hg)\nRF✝ : α → Code → σ → σ := fun a cf hf => rf a (cf, hf)\nF : α → Code → σ := fun a c => Code.recOn c (z a) (s a) (l a) (r a) (PR✝ a) (CO✝ a) (PC✝ a) (RF✝ a)\nG₁ : (α × List σ) × ℕ × ℕ → Option σ :=\n fun p =>\n let a := p.fst.fst;\n let IH := p.fst.snd;\n let n := p.snd.fst;\n let m := p.snd.snd;\n Option.bind (List.get? IH m) fun s =>\n Option.bind (List.get? IH (unpair m).fst) fun s₁ =>\n Option.map\n (fun s₂ =>\n bif bodd n then\n bif bodd (div2 n) then rf a (ofNat Code m, s)\n else pc a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else\n bif bodd (div2 n) then co a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else pr a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂))\n (List.get? IH (unpair m).snd)\nthis✝ : Primrec G₁\nG : α → List σ → Option σ :=\n fun a IH =>\n Nat.casesOn (List.length IH) (some (z a)) fun n =>\n Nat.casesOn n (some (s a)) fun n =>\n Nat.casesOn n (some (l a)) fun n => Nat.casesOn n (some (r a)) fun n => G₁ ((a, IH), n, div2 (div2 n))\nthis : Primrec₂ G\na : α\nn : ℕ\n⊢ Nat.rec (some (z a))\n (fun n_1 n_ih =>\n Nat.rec (some (s a))\n (fun n_2 n_ih =>\n Nat.rec (some (l a))\n (fun n_3 n_ih =>\n Nat.rec (some (r a))\n (fun n_4 n_ih =>\n Option.bind\n (List.get?\n (List.map\n (fun n =>\n rec (z a) (s a) (l a) (r a) (fun cf cg hf hg => pr a (cf, cg, hf, hg))\n (fun cf cg hf hg => co a (cf, cg, hf, hg)) (fun cf cg hf hg => pc a (cf, cg, hf, hg))\n (fun cf hf => rf a (cf, hf)) (ofNat Code n))\n (List.range (Nat.succ (Nat.succ (Nat.succ (Nat.succ n))))))\n (div2 (div2 n_4)))\n fun s_1 =>\n Option.bind\n (List.get?\n (List.map\n (fun n =>\n rec (z a) (s a) (l a) (r a) (fun cf cg hf hg => pr a (cf, cg, hf, hg))\n (fun cf cg hf hg => co a (cf, cg, hf, hg)) (fun cf cg hf hg => pc a (cf, cg, hf, hg))\n (fun cf hf => rf a (cf, hf)) (ofNat Code n))\n (List.range (Nat.succ (Nat.succ (Nat.succ (Nat.succ n))))))\n (unpair (div2 (div2 n_4))).fst)\n fun s₁ =>\n Option.map\n (fun s₂ =>\n bif bodd n_4 then\n bif bodd (div2 n_4) then rf a (ofNat Code (div2 (div2 n_4)), s_1)\n else\n pc a\n (ofNat Code (unpair (div2 (div2 n_4))).fst, ofNat Code (unpair (div2 (div2 n_4))).snd,\n s₁, s₂)\n else\n bif bodd (div2 n_4) then\n co a\n (ofNat Code (unpair (div2 (div2 n_4))).fst, ofNat Code (unpair (div2 (div2 n_4))).snd,\n s₁, s₂)\n else\n pr a\n (ofNat Code (unpair (div2 (div2 n_4))).fst, ofNat Code (unpair (div2 (div2 n_4))).snd,\n s₁, s₂))\n (List.get?\n (List.map\n (fun n =>\n rec (z a) (s a) (l a) (r a) (fun cf cg hf hg => pr a (cf, cg, hf, hg))\n (fun cf cg hf hg => co a (cf, cg, hf, hg)) (fun cf cg hf hg => pc a (cf, cg, hf, hg))\n (fun cf hf => rf a (cf, hf)) (ofNat Code n))\n (List.range (Nat.succ (Nat.succ (Nat.succ (Nat.succ n))))))\n (unpair (div2 (div2 n_4))).snd))\n n_3)\n n_2)\n n_1)\n (Nat.succ (Nat.succ (Nat.succ (Nat.succ n)))) =\n some\n (rec (z a) (s a) (l a) (r a) (fun cf cg hf hg => pr a (cf, cg, hf, hg)) (fun cf cg hf hg => co a (cf, cg, hf, hg))\n (fun cf cg hf hg => pc a (cf, cg, hf, hg)) (fun cf hf => rf a (cf, hf))\n (ofNat Code (Nat.succ (Nat.succ (Nat.succ (Nat.succ n))))))",
"tactic": "let m := n.div2.div2"
},
{
"state_after": "case succ.succ.succ.succ\nα : Type u_1\nσ : Type u_2\ninst✝¹ : Primcodable α\ninst✝ : Primcodable σ\nc : α → Code\nhc : Primrec c\nz : α → σ\nhz : Primrec z\ns : α → σ\nhs : Primrec s\nl : α → σ\nhl : Primrec l\nr : α → σ\nhr : Primrec r\npr : α → Code × Code × σ × σ → σ\nhpr : Primrec₂ pr\nco : α → Code × Code × σ × σ → σ\nhco : Primrec₂ co\npc : α → Code × Code × σ × σ → σ\nhpc : Primrec₂ pc\nrf : α → Code × σ → σ\nhrf : Primrec₂ rf\nPR✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pr a (cf, cg, hf, hg)\nCO✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => co a (cf, cg, hf, hg)\nPC✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pc a (cf, cg, hf, hg)\nRF✝ : α → Code → σ → σ := fun a cf hf => rf a (cf, hf)\nF : α → Code → σ := fun a c => Code.recOn c (z a) (s a) (l a) (r a) (PR✝ a) (CO✝ a) (PC✝ a) (RF✝ a)\nG₁ : (α × List σ) × ℕ × ℕ → Option σ :=\n fun p =>\n let a := p.fst.fst;\n let IH := p.fst.snd;\n let n := p.snd.fst;\n let m := p.snd.snd;\n Option.bind (List.get? IH m) fun s =>\n Option.bind (List.get? IH (unpair m).fst) fun s₁ =>\n Option.map\n (fun s₂ =>\n bif bodd n then\n bif bodd (div2 n) then rf a (ofNat Code m, s)\n else pc a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else\n bif bodd (div2 n) then co a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else pr a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂))\n (List.get? IH (unpair m).snd)\nthis✝ : Primrec G₁\nG : α → List σ → Option σ :=\n fun a IH =>\n Nat.casesOn (List.length IH) (some (z a)) fun n =>\n Nat.casesOn n (some (s a)) fun n =>\n Nat.casesOn n (some (l a)) fun n => Nat.casesOn n (some (r a)) fun n => G₁ ((a, IH), n, div2 (div2 n))\nthis : Primrec₂ G\na : α\nn : ℕ\nm : ℕ := div2 (div2 n)\n⊢ G₁ ((a, List.map (fun n => F a (ofNat Code n)) (List.range (n + 4))), n, m) = some (F a (ofNat Code (n + 4)))",
"state_before": "case succ.succ.succ.succ\nα : Type u_1\nσ : Type u_2\ninst✝¹ : Primcodable α\ninst✝ : Primcodable σ\nc : α → Code\nhc : Primrec c\nz : α → σ\nhz : Primrec z\ns : α → σ\nhs : Primrec s\nl : α → σ\nhl : Primrec l\nr : α → σ\nhr : Primrec r\npr : α → Code × Code × σ × σ → σ\nhpr : Primrec₂ pr\nco : α → Code × Code × σ × σ → σ\nhco : Primrec₂ co\npc : α → Code × Code × σ × σ → σ\nhpc : Primrec₂ pc\nrf : α → Code × σ → σ\nhrf : Primrec₂ rf\nPR✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pr a (cf, cg, hf, hg)\nCO✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => co a (cf, cg, hf, hg)\nPC✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pc a (cf, cg, hf, hg)\nRF✝ : α → Code → σ → σ := fun a cf hf => rf a (cf, hf)\nF : α → Code → σ := fun a c => Code.recOn c (z a) (s a) (l a) (r a) (PR✝ a) (CO✝ a) (PC✝ a) (RF✝ a)\nG₁ : (α × List σ) × ℕ × ℕ → Option σ :=\n fun p =>\n let a := p.fst.fst;\n let IH := p.fst.snd;\n let n := p.snd.fst;\n let m := p.snd.snd;\n Option.bind (List.get? IH m) fun s =>\n Option.bind (List.get? IH (unpair m).fst) fun s₁ =>\n Option.map\n (fun s₂ =>\n bif bodd n then\n bif bodd (div2 n) then rf a (ofNat Code m, s)\n else pc a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else\n bif bodd (div2 n) then co a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else pr a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂))\n (List.get? IH (unpair m).snd)\nthis✝ : Primrec G₁\nG : α → List σ → Option σ :=\n fun a IH =>\n Nat.casesOn (List.length IH) (some (z a)) fun n =>\n Nat.casesOn n (some (s a)) fun n =>\n Nat.casesOn n (some (l a)) fun n => Nat.casesOn n (some (r a)) fun n => G₁ ((a, IH), n, div2 (div2 n))\nthis : Primrec₂ G\na : α\nn : ℕ\nm : ℕ := div2 (div2 n)\n⊢ Nat.rec (some (z a))\n (fun n_1 n_ih =>\n Nat.rec (some (s a))\n (fun n_2 n_ih =>\n Nat.rec (some (l a))\n (fun n_3 n_ih =>\n Nat.rec (some (r a))\n (fun n_4 n_ih =>\n Option.bind\n (List.get?\n (List.map\n (fun n =>\n rec (z a) (s a) (l a) (r a) (fun cf cg hf hg => pr a (cf, cg, hf, hg))\n (fun cf cg hf hg => co a (cf, cg, hf, hg)) (fun cf cg hf hg => pc a (cf, cg, hf, hg))\n (fun cf hf => rf a (cf, hf)) (ofNat Code n))\n (List.range (Nat.succ (Nat.succ (Nat.succ (Nat.succ n))))))\n (div2 (div2 n_4)))\n fun s_1 =>\n Option.bind\n (List.get?\n (List.map\n (fun n =>\n rec (z a) (s a) (l a) (r a) (fun cf cg hf hg => pr a (cf, cg, hf, hg))\n (fun cf cg hf hg => co a (cf, cg, hf, hg)) (fun cf cg hf hg => pc a (cf, cg, hf, hg))\n (fun cf hf => rf a (cf, hf)) (ofNat Code n))\n (List.range (Nat.succ (Nat.succ (Nat.succ (Nat.succ n))))))\n (unpair (div2 (div2 n_4))).fst)\n fun s₁ =>\n Option.map\n (fun s₂ =>\n bif bodd n_4 then\n bif bodd (div2 n_4) then rf a (ofNat Code (div2 (div2 n_4)), s_1)\n else\n pc a\n (ofNat Code (unpair (div2 (div2 n_4))).fst, ofNat Code (unpair (div2 (div2 n_4))).snd,\n s₁, s₂)\n else\n bif bodd (div2 n_4) then\n co a\n (ofNat Code (unpair (div2 (div2 n_4))).fst, ofNat Code (unpair (div2 (div2 n_4))).snd,\n s₁, s₂)\n else\n pr a\n (ofNat Code (unpair (div2 (div2 n_4))).fst, ofNat Code (unpair (div2 (div2 n_4))).snd,\n s₁, s₂))\n (List.get?\n (List.map\n (fun n =>\n rec (z a) (s a) (l a) (r a) (fun cf cg hf hg => pr a (cf, cg, hf, hg))\n (fun cf cg hf hg => co a (cf, cg, hf, hg)) (fun cf cg hf hg => pc a (cf, cg, hf, hg))\n (fun cf hf => rf a (cf, hf)) (ofNat Code n))\n (List.range (Nat.succ (Nat.succ (Nat.succ (Nat.succ n))))))\n (unpair (div2 (div2 n_4))).snd))\n n_3)\n n_2)\n n_1)\n (Nat.succ (Nat.succ (Nat.succ (Nat.succ n)))) =\n some\n (rec (z a) (s a) (l a) (r a) (fun cf cg hf hg => pr a (cf, cg, hf, hg)) (fun cf cg hf hg => co a (cf, cg, hf, hg))\n (fun cf cg hf hg => pc a (cf, cg, hf, hg)) (fun cf hf => rf a (cf, hf))\n (ofNat Code (Nat.succ (Nat.succ (Nat.succ (Nat.succ n))))))",
"tactic": "show\n G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) =\n some (F a (ofNat Code (n + 4)))"
},
{
"state_after": "case succ.succ.succ.succ\nα : Type u_1\nσ : Type u_2\ninst✝¹ : Primcodable α\ninst✝ : Primcodable σ\nc : α → Code\nhc : Primrec c\nz : α → σ\nhz : Primrec z\ns : α → σ\nhs : Primrec s\nl : α → σ\nhl : Primrec l\nr : α → σ\nhr : Primrec r\npr : α → Code × Code × σ × σ → σ\nhpr : Primrec₂ pr\nco : α → Code × Code × σ × σ → σ\nhco : Primrec₂ co\npc : α → Code × Code × σ × σ → σ\nhpc : Primrec₂ pc\nrf : α → Code × σ → σ\nhrf : Primrec₂ rf\nPR✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pr a (cf, cg, hf, hg)\nCO✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => co a (cf, cg, hf, hg)\nPC✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pc a (cf, cg, hf, hg)\nRF✝ : α → Code → σ → σ := fun a cf hf => rf a (cf, hf)\nF : α → Code → σ := fun a c => Code.recOn c (z a) (s a) (l a) (r a) (PR✝ a) (CO✝ a) (PC✝ a) (RF✝ a)\nG₁ : (α × List σ) × ℕ × ℕ → Option σ :=\n fun p =>\n let a := p.fst.fst;\n let IH := p.fst.snd;\n let n := p.snd.fst;\n let m := p.snd.snd;\n Option.bind (List.get? IH m) fun s =>\n Option.bind (List.get? IH (unpair m).fst) fun s₁ =>\n Option.map\n (fun s₂ =>\n bif bodd n then\n bif bodd (div2 n) then rf a (ofNat Code m, s)\n else pc a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else\n bif bodd (div2 n) then co a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else pr a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂))\n (List.get? IH (unpair m).snd)\nthis✝ : Primrec G₁\nG : α → List σ → Option σ :=\n fun a IH =>\n Nat.casesOn (List.length IH) (some (z a)) fun n =>\n Nat.casesOn n (some (s a)) fun n =>\n Nat.casesOn n (some (l a)) fun n => Nat.casesOn n (some (r a)) fun n => G₁ ((a, IH), n, div2 (div2 n))\nthis : Primrec₂ G\na : α\nn : ℕ\nm : ℕ := div2 (div2 n)\nhm : m < n + 4\n⊢ G₁ ((a, List.map (fun n => F a (ofNat Code n)) (List.range (n + 4))), n, m) = some (F a (ofNat Code (n + 4)))",
"state_before": "case succ.succ.succ.succ\nα : Type u_1\nσ : Type u_2\ninst✝¹ : Primcodable α\ninst✝ : Primcodable σ\nc : α → Code\nhc : Primrec c\nz : α → σ\nhz : Primrec z\ns : α → σ\nhs : Primrec s\nl : α → σ\nhl : Primrec l\nr : α → σ\nhr : Primrec r\npr : α → Code × Code × σ × σ → σ\nhpr : Primrec₂ pr\nco : α → Code × Code × σ × σ → σ\nhco : Primrec₂ co\npc : α → Code × Code × σ × σ → σ\nhpc : Primrec₂ pc\nrf : α → Code × σ → σ\nhrf : Primrec₂ rf\nPR✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pr a (cf, cg, hf, hg)\nCO✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => co a (cf, cg, hf, hg)\nPC✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pc a (cf, cg, hf, hg)\nRF✝ : α → Code → σ → σ := fun a cf hf => rf a (cf, hf)\nF : α → Code → σ := fun a c => Code.recOn c (z a) (s a) (l a) (r a) (PR✝ a) (CO✝ a) (PC✝ a) (RF✝ a)\nG₁ : (α × List σ) × ℕ × ℕ → Option σ :=\n fun p =>\n let a := p.fst.fst;\n let IH := p.fst.snd;\n let n := p.snd.fst;\n let m := p.snd.snd;\n Option.bind (List.get? IH m) fun s =>\n Option.bind (List.get? IH (unpair m).fst) fun s₁ =>\n Option.map\n (fun s₂ =>\n bif bodd n then\n bif bodd (div2 n) then rf a (ofNat Code m, s)\n else pc a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else\n bif bodd (div2 n) then co a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else pr a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂))\n (List.get? IH (unpair m).snd)\nthis✝ : Primrec G₁\nG : α → List σ → Option σ :=\n fun a IH =>\n Nat.casesOn (List.length IH) (some (z a)) fun n =>\n Nat.casesOn n (some (s a)) fun n =>\n Nat.casesOn n (some (l a)) fun n => Nat.casesOn n (some (r a)) fun n => G₁ ((a, IH), n, div2 (div2 n))\nthis : Primrec₂ G\na : α\nn : ℕ\nm : ℕ := div2 (div2 n)\n⊢ G₁ ((a, List.map (fun n => F a (ofNat Code n)) (List.range (n + 4))), n, m) = some (F a (ofNat Code (n + 4)))",
"tactic": "have hm : m < n + 4 := by\n simp [Nat.div2_val]\n exact\n lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _))\n (Nat.succ_le_succ (Nat.le_add_right _ _))"
},
{
"state_after": "case succ.succ.succ.succ\nα : Type u_1\nσ : Type u_2\ninst✝¹ : Primcodable α\ninst✝ : Primcodable σ\nc : α → Code\nhc : Primrec c\nz : α → σ\nhz : Primrec z\ns : α → σ\nhs : Primrec s\nl : α → σ\nhl : Primrec l\nr : α → σ\nhr : Primrec r\npr : α → Code × Code × σ × σ → σ\nhpr : Primrec₂ pr\nco : α → Code × Code × σ × σ → σ\nhco : Primrec₂ co\npc : α → Code × Code × σ × σ → σ\nhpc : Primrec₂ pc\nrf : α → Code × σ → σ\nhrf : Primrec₂ rf\nPR✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pr a (cf, cg, hf, hg)\nCO✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => co a (cf, cg, hf, hg)\nPC✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pc a (cf, cg, hf, hg)\nRF✝ : α → Code → σ → σ := fun a cf hf => rf a (cf, hf)\nF : α → Code → σ := fun a c => Code.recOn c (z a) (s a) (l a) (r a) (PR✝ a) (CO✝ a) (PC✝ a) (RF✝ a)\nG₁ : (α × List σ) × ℕ × ℕ → Option σ :=\n fun p =>\n let a := p.fst.fst;\n let IH := p.fst.snd;\n let n := p.snd.fst;\n let m := p.snd.snd;\n Option.bind (List.get? IH m) fun s =>\n Option.bind (List.get? IH (unpair m).fst) fun s₁ =>\n Option.map\n (fun s₂ =>\n bif bodd n then\n bif bodd (div2 n) then rf a (ofNat Code m, s)\n else pc a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else\n bif bodd (div2 n) then co a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else pr a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂))\n (List.get? IH (unpair m).snd)\nthis✝ : Primrec G₁\nG : α → List σ → Option σ :=\n fun a IH =>\n Nat.casesOn (List.length IH) (some (z a)) fun n =>\n Nat.casesOn n (some (s a)) fun n =>\n Nat.casesOn n (some (l a)) fun n => Nat.casesOn n (some (r a)) fun n => G₁ ((a, IH), n, div2 (div2 n))\nthis : Primrec₂ G\na : α\nn : ℕ\nm : ℕ := div2 (div2 n)\nhm : m < n + 4\nm1 : (unpair m).fst < n + 4\n⊢ G₁ ((a, List.map (fun n => F a (ofNat Code n)) (List.range (n + 4))), n, m) = some (F a (ofNat Code (n + 4)))",
"state_before": "case succ.succ.succ.succ\nα : Type u_1\nσ : Type u_2\ninst✝¹ : Primcodable α\ninst✝ : Primcodable σ\nc : α → Code\nhc : Primrec c\nz : α → σ\nhz : Primrec z\ns : α → σ\nhs : Primrec s\nl : α → σ\nhl : Primrec l\nr : α → σ\nhr : Primrec r\npr : α → Code × Code × σ × σ → σ\nhpr : Primrec₂ pr\nco : α → Code × Code × σ × σ → σ\nhco : Primrec₂ co\npc : α → Code × Code × σ × σ → σ\nhpc : Primrec₂ pc\nrf : α → Code × σ → σ\nhrf : Primrec₂ rf\nPR✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pr a (cf, cg, hf, hg)\nCO✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => co a (cf, cg, hf, hg)\nPC✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pc a (cf, cg, hf, hg)\nRF✝ : α → Code → σ → σ := fun a cf hf => rf a (cf, hf)\nF : α → Code → σ := fun a c => Code.recOn c (z a) (s a) (l a) (r a) (PR✝ a) (CO✝ a) (PC✝ a) (RF✝ a)\nG₁ : (α × List σ) × ℕ × ℕ → Option σ :=\n fun p =>\n let a := p.fst.fst;\n let IH := p.fst.snd;\n let n := p.snd.fst;\n let m := p.snd.snd;\n Option.bind (List.get? IH m) fun s =>\n Option.bind (List.get? IH (unpair m).fst) fun s₁ =>\n Option.map\n (fun s₂ =>\n bif bodd n then\n bif bodd (div2 n) then rf a (ofNat Code m, s)\n else pc a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else\n bif bodd (div2 n) then co a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else pr a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂))\n (List.get? IH (unpair m).snd)\nthis✝ : Primrec G₁\nG : α → List σ → Option σ :=\n fun a IH =>\n Nat.casesOn (List.length IH) (some (z a)) fun n =>\n Nat.casesOn n (some (s a)) fun n =>\n Nat.casesOn n (some (l a)) fun n => Nat.casesOn n (some (r a)) fun n => G₁ ((a, IH), n, div2 (div2 n))\nthis : Primrec₂ G\na : α\nn : ℕ\nm : ℕ := div2 (div2 n)\nhm : m < n + 4\n⊢ G₁ ((a, List.map (fun n => F a (ofNat Code n)) (List.range (n + 4))), n, m) = some (F a (ofNat Code (n + 4)))",
"tactic": "have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm"
},
{
"state_after": "case succ.succ.succ.succ\nα : Type u_1\nσ : Type u_2\ninst✝¹ : Primcodable α\ninst✝ : Primcodable σ\nc : α → Code\nhc : Primrec c\nz : α → σ\nhz : Primrec z\ns : α → σ\nhs : Primrec s\nl : α → σ\nhl : Primrec l\nr : α → σ\nhr : Primrec r\npr : α → Code × Code × σ × σ → σ\nhpr : Primrec₂ pr\nco : α → Code × Code × σ × σ → σ\nhco : Primrec₂ co\npc : α → Code × Code × σ × σ → σ\nhpc : Primrec₂ pc\nrf : α → Code × σ → σ\nhrf : Primrec₂ rf\nPR✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pr a (cf, cg, hf, hg)\nCO✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => co a (cf, cg, hf, hg)\nPC✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pc a (cf, cg, hf, hg)\nRF✝ : α → Code → σ → σ := fun a cf hf => rf a (cf, hf)\nF : α → Code → σ := fun a c => Code.recOn c (z a) (s a) (l a) (r a) (PR✝ a) (CO✝ a) (PC✝ a) (RF✝ a)\nG₁ : (α × List σ) × ℕ × ℕ → Option σ :=\n fun p =>\n let a := p.fst.fst;\n let IH := p.fst.snd;\n let n := p.snd.fst;\n let m := p.snd.snd;\n Option.bind (List.get? IH m) fun s =>\n Option.bind (List.get? IH (unpair m).fst) fun s₁ =>\n Option.map\n (fun s₂ =>\n bif bodd n then\n bif bodd (div2 n) then rf a (ofNat Code m, s)\n else pc a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else\n bif bodd (div2 n) then co a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else pr a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂))\n (List.get? IH (unpair m).snd)\nthis✝ : Primrec G₁\nG : α → List σ → Option σ :=\n fun a IH =>\n Nat.casesOn (List.length IH) (some (z a)) fun n =>\n Nat.casesOn n (some (s a)) fun n =>\n Nat.casesOn n (some (l a)) fun n => Nat.casesOn n (some (r a)) fun n => G₁ ((a, IH), n, div2 (div2 n))\nthis : Primrec₂ G\na : α\nn : ℕ\nm : ℕ := div2 (div2 n)\nhm : m < n + 4\nm1 : (unpair m).fst < n + 4\nm2 : (unpair m).snd < n + 4\n⊢ G₁ ((a, List.map (fun n => F a (ofNat Code n)) (List.range (n + 4))), n, m) = some (F a (ofNat Code (n + 4)))",
"state_before": "case succ.succ.succ.succ\nα : Type u_1\nσ : Type u_2\ninst✝¹ : Primcodable α\ninst✝ : Primcodable σ\nc : α → Code\nhc : Primrec c\nz : α → σ\nhz : Primrec z\ns : α → σ\nhs : Primrec s\nl : α → σ\nhl : Primrec l\nr : α → σ\nhr : Primrec r\npr : α → Code × Code × σ × σ → σ\nhpr : Primrec₂ pr\nco : α → Code × Code × σ × σ → σ\nhco : Primrec₂ co\npc : α → Code × Code × σ × σ → σ\nhpc : Primrec₂ pc\nrf : α → Code × σ → σ\nhrf : Primrec₂ rf\nPR✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pr a (cf, cg, hf, hg)\nCO✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => co a (cf, cg, hf, hg)\nPC✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pc a (cf, cg, hf, hg)\nRF✝ : α → Code → σ → σ := fun a cf hf => rf a (cf, hf)\nF : α → Code → σ := fun a c => Code.recOn c (z a) (s a) (l a) (r a) (PR✝ a) (CO✝ a) (PC✝ a) (RF✝ a)\nG₁ : (α × List σ) × ℕ × ℕ → Option σ :=\n fun p =>\n let a := p.fst.fst;\n let IH := p.fst.snd;\n let n := p.snd.fst;\n let m := p.snd.snd;\n Option.bind (List.get? IH m) fun s =>\n Option.bind (List.get? IH (unpair m).fst) fun s₁ =>\n Option.map\n (fun s₂ =>\n bif bodd n then\n bif bodd (div2 n) then rf a (ofNat Code m, s)\n else pc a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else\n bif bodd (div2 n) then co a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else pr a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂))\n (List.get? IH (unpair m).snd)\nthis✝ : Primrec G₁\nG : α → List σ → Option σ :=\n fun a IH =>\n Nat.casesOn (List.length IH) (some (z a)) fun n =>\n Nat.casesOn n (some (s a)) fun n =>\n Nat.casesOn n (some (l a)) fun n => Nat.casesOn n (some (r a)) fun n => G₁ ((a, IH), n, div2 (div2 n))\nthis : Primrec₂ G\na : α\nn : ℕ\nm : ℕ := div2 (div2 n)\nhm : m < n + 4\nm1 : (unpair m).fst < n + 4\n⊢ G₁ ((a, List.map (fun n => F a (ofNat Code n)) (List.range (n + 4))), n, m) = some (F a (ofNat Code (n + 4)))",
"tactic": "have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm"
},
{
"state_after": "case succ.succ.succ.succ\nα : Type u_1\nσ : Type u_2\ninst✝¹ : Primcodable α\ninst✝ : Primcodable σ\nc : α → Code\nhc : Primrec c\nz : α → σ\nhz : Primrec z\ns : α → σ\nhs : Primrec s\nl : α → σ\nhl : Primrec l\nr : α → σ\nhr : Primrec r\npr : α → Code × Code × σ × σ → σ\nhpr : Primrec₂ pr\nco : α → Code × Code × σ × σ → σ\nhco : Primrec₂ co\npc : α → Code × Code × σ × σ → σ\nhpc : Primrec₂ pc\nrf : α → Code × σ → σ\nhrf : Primrec₂ rf\nPR✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pr a (cf, cg, hf, hg)\nCO✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => co a (cf, cg, hf, hg)\nPC✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pc a (cf, cg, hf, hg)\nRF✝ : α → Code → σ → σ := fun a cf hf => rf a (cf, hf)\nF : α → Code → σ := fun a c => Code.recOn c (z a) (s a) (l a) (r a) (PR✝ a) (CO✝ a) (PC✝ a) (RF✝ a)\nG₁ : (α × List σ) × ℕ × ℕ → Option σ :=\n fun p =>\n let a := p.fst.fst;\n let IH := p.fst.snd;\n let n := p.snd.fst;\n let m := p.snd.snd;\n Option.bind (List.get? IH m) fun s =>\n Option.bind (List.get? IH (unpair m).fst) fun s₁ =>\n Option.map\n (fun s₂ =>\n bif bodd n then\n bif bodd (div2 n) then rf a (ofNat Code m, s)\n else pc a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else\n bif bodd (div2 n) then co a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else pr a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂))\n (List.get? IH (unpair m).snd)\nthis✝ : Primrec G₁\nG : α → List σ → Option σ :=\n fun a IH =>\n Nat.casesOn (List.length IH) (some (z a)) fun n =>\n Nat.casesOn n (some (s a)) fun n =>\n Nat.casesOn n (some (l a)) fun n => Nat.casesOn n (some (r a)) fun n => G₁ ((a, IH), n, div2 (div2 n))\nthis : Primrec₂ G\na : α\nn : ℕ\nm : ℕ := div2 (div2 n)\nhm : m < n + 4\nm1 : (unpair m).fst < n + 4\nm2 : (unpair m).snd < n + 4\n⊢ (bif bodd n then\n bif bodd (div2 n) then\n rf a\n (ofNat Code (div2 (div2 n)),\n rec (z a) (s a) (l a) (r a) (fun cf cg hf hg => pr a (cf, cg, hf, hg))\n (fun cf cg hf hg => co a (cf, cg, hf, hg)) (fun cf cg hf hg => pc a (cf, cg, hf, hg))\n (fun cf hf => rf a (cf, hf)) (ofNat Code (div2 (div2 n))))\n else\n pc a\n (ofNat Code (unpair (div2 (div2 n))).fst, ofNat Code (unpair (div2 (div2 n))).snd,\n rec (z a) (s a) (l a) (r a) (fun cf cg hf hg => pr a (cf, cg, hf, hg))\n (fun cf cg hf hg => co a (cf, cg, hf, hg)) (fun cf cg hf hg => pc a (cf, cg, hf, hg))\n (fun cf hf => rf a (cf, hf)) (ofNat Code (unpair (div2 (div2 n))).fst),\n rec (z a) (s a) (l a) (r a) (fun cf cg hf hg => pr a (cf, cg, hf, hg))\n (fun cf cg hf hg => co a (cf, cg, hf, hg)) (fun cf cg hf hg => pc a (cf, cg, hf, hg))\n (fun cf hf => rf a (cf, hf)) (ofNat Code (unpair (div2 (div2 n))).snd))\n else\n bif bodd (div2 n) then\n co a\n (ofNat Code (unpair (div2 (div2 n))).fst, ofNat Code (unpair (div2 (div2 n))).snd,\n rec (z a) (s a) (l a) (r a) (fun cf cg hf hg => pr a (cf, cg, hf, hg))\n (fun cf cg hf hg => co a (cf, cg, hf, hg)) (fun cf cg hf hg => pc a (cf, cg, hf, hg))\n (fun cf hf => rf a (cf, hf)) (ofNat Code (unpair (div2 (div2 n))).fst),\n rec (z a) (s a) (l a) (r a) (fun cf cg hf hg => pr a (cf, cg, hf, hg))\n (fun cf cg hf hg => co a (cf, cg, hf, hg)) (fun cf cg hf hg => pc a (cf, cg, hf, hg))\n (fun cf hf => rf a (cf, hf)) (ofNat Code (unpair (div2 (div2 n))).snd))\n else\n pr a\n (ofNat Code (unpair (div2 (div2 n))).fst, ofNat Code (unpair (div2 (div2 n))).snd,\n rec (z a) (s a) (l a) (r a) (fun cf cg hf hg => pr a (cf, cg, hf, hg))\n (fun cf cg hf hg => co a (cf, cg, hf, hg)) (fun cf cg hf hg => pc a (cf, cg, hf, hg))\n (fun cf hf => rf a (cf, hf)) (ofNat Code (unpair (div2 (div2 n))).fst),\n rec (z a) (s a) (l a) (r a) (fun cf cg hf hg => pr a (cf, cg, hf, hg))\n (fun cf cg hf hg => co a (cf, cg, hf, hg)) (fun cf cg hf hg => pc a (cf, cg, hf, hg))\n (fun cf hf => rf a (cf, hf)) (ofNat Code (unpair (div2 (div2 n))).snd))) =\n rec (z a) (s a) (l a) (r a) (fun cf cg hf hg => pr a (cf, cg, hf, hg)) (fun cf cg hf hg => co a (cf, cg, hf, hg))\n (fun cf cg hf hg => pc a (cf, cg, hf, hg)) (fun cf hf => rf a (cf, hf)) (ofNat Code (n + 4))",
"state_before": "case succ.succ.succ.succ\nα : Type u_1\nσ : Type u_2\ninst✝¹ : Primcodable α\ninst✝ : Primcodable σ\nc : α → Code\nhc : Primrec c\nz : α → σ\nhz : Primrec z\ns : α → σ\nhs : Primrec s\nl : α → σ\nhl : Primrec l\nr : α → σ\nhr : Primrec r\npr : α → Code × Code × σ × σ → σ\nhpr : Primrec₂ pr\nco : α → Code × Code × σ × σ → σ\nhco : Primrec₂ co\npc : α → Code × Code × σ × σ → σ\nhpc : Primrec₂ pc\nrf : α → Code × σ → σ\nhrf : Primrec₂ rf\nPR✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pr a (cf, cg, hf, hg)\nCO✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => co a (cf, cg, hf, hg)\nPC✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pc a (cf, cg, hf, hg)\nRF✝ : α → Code → σ → σ := fun a cf hf => rf a (cf, hf)\nF : α → Code → σ := fun a c => Code.recOn c (z a) (s a) (l a) (r a) (PR✝ a) (CO✝ a) (PC✝ a) (RF✝ a)\nG₁ : (α × List σ) × ℕ × ℕ → Option σ :=\n fun p =>\n let a := p.fst.fst;\n let IH := p.fst.snd;\n let n := p.snd.fst;\n let m := p.snd.snd;\n Option.bind (List.get? IH m) fun s =>\n Option.bind (List.get? IH (unpair m).fst) fun s₁ =>\n Option.map\n (fun s₂ =>\n bif bodd n then\n bif bodd (div2 n) then rf a (ofNat Code m, s)\n else pc a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else\n bif bodd (div2 n) then co a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else pr a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂))\n (List.get? IH (unpair m).snd)\nthis✝ : Primrec G₁\nG : α → List σ → Option σ :=\n fun a IH =>\n Nat.casesOn (List.length IH) (some (z a)) fun n =>\n Nat.casesOn n (some (s a)) fun n =>\n Nat.casesOn n (some (l a)) fun n => Nat.casesOn n (some (r a)) fun n => G₁ ((a, IH), n, div2 (div2 n))\nthis : Primrec₂ G\na : α\nn : ℕ\nm : ℕ := div2 (div2 n)\nhm : m < n + 4\nm1 : (unpair m).fst < n + 4\nm2 : (unpair m).snd < n + 4\n⊢ G₁ ((a, List.map (fun n => F a (ofNat Code n)) (List.range (n + 4))), n, m) = some (F a (ofNat Code (n + 4)))",
"tactic": "simp [List.get?_map, List.get?_range, hm, m1, m2]"
},
{
"state_after": "case succ.succ.succ.succ\nα : Type u_1\nσ : Type u_2\ninst✝¹ : Primcodable α\ninst✝ : Primcodable σ\nc : α → Code\nhc : Primrec c\nz : α → σ\nhz : Primrec z\ns : α → σ\nhs : Primrec s\nl : α → σ\nhl : Primrec l\nr : α → σ\nhr : Primrec r\npr : α → Code × Code × σ × σ → σ\nhpr : Primrec₂ pr\nco : α → Code × Code × σ × σ → σ\nhco : Primrec₂ co\npc : α → Code × Code × σ × σ → σ\nhpc : Primrec₂ pc\nrf : α → Code × σ → σ\nhrf : Primrec₂ rf\nPR✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pr a (cf, cg, hf, hg)\nCO✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => co a (cf, cg, hf, hg)\nPC✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pc a (cf, cg, hf, hg)\nRF✝ : α → Code → σ → σ := fun a cf hf => rf a (cf, hf)\nF : α → Code → σ := fun a c => Code.recOn c (z a) (s a) (l a) (r a) (PR✝ a) (CO✝ a) (PC✝ a) (RF✝ a)\nG₁ : (α × List σ) × ℕ × ℕ → Option σ :=\n fun p =>\n let a := p.fst.fst;\n let IH := p.fst.snd;\n let n := p.snd.fst;\n let m := p.snd.snd;\n Option.bind (List.get? IH m) fun s =>\n Option.bind (List.get? IH (unpair m).fst) fun s₁ =>\n Option.map\n (fun s₂ =>\n bif bodd n then\n bif bodd (div2 n) then rf a (ofNat Code m, s)\n else pc a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else\n bif bodd (div2 n) then co a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else pr a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂))\n (List.get? IH (unpair m).snd)\nthis✝ : Primrec G₁\nG : α → List σ → Option σ :=\n fun a IH =>\n Nat.casesOn (List.length IH) (some (z a)) fun n =>\n Nat.casesOn n (some (s a)) fun n =>\n Nat.casesOn n (some (l a)) fun n => Nat.casesOn n (some (r a)) fun n => G₁ ((a, IH), n, div2 (div2 n))\nthis : Primrec₂ G\na : α\nn : ℕ\nm : ℕ := div2 (div2 n)\nhm : m < n + 4\nm1 : (unpair m).fst < n + 4\nm2 : (unpair m).snd < n + 4\n⊢ (bif bodd n then\n bif bodd (div2 n) then\n rf a\n (ofNat Code (div2 (div2 n)),\n rec (z a) (s a) (l a) (r a) (fun cf cg hf hg => pr a (cf, cg, hf, hg))\n (fun cf cg hf hg => co a (cf, cg, hf, hg)) (fun cf cg hf hg => pc a (cf, cg, hf, hg))\n (fun cf hf => rf a (cf, hf)) (ofNat Code (div2 (div2 n))))\n else\n pc a\n (ofNat Code (unpair (div2 (div2 n))).fst, ofNat Code (unpair (div2 (div2 n))).snd,\n rec (z a) (s a) (l a) (r a) (fun cf cg hf hg => pr a (cf, cg, hf, hg))\n (fun cf cg hf hg => co a (cf, cg, hf, hg)) (fun cf cg hf hg => pc a (cf, cg, hf, hg))\n (fun cf hf => rf a (cf, hf)) (ofNat Code (unpair (div2 (div2 n))).fst),\n rec (z a) (s a) (l a) (r a) (fun cf cg hf hg => pr a (cf, cg, hf, hg))\n (fun cf cg hf hg => co a (cf, cg, hf, hg)) (fun cf cg hf hg => pc a (cf, cg, hf, hg))\n (fun cf hf => rf a (cf, hf)) (ofNat Code (unpair (div2 (div2 n))).snd))\n else\n bif bodd (div2 n) then\n co a\n (ofNat Code (unpair (div2 (div2 n))).fst, ofNat Code (unpair (div2 (div2 n))).snd,\n rec (z a) (s a) (l a) (r a) (fun cf cg hf hg => pr a (cf, cg, hf, hg))\n (fun cf cg hf hg => co a (cf, cg, hf, hg)) (fun cf cg hf hg => pc a (cf, cg, hf, hg))\n (fun cf hf => rf a (cf, hf)) (ofNat Code (unpair (div2 (div2 n))).fst),\n rec (z a) (s a) (l a) (r a) (fun cf cg hf hg => pr a (cf, cg, hf, hg))\n (fun cf cg hf hg => co a (cf, cg, hf, hg)) (fun cf cg hf hg => pc a (cf, cg, hf, hg))\n (fun cf hf => rf a (cf, hf)) (ofNat Code (unpair (div2 (div2 n))).snd))\n else\n pr a\n (ofNat Code (unpair (div2 (div2 n))).fst, ofNat Code (unpair (div2 (div2 n))).snd,\n rec (z a) (s a) (l a) (r a) (fun cf cg hf hg => pr a (cf, cg, hf, hg))\n (fun cf cg hf hg => co a (cf, cg, hf, hg)) (fun cf cg hf hg => pc a (cf, cg, hf, hg))\n (fun cf hf => rf a (cf, hf)) (ofNat Code (unpair (div2 (div2 n))).fst),\n rec (z a) (s a) (l a) (r a) (fun cf cg hf hg => pr a (cf, cg, hf, hg))\n (fun cf cg hf hg => co a (cf, cg, hf, hg)) (fun cf cg hf hg => pc a (cf, cg, hf, hg))\n (fun cf hf => rf a (cf, hf)) (ofNat Code (unpair (div2 (div2 n))).snd))) =\n rec (z a) (s a) (l a) (r a) (fun cf cg hf hg => pr a (cf, cg, hf, hg)) (fun cf cg hf hg => co a (cf, cg, hf, hg))\n (fun cf cg hf hg => pc a (cf, cg, hf, hg)) (fun cf hf => rf a (cf, hf)) (ofNatCode (n + 4))",
"state_before": "case succ.succ.succ.succ\nα : Type u_1\nσ : Type u_2\ninst✝¹ : Primcodable α\ninst✝ : Primcodable σ\nc : α → Code\nhc : Primrec c\nz : α → σ\nhz : Primrec z\ns : α → σ\nhs : Primrec s\nl : α → σ\nhl : Primrec l\nr : α → σ\nhr : Primrec r\npr : α → Code × Code × σ × σ → σ\nhpr : Primrec₂ pr\nco : α → Code × Code × σ × σ → σ\nhco : Primrec₂ co\npc : α → Code × Code × σ × σ → σ\nhpc : Primrec₂ pc\nrf : α → Code × σ → σ\nhrf : Primrec₂ rf\nPR✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pr a (cf, cg, hf, hg)\nCO✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => co a (cf, cg, hf, hg)\nPC✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pc a (cf, cg, hf, hg)\nRF✝ : α → Code → σ → σ := fun a cf hf => rf a (cf, hf)\nF : α → Code → σ := fun a c => Code.recOn c (z a) (s a) (l a) (r a) (PR✝ a) (CO✝ a) (PC✝ a) (RF✝ a)\nG₁ : (α × List σ) × ℕ × ℕ → Option σ :=\n fun p =>\n let a := p.fst.fst;\n let IH := p.fst.snd;\n let n := p.snd.fst;\n let m := p.snd.snd;\n Option.bind (List.get? IH m) fun s =>\n Option.bind (List.get? IH (unpair m).fst) fun s₁ =>\n Option.map\n (fun s₂ =>\n bif bodd n then\n bif bodd (div2 n) then rf a (ofNat Code m, s)\n else pc a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else\n bif bodd (div2 n) then co a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else pr a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂))\n (List.get? IH (unpair m).snd)\nthis✝ : Primrec G₁\nG : α → List σ → Option σ :=\n fun a IH =>\n Nat.casesOn (List.length IH) (some (z a)) fun n =>\n Nat.casesOn n (some (s a)) fun n =>\n Nat.casesOn n (some (l a)) fun n => Nat.casesOn n (some (r a)) fun n => G₁ ((a, IH), n, div2 (div2 n))\nthis : Primrec₂ G\na : α\nn : ℕ\nm : ℕ := div2 (div2 n)\nhm : m < n + 4\nm1 : (unpair m).fst < n + 4\nm2 : (unpair m).snd < n + 4\n⊢ (bif bodd n then\n bif bodd (div2 n) then\n rf a\n (ofNat Code (div2 (div2 n)),\n rec (z a) (s a) (l a) (r a) (fun cf cg hf hg => pr a (cf, cg, hf, hg))\n (fun cf cg hf hg => co a (cf, cg, hf, hg)) (fun cf cg hf hg => pc a (cf, cg, hf, hg))\n (fun cf hf => rf a (cf, hf)) (ofNat Code (div2 (div2 n))))\n else\n pc a\n (ofNat Code (unpair (div2 (div2 n))).fst, ofNat Code (unpair (div2 (div2 n))).snd,\n rec (z a) (s a) (l a) (r a) (fun cf cg hf hg => pr a (cf, cg, hf, hg))\n (fun cf cg hf hg => co a (cf, cg, hf, hg)) (fun cf cg hf hg => pc a (cf, cg, hf, hg))\n (fun cf hf => rf a (cf, hf)) (ofNat Code (unpair (div2 (div2 n))).fst),\n rec (z a) (s a) (l a) (r a) (fun cf cg hf hg => pr a (cf, cg, hf, hg))\n (fun cf cg hf hg => co a (cf, cg, hf, hg)) (fun cf cg hf hg => pc a (cf, cg, hf, hg))\n (fun cf hf => rf a (cf, hf)) (ofNat Code (unpair (div2 (div2 n))).snd))\n else\n bif bodd (div2 n) then\n co a\n (ofNat Code (unpair (div2 (div2 n))).fst, ofNat Code (unpair (div2 (div2 n))).snd,\n rec (z a) (s a) (l a) (r a) (fun cf cg hf hg => pr a (cf, cg, hf, hg))\n (fun cf cg hf hg => co a (cf, cg, hf, hg)) (fun cf cg hf hg => pc a (cf, cg, hf, hg))\n (fun cf hf => rf a (cf, hf)) (ofNat Code (unpair (div2 (div2 n))).fst),\n rec (z a) (s a) (l a) (r a) (fun cf cg hf hg => pr a (cf, cg, hf, hg))\n (fun cf cg hf hg => co a (cf, cg, hf, hg)) (fun cf cg hf hg => pc a (cf, cg, hf, hg))\n (fun cf hf => rf a (cf, hf)) (ofNat Code (unpair (div2 (div2 n))).snd))\n else\n pr a\n (ofNat Code (unpair (div2 (div2 n))).fst, ofNat Code (unpair (div2 (div2 n))).snd,\n rec (z a) (s a) (l a) (r a) (fun cf cg hf hg => pr a (cf, cg, hf, hg))\n (fun cf cg hf hg => co a (cf, cg, hf, hg)) (fun cf cg hf hg => pc a (cf, cg, hf, hg))\n (fun cf hf => rf a (cf, hf)) (ofNat Code (unpair (div2 (div2 n))).fst),\n rec (z a) (s a) (l a) (r a) (fun cf cg hf hg => pr a (cf, cg, hf, hg))\n (fun cf cg hf hg => co a (cf, cg, hf, hg)) (fun cf cg hf hg => pc a (cf, cg, hf, hg))\n (fun cf hf => rf a (cf, hf)) (ofNat Code (unpair (div2 (div2 n))).snd))) =\n rec (z a) (s a) (l a) (r a) (fun cf cg hf hg => pr a (cf, cg, hf, hg)) (fun cf cg hf hg => co a (cf, cg, hf, hg))\n (fun cf cg hf hg => pc a (cf, cg, hf, hg)) (fun cf hf => rf a (cf, hf)) (ofNat Code (n + 4))",
"tactic": "rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl]"
},
{
"state_after": "case succ.succ.succ.succ\nα : Type u_1\nσ : Type u_2\ninst✝¹ : Primcodable α\ninst✝ : Primcodable σ\nc : α → Code\nhc : Primrec c\nz : α → σ\nhz : Primrec z\ns : α → σ\nhs : Primrec s\nl : α → σ\nhl : Primrec l\nr : α → σ\nhr : Primrec r\npr : α → Code × Code × σ × σ → σ\nhpr : Primrec₂ pr\nco : α → Code × Code × σ × σ → σ\nhco : Primrec₂ co\npc : α → Code × Code × σ × σ → σ\nhpc : Primrec₂ pc\nrf : α → Code × σ → σ\nhrf : Primrec₂ rf\nPR✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pr a (cf, cg, hf, hg)\nCO✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => co a (cf, cg, hf, hg)\nPC✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pc a (cf, cg, hf, hg)\nRF✝ : α → Code → σ → σ := fun a cf hf => rf a (cf, hf)\nF : α → Code → σ := fun a c => Code.recOn c (z a) (s a) (l a) (r a) (PR✝ a) (CO✝ a) (PC✝ a) (RF✝ a)\nG₁ : (α × List σ) × ℕ × ℕ → Option σ :=\n fun p =>\n let a := p.fst.fst;\n let IH := p.fst.snd;\n let n := p.snd.fst;\n let m := p.snd.snd;\n Option.bind (List.get? IH m) fun s =>\n Option.bind (List.get? IH (unpair m).fst) fun s₁ =>\n Option.map\n (fun s₂ =>\n bif bodd n then\n bif bodd (div2 n) then rf a (ofNat Code m, s)\n else pc a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else\n bif bodd (div2 n) then co a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else pr a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂))\n (List.get? IH (unpair m).snd)\nthis✝ : Primrec G₁\nG : α → List σ → Option σ :=\n fun a IH =>\n Nat.casesOn (List.length IH) (some (z a)) fun n =>\n Nat.casesOn n (some (s a)) fun n =>\n Nat.casesOn n (some (l a)) fun n => Nat.casesOn n (some (r a)) fun n => G₁ ((a, IH), n, div2 (div2 n))\nthis : Primrec₂ G\na : α\nn : ℕ\nm : ℕ := div2 (div2 n)\nhm : m < n + 4\nm1 : (unpair m).fst < n + 4\nm2 : (unpair m).snd < n + 4\n⊢ (bif bodd n then\n bif bodd (div2 n) then\n rf a\n (ofNat Code (div2 (div2 n)),\n rec (z a) (s a) (l a) (r a) (fun cf cg hf hg => pr a (cf, cg, hf, hg))\n (fun cf cg hf hg => co a (cf, cg, hf, hg)) (fun cf cg hf hg => pc a (cf, cg, hf, hg))\n (fun cf hf => rf a (cf, hf)) (ofNat Code (div2 (div2 n))))\n else\n pc a\n (ofNat Code (unpair (div2 (div2 n))).fst, ofNat Code (unpair (div2 (div2 n))).snd,\n rec (z a) (s a) (l a) (r a) (fun cf cg hf hg => pr a (cf, cg, hf, hg))\n (fun cf cg hf hg => co a (cf, cg, hf, hg)) (fun cf cg hf hg => pc a (cf, cg, hf, hg))\n (fun cf hf => rf a (cf, hf)) (ofNat Code (unpair (div2 (div2 n))).fst),\n rec (z a) (s a) (l a) (r a) (fun cf cg hf hg => pr a (cf, cg, hf, hg))\n (fun cf cg hf hg => co a (cf, cg, hf, hg)) (fun cf cg hf hg => pc a (cf, cg, hf, hg))\n (fun cf hf => rf a (cf, hf)) (ofNat Code (unpair (div2 (div2 n))).snd))\n else\n bif bodd (div2 n) then\n co a\n (ofNat Code (unpair (div2 (div2 n))).fst, ofNat Code (unpair (div2 (div2 n))).snd,\n rec (z a) (s a) (l a) (r a) (fun cf cg hf hg => pr a (cf, cg, hf, hg))\n (fun cf cg hf hg => co a (cf, cg, hf, hg)) (fun cf cg hf hg => pc a (cf, cg, hf, hg))\n (fun cf hf => rf a (cf, hf)) (ofNat Code (unpair (div2 (div2 n))).fst),\n rec (z a) (s a) (l a) (r a) (fun cf cg hf hg => pr a (cf, cg, hf, hg))\n (fun cf cg hf hg => co a (cf, cg, hf, hg)) (fun cf cg hf hg => pc a (cf, cg, hf, hg))\n (fun cf hf => rf a (cf, hf)) (ofNat Code (unpair (div2 (div2 n))).snd))\n else\n pr a\n (ofNat Code (unpair (div2 (div2 n))).fst, ofNat Code (unpair (div2 (div2 n))).snd,\n rec (z a) (s a) (l a) (r a) (fun cf cg hf hg => pr a (cf, cg, hf, hg))\n (fun cf cg hf hg => co a (cf, cg, hf, hg)) (fun cf cg hf hg => pc a (cf, cg, hf, hg))\n (fun cf hf => rf a (cf, hf)) (ofNat Code (unpair (div2 (div2 n))).fst),\n rec (z a) (s a) (l a) (r a) (fun cf cg hf hg => pr a (cf, cg, hf, hg))\n (fun cf cg hf hg => co a (cf, cg, hf, hg)) (fun cf cg hf hg => pc a (cf, cg, hf, hg))\n (fun cf hf => rf a (cf, hf)) (ofNat Code (unpair (div2 (div2 n))).snd))) =\n rec (z a) (s a) (l a) (r a) (fun cf cg hf hg => pr a (cf, cg, hf, hg)) (fun cf cg hf hg => co a (cf, cg, hf, hg))\n (fun cf cg hf hg => pc a (cf, cg, hf, hg)) (fun cf hf => rf a (cf, hf))\n (match bodd n, bodd (div2 n) with\n | false, false => pair (ofNatCode (unpair (div2 (div2 n))).fst) (ofNatCode (unpair (div2 (div2 n))).snd)\n | false, true => comp (ofNatCode (unpair (div2 (div2 n))).fst) (ofNatCode (unpair (div2 (div2 n))).snd)\n | true, false => prec (ofNatCode (unpair (div2 (div2 n))).fst) (ofNatCode (unpair (div2 (div2 n))).snd)\n | true, true => rfind' (ofNatCode (div2 (div2 n))))",
"state_before": "case succ.succ.succ.succ\nα : Type u_1\nσ : Type u_2\ninst✝¹ : Primcodable α\ninst✝ : Primcodable σ\nc : α → Code\nhc : Primrec c\nz : α → σ\nhz : Primrec z\ns : α → σ\nhs : Primrec s\nl : α → σ\nhl : Primrec l\nr : α → σ\nhr : Primrec r\npr : α → Code × Code × σ × σ → σ\nhpr : Primrec₂ pr\nco : α → Code × Code × σ × σ → σ\nhco : Primrec₂ co\npc : α → Code × Code × σ × σ → σ\nhpc : Primrec₂ pc\nrf : α → Code × σ → σ\nhrf : Primrec₂ rf\nPR✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pr a (cf, cg, hf, hg)\nCO✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => co a (cf, cg, hf, hg)\nPC✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pc a (cf, cg, hf, hg)\nRF✝ : α → Code → σ → σ := fun a cf hf => rf a (cf, hf)\nF : α → Code → σ := fun a c => Code.recOn c (z a) (s a) (l a) (r a) (PR✝ a) (CO✝ a) (PC✝ a) (RF✝ a)\nG₁ : (α × List σ) × ℕ × ℕ → Option σ :=\n fun p =>\n let a := p.fst.fst;\n let IH := p.fst.snd;\n let n := p.snd.fst;\n let m := p.snd.snd;\n Option.bind (List.get? IH m) fun s =>\n Option.bind (List.get? IH (unpair m).fst) fun s₁ =>\n Option.map\n (fun s₂ =>\n bif bodd n then\n bif bodd (div2 n) then rf a (ofNat Code m, s)\n else pc a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else\n bif bodd (div2 n) then co a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else pr a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂))\n (List.get? IH (unpair m).snd)\nthis✝ : Primrec G₁\nG : α → List σ → Option σ :=\n fun a IH =>\n Nat.casesOn (List.length IH) (some (z a)) fun n =>\n Nat.casesOn n (some (s a)) fun n =>\n Nat.casesOn n (some (l a)) fun n => Nat.casesOn n (some (r a)) fun n => G₁ ((a, IH), n, div2 (div2 n))\nthis : Primrec₂ G\na : α\nn : ℕ\nm : ℕ := div2 (div2 n)\nhm : m < n + 4\nm1 : (unpair m).fst < n + 4\nm2 : (unpair m).snd < n + 4\n⊢ (bif bodd n then\n bif bodd (div2 n) then\n rf a\n (ofNat Code (div2 (div2 n)),\n rec (z a) (s a) (l a) (r a) (fun cf cg hf hg => pr a (cf, cg, hf, hg))\n (fun cf cg hf hg => co a (cf, cg, hf, hg)) (fun cf cg hf hg => pc a (cf, cg, hf, hg))\n (fun cf hf => rf a (cf, hf)) (ofNat Code (div2 (div2 n))))\n else\n pc a\n (ofNat Code (unpair (div2 (div2 n))).fst, ofNat Code (unpair (div2 (div2 n))).snd,\n rec (z a) (s a) (l a) (r a) (fun cf cg hf hg => pr a (cf, cg, hf, hg))\n (fun cf cg hf hg => co a (cf, cg, hf, hg)) (fun cf cg hf hg => pc a (cf, cg, hf, hg))\n (fun cf hf => rf a (cf, hf)) (ofNat Code (unpair (div2 (div2 n))).fst),\n rec (z a) (s a) (l a) (r a) (fun cf cg hf hg => pr a (cf, cg, hf, hg))\n (fun cf cg hf hg => co a (cf, cg, hf, hg)) (fun cf cg hf hg => pc a (cf, cg, hf, hg))\n (fun cf hf => rf a (cf, hf)) (ofNat Code (unpair (div2 (div2 n))).snd))\n else\n bif bodd (div2 n) then\n co a\n (ofNat Code (unpair (div2 (div2 n))).fst, ofNat Code (unpair (div2 (div2 n))).snd,\n rec (z a) (s a) (l a) (r a) (fun cf cg hf hg => pr a (cf, cg, hf, hg))\n (fun cf cg hf hg => co a (cf, cg, hf, hg)) (fun cf cg hf hg => pc a (cf, cg, hf, hg))\n (fun cf hf => rf a (cf, hf)) (ofNat Code (unpair (div2 (div2 n))).fst),\n rec (z a) (s a) (l a) (r a) (fun cf cg hf hg => pr a (cf, cg, hf, hg))\n (fun cf cg hf hg => co a (cf, cg, hf, hg)) (fun cf cg hf hg => pc a (cf, cg, hf, hg))\n (fun cf hf => rf a (cf, hf)) (ofNat Code (unpair (div2 (div2 n))).snd))\n else\n pr a\n (ofNat Code (unpair (div2 (div2 n))).fst, ofNat Code (unpair (div2 (div2 n))).snd,\n rec (z a) (s a) (l a) (r a) (fun cf cg hf hg => pr a (cf, cg, hf, hg))\n (fun cf cg hf hg => co a (cf, cg, hf, hg)) (fun cf cg hf hg => pc a (cf, cg, hf, hg))\n (fun cf hf => rf a (cf, hf)) (ofNat Code (unpair (div2 (div2 n))).fst),\n rec (z a) (s a) (l a) (r a) (fun cf cg hf hg => pr a (cf, cg, hf, hg))\n (fun cf cg hf hg => co a (cf, cg, hf, hg)) (fun cf cg hf hg => pc a (cf, cg, hf, hg))\n (fun cf hf => rf a (cf, hf)) (ofNat Code (unpair (div2 (div2 n))).snd))) =\n rec (z a) (s a) (l a) (r a) (fun cf cg hf hg => pr a (cf, cg, hf, hg)) (fun cf cg hf hg => co a (cf, cg, hf, hg))\n (fun cf cg hf hg => pc a (cf, cg, hf, hg)) (fun cf hf => rf a (cf, hf)) (ofNatCode (n + 4))",
"tactic": "simp [ofNatCode]"
},
{
"state_after": "no goals",
"state_before": "case succ.succ.succ.succ\nα : Type u_1\nσ : Type u_2\ninst✝¹ : Primcodable α\ninst✝ : Primcodable σ\nc : α → Code\nhc : Primrec c\nz : α → σ\nhz : Primrec z\ns : α → σ\nhs : Primrec s\nl : α → σ\nhl : Primrec l\nr : α → σ\nhr : Primrec r\npr : α → Code × Code × σ × σ → σ\nhpr : Primrec₂ pr\nco : α → Code × Code × σ × σ → σ\nhco : Primrec₂ co\npc : α → Code × Code × σ × σ → σ\nhpc : Primrec₂ pc\nrf : α → Code × σ → σ\nhrf : Primrec₂ rf\nPR✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pr a (cf, cg, hf, hg)\nCO✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => co a (cf, cg, hf, hg)\nPC✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pc a (cf, cg, hf, hg)\nRF✝ : α → Code → σ → σ := fun a cf hf => rf a (cf, hf)\nF : α → Code → σ := fun a c => Code.recOn c (z a) (s a) (l a) (r a) (PR✝ a) (CO✝ a) (PC✝ a) (RF✝ a)\nG₁ : (α × List σ) × ℕ × ℕ → Option σ :=\n fun p =>\n let a := p.fst.fst;\n let IH := p.fst.snd;\n let n := p.snd.fst;\n let m := p.snd.snd;\n Option.bind (List.get? IH m) fun s =>\n Option.bind (List.get? IH (unpair m).fst) fun s₁ =>\n Option.map\n (fun s₂ =>\n bif bodd n then\n bif bodd (div2 n) then rf a (ofNat Code m, s)\n else pc a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else\n bif bodd (div2 n) then co a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else pr a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂))\n (List.get? IH (unpair m).snd)\nthis✝ : Primrec G₁\nG : α → List σ → Option σ :=\n fun a IH =>\n Nat.casesOn (List.length IH) (some (z a)) fun n =>\n Nat.casesOn n (some (s a)) fun n =>\n Nat.casesOn n (some (l a)) fun n => Nat.casesOn n (some (r a)) fun n => G₁ ((a, IH), n, div2 (div2 n))\nthis : Primrec₂ G\na : α\nn : ℕ\nm : ℕ := div2 (div2 n)\nhm : m < n + 4\nm1 : (unpair m).fst < n + 4\nm2 : (unpair m).snd < n + 4\n⊢ (bif bodd n then\n bif bodd (div2 n) then\n rf a\n (ofNat Code (div2 (div2 n)),\n rec (z a) (s a) (l a) (r a) (fun cf cg hf hg => pr a (cf, cg, hf, hg))\n (fun cf cg hf hg => co a (cf, cg, hf, hg)) (fun cf cg hf hg => pc a (cf, cg, hf, hg))\n (fun cf hf => rf a (cf, hf)) (ofNat Code (div2 (div2 n))))\n else\n pc a\n (ofNat Code (unpair (div2 (div2 n))).fst, ofNat Code (unpair (div2 (div2 n))).snd,\n rec (z a) (s a) (l a) (r a) (fun cf cg hf hg => pr a (cf, cg, hf, hg))\n (fun cf cg hf hg => co a (cf, cg, hf, hg)) (fun cf cg hf hg => pc a (cf, cg, hf, hg))\n (fun cf hf => rf a (cf, hf)) (ofNat Code (unpair (div2 (div2 n))).fst),\n rec (z a) (s a) (l a) (r a) (fun cf cg hf hg => pr a (cf, cg, hf, hg))\n (fun cf cg hf hg => co a (cf, cg, hf, hg)) (fun cf cg hf hg => pc a (cf, cg, hf, hg))\n (fun cf hf => rf a (cf, hf)) (ofNat Code (unpair (div2 (div2 n))).snd))\n else\n bif bodd (div2 n) then\n co a\n (ofNat Code (unpair (div2 (div2 n))).fst, ofNat Code (unpair (div2 (div2 n))).snd,\n rec (z a) (s a) (l a) (r a) (fun cf cg hf hg => pr a (cf, cg, hf, hg))\n (fun cf cg hf hg => co a (cf, cg, hf, hg)) (fun cf cg hf hg => pc a (cf, cg, hf, hg))\n (fun cf hf => rf a (cf, hf)) (ofNat Code (unpair (div2 (div2 n))).fst),\n rec (z a) (s a) (l a) (r a) (fun cf cg hf hg => pr a (cf, cg, hf, hg))\n (fun cf cg hf hg => co a (cf, cg, hf, hg)) (fun cf cg hf hg => pc a (cf, cg, hf, hg))\n (fun cf hf => rf a (cf, hf)) (ofNat Code (unpair (div2 (div2 n))).snd))\n else\n pr a\n (ofNat Code (unpair (div2 (div2 n))).fst, ofNat Code (unpair (div2 (div2 n))).snd,\n rec (z a) (s a) (l a) (r a) (fun cf cg hf hg => pr a (cf, cg, hf, hg))\n (fun cf cg hf hg => co a (cf, cg, hf, hg)) (fun cf cg hf hg => pc a (cf, cg, hf, hg))\n (fun cf hf => rf a (cf, hf)) (ofNat Code (unpair (div2 (div2 n))).fst),\n rec (z a) (s a) (l a) (r a) (fun cf cg hf hg => pr a (cf, cg, hf, hg))\n (fun cf cg hf hg => co a (cf, cg, hf, hg)) (fun cf cg hf hg => pc a (cf, cg, hf, hg))\n (fun cf hf => rf a (cf, hf)) (ofNat Code (unpair (div2 (div2 n))).snd))) =\n rec (z a) (s a) (l a) (r a) (fun cf cg hf hg => pr a (cf, cg, hf, hg)) (fun cf cg hf hg => co a (cf, cg, hf, hg))\n (fun cf cg hf hg => pc a (cf, cg, hf, hg)) (fun cf hf => rf a (cf, hf))\n (match bodd n, bodd (div2 n) with\n | false, false => pair (ofNatCode (unpair (div2 (div2 n))).fst) (ofNatCode (unpair (div2 (div2 n))).snd)\n | false, true => comp (ofNatCode (unpair (div2 (div2 n))).fst) (ofNatCode (unpair (div2 (div2 n))).snd)\n | true, false => prec (ofNatCode (unpair (div2 (div2 n))).fst) (ofNatCode (unpair (div2 (div2 n))).snd)\n | true, true => rfind' (ofNatCode (div2 (div2 n))))",
"tactic": "cases n.bodd <;> cases n.div2.bodd <;> rfl"
},
{
"state_after": "α : Type u_1\nσ : Type u_2\ninst✝¹ : Primcodable α\ninst✝ : Primcodable σ\nc : α → Code\nhc : Primrec c\nz : α → σ\nhz : Primrec z\ns : α → σ\nhs : Primrec s\nl : α → σ\nhl : Primrec l\nr : α → σ\nhr : Primrec r\npr : α → Code × Code × σ × σ → σ\nhpr : Primrec₂ pr\nco : α → Code × Code × σ × σ → σ\nhco : Primrec₂ co\npc : α → Code × Code × σ × σ → σ\nhpc : Primrec₂ pc\nrf : α → Code × σ → σ\nhrf : Primrec₂ rf\nPR✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pr a (cf, cg, hf, hg)\nCO✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => co a (cf, cg, hf, hg)\nPC✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pc a (cf, cg, hf, hg)\nRF✝ : α → Code → σ → σ := fun a cf hf => rf a (cf, hf)\nF : α → Code → σ := fun a c => Code.recOn c (z a) (s a) (l a) (r a) (PR✝ a) (CO✝ a) (PC✝ a) (RF✝ a)\nG₁ : (α × List σ) × ℕ × ℕ → Option σ :=\n fun p =>\n let a := p.fst.fst;\n let IH := p.fst.snd;\n let n := p.snd.fst;\n let m := p.snd.snd;\n Option.bind (List.get? IH m) fun s =>\n Option.bind (List.get? IH (unpair m).fst) fun s₁ =>\n Option.map\n (fun s₂ =>\n bif bodd n then\n bif bodd (div2 n) then rf a (ofNat Code m, s)\n else pc a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else\n bif bodd (div2 n) then co a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else pr a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂))\n (List.get? IH (unpair m).snd)\n⊢ Primrec₂ fun p s =>\n Option.bind (List.get? p.fst.snd (unpair p.snd.snd).fst) fun s₁ =>\n Option.map\n (fun s₂ =>\n bif bodd p.snd.fst then\n bif bodd (div2 p.snd.fst) then rf p.fst.fst (ofNat Code p.snd.snd, s)\n else pc p.fst.fst (ofNat Code (unpair p.snd.snd).fst, ofNat Code (unpair p.snd.snd).snd, s₁, s₂)\n else\n bif bodd (div2 p.snd.fst) then\n co p.fst.fst (ofNat Code (unpair p.snd.snd).fst, ofNat Code (unpair p.snd.snd).snd, s₁, s₂)\n else pr p.fst.fst (ofNat Code (unpair p.snd.snd).fst, ofNat Code (unpair p.snd.snd).snd, s₁, s₂))\n (List.get? p.fst.snd (unpair p.snd.snd).snd)",
"state_before": "α : Type u_1\nσ : Type u_2\ninst✝¹ : Primcodable α\ninst✝ : Primcodable σ\nc : α → Code\nhc : Primrec c\nz : α → σ\nhz : Primrec z\ns : α → σ\nhs : Primrec s\nl : α → σ\nhl : Primrec l\nr : α → σ\nhr : Primrec r\npr : α → Code × Code × σ × σ → σ\nhpr : Primrec₂ pr\nco : α → Code × Code × σ × σ → σ\nhco : Primrec₂ co\npc : α → Code × Code × σ × σ → σ\nhpc : Primrec₂ pc\nrf : α → Code × σ → σ\nhrf : Primrec₂ rf\nPR✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pr a (cf, cg, hf, hg)\nCO✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => co a (cf, cg, hf, hg)\nPC✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pc a (cf, cg, hf, hg)\nRF✝ : α → Code → σ → σ := fun a cf hf => rf a (cf, hf)\nF : α → Code → σ := fun a c => Code.recOn c (z a) (s a) (l a) (r a) (PR✝ a) (CO✝ a) (PC✝ a) (RF✝ a)\nG₁ : (α × List σ) × ℕ × ℕ → Option σ :=\n fun p =>\n let a := p.fst.fst;\n let IH := p.fst.snd;\n let n := p.snd.fst;\n let m := p.snd.snd;\n Option.bind (List.get? IH m) fun s =>\n Option.bind (List.get? IH (unpair m).fst) fun s₁ =>\n Option.map\n (fun s₂ =>\n bif bodd n then\n bif bodd (div2 n) then rf a (ofNat Code m, s)\n else pc a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else\n bif bodd (div2 n) then co a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else pr a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂))\n (List.get? IH (unpair m).snd)\n⊢ Primrec G₁",
"tactic": "refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _"
},
{
"state_after": "α : Type u_1\nσ : Type u_2\ninst✝¹ : Primcodable α\ninst✝ : Primcodable σ\nc : α → Code\nhc : Primrec c\nz : α → σ\nhz : Primrec z\ns : α → σ\nhs : Primrec s\nl : α → σ\nhl : Primrec l\nr : α → σ\nhr : Primrec r\npr : α → Code × Code × σ × σ → σ\nhpr : Primrec₂ pr\nco : α → Code × Code × σ × σ → σ\nhco : Primrec₂ co\npc : α → Code × Code × σ × σ → σ\nhpc : Primrec₂ pc\nrf : α → Code × σ → σ\nhrf : Primrec₂ rf\nPR✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pr a (cf, cg, hf, hg)\nCO✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => co a (cf, cg, hf, hg)\nPC✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pc a (cf, cg, hf, hg)\nRF✝ : α → Code → σ → σ := fun a cf hf => rf a (cf, hf)\nF : α → Code → σ := fun a c => Code.recOn c (z a) (s a) (l a) (r a) (PR✝ a) (CO✝ a) (PC✝ a) (RF✝ a)\nG₁ : (α × List σ) × ℕ × ℕ → Option σ :=\n fun p =>\n let a := p.fst.fst;\n let IH := p.fst.snd;\n let n := p.snd.fst;\n let m := p.snd.snd;\n Option.bind (List.get? IH m) fun s =>\n Option.bind (List.get? IH (unpair m).fst) fun s₁ =>\n Option.map\n (fun s₂ =>\n bif bodd n then\n bif bodd (div2 n) then rf a (ofNat Code m, s)\n else pc a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else\n bif bodd (div2 n) then co a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else pr a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂))\n (List.get? IH (unpair m).snd)\n⊢ Primrec fun p =>\n (fun p s =>\n Option.bind (List.get? p.fst.snd (unpair p.snd.snd).fst) fun s₁ =>\n Option.map\n (fun s₂ =>\n bif bodd p.snd.fst then\n bif bodd (div2 p.snd.fst) then rf p.fst.fst (ofNat Code p.snd.snd, s)\n else pc p.fst.fst (ofNat Code (unpair p.snd.snd).fst, ofNat Code (unpair p.snd.snd).snd, s₁, s₂)\n else\n bif bodd (div2 p.snd.fst) then\n co p.fst.fst (ofNat Code (unpair p.snd.snd).fst, ofNat Code (unpair p.snd.snd).snd, s₁, s₂)\n else pr p.fst.fst (ofNat Code (unpair p.snd.snd).fst, ofNat Code (unpair p.snd.snd).snd, s₁, s₂))\n (List.get? p.fst.snd (unpair p.snd.snd).snd))\n p.fst p.snd",
"state_before": "α : Type u_1\nσ : Type u_2\ninst✝¹ : Primcodable α\ninst✝ : Primcodable σ\nc : α → Code\nhc : Primrec c\nz : α → σ\nhz : Primrec z\ns : α → σ\nhs : Primrec s\nl : α → σ\nhl : Primrec l\nr : α → σ\nhr : Primrec r\npr : α → Code × Code × σ × σ → σ\nhpr : Primrec₂ pr\nco : α → Code × Code × σ × σ → σ\nhco : Primrec₂ co\npc : α → Code × Code × σ × σ → σ\nhpc : Primrec₂ pc\nrf : α → Code × σ → σ\nhrf : Primrec₂ rf\nPR✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pr a (cf, cg, hf, hg)\nCO✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => co a (cf, cg, hf, hg)\nPC✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pc a (cf, cg, hf, hg)\nRF✝ : α → Code → σ → σ := fun a cf hf => rf a (cf, hf)\nF : α → Code → σ := fun a c => Code.recOn c (z a) (s a) (l a) (r a) (PR✝ a) (CO✝ a) (PC✝ a) (RF✝ a)\nG₁ : (α × List σ) × ℕ × ℕ → Option σ :=\n fun p =>\n let a := p.fst.fst;\n let IH := p.fst.snd;\n let n := p.snd.fst;\n let m := p.snd.snd;\n Option.bind (List.get? IH m) fun s =>\n Option.bind (List.get? IH (unpair m).fst) fun s₁ =>\n Option.map\n (fun s₂ =>\n bif bodd n then\n bif bodd (div2 n) then rf a (ofNat Code m, s)\n else pc a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else\n bif bodd (div2 n) then co a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else pr a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂))\n (List.get? IH (unpair m).snd)\n⊢ Primrec₂ fun p s =>\n Option.bind (List.get? p.fst.snd (unpair p.snd.snd).fst) fun s₁ =>\n Option.map\n (fun s₂ =>\n bif bodd p.snd.fst then\n bif bodd (div2 p.snd.fst) then rf p.fst.fst (ofNat Code p.snd.snd, s)\n else pc p.fst.fst (ofNat Code (unpair p.snd.snd).fst, ofNat Code (unpair p.snd.snd).snd, s₁, s₂)\n else\n bif bodd (div2 p.snd.fst) then\n co p.fst.fst (ofNat Code (unpair p.snd.snd).fst, ofNat Code (unpair p.snd.snd).snd, s₁, s₂)\n else pr p.fst.fst (ofNat Code (unpair p.snd.snd).fst, ofNat Code (unpair p.snd.snd).snd, s₁, s₂))\n (List.get? p.fst.snd (unpair p.snd.snd).snd)",
"tactic": "unfold Primrec₂"
},
{
"state_after": "α : Type u_1\nσ : Type u_2\ninst✝¹ : Primcodable α\ninst✝ : Primcodable σ\nc : α → Code\nhc : Primrec c\nz : α → σ\nhz : Primrec z\ns : α → σ\nhs : Primrec s\nl : α → σ\nhl : Primrec l\nr : α → σ\nhr : Primrec r\npr : α → Code × Code × σ × σ → σ\nhpr : Primrec₂ pr\nco : α → Code × Code × σ × σ → σ\nhco : Primrec₂ co\npc : α → Code × Code × σ × σ → σ\nhpc : Primrec₂ pc\nrf : α → Code × σ → σ\nhrf : Primrec₂ rf\nPR✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pr a (cf, cg, hf, hg)\nCO✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => co a (cf, cg, hf, hg)\nPC✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pc a (cf, cg, hf, hg)\nRF✝ : α → Code → σ → σ := fun a cf hf => rf a (cf, hf)\nF : α → Code → σ := fun a c => Code.recOn c (z a) (s a) (l a) (r a) (PR✝ a) (CO✝ a) (PC✝ a) (RF✝ a)\nG₁ : (α × List σ) × ℕ × ℕ → Option σ :=\n fun p =>\n let a := p.fst.fst;\n let IH := p.fst.snd;\n let n := p.snd.fst;\n let m := p.snd.snd;\n Option.bind (List.get? IH m) fun s =>\n Option.bind (List.get? IH (unpair m).fst) fun s₁ =>\n Option.map\n (fun s₂ =>\n bif bodd n then\n bif bodd (div2 n) then rf a (ofNat Code m, s)\n else pc a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else\n bif bodd (div2 n) then co a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else pr a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂))\n (List.get? IH (unpair m).snd)\n⊢ Primrec₂ fun p s₁ =>\n Option.map\n (fun s₂ =>\n bif bodd p.fst.snd.fst then\n bif bodd (div2 p.fst.snd.fst) then rf p.fst.fst.fst (ofNat Code p.fst.snd.snd, p.snd)\n else pc p.fst.fst.fst (ofNat Code (unpair p.fst.snd.snd).fst, ofNat Code (unpair p.fst.snd.snd).snd, s₁, s₂)\n else\n bif bodd (div2 p.fst.snd.fst) then\n co p.fst.fst.fst (ofNat Code (unpair p.fst.snd.snd).fst, ofNat Code (unpair p.fst.snd.snd).snd, s₁, s₂)\n else pr p.fst.fst.fst (ofNat Code (unpair p.fst.snd.snd).fst, ofNat Code (unpair p.fst.snd.snd).snd, s₁, s₂))\n (List.get? p.fst.fst.snd (unpair p.fst.snd.snd).snd)",
"state_before": "α : Type u_1\nσ : Type u_2\ninst✝¹ : Primcodable α\ninst✝ : Primcodable σ\nc : α → Code\nhc : Primrec c\nz : α → σ\nhz : Primrec z\ns : α → σ\nhs : Primrec s\nl : α → σ\nhl : Primrec l\nr : α → σ\nhr : Primrec r\npr : α → Code × Code × σ × σ → σ\nhpr : Primrec₂ pr\nco : α → Code × Code × σ × σ → σ\nhco : Primrec₂ co\npc : α → Code × Code × σ × σ → σ\nhpc : Primrec₂ pc\nrf : α → Code × σ → σ\nhrf : Primrec₂ rf\nPR✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pr a (cf, cg, hf, hg)\nCO✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => co a (cf, cg, hf, hg)\nPC✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pc a (cf, cg, hf, hg)\nRF✝ : α → Code → σ → σ := fun a cf hf => rf a (cf, hf)\nF : α → Code → σ := fun a c => Code.recOn c (z a) (s a) (l a) (r a) (PR✝ a) (CO✝ a) (PC✝ a) (RF✝ a)\nG₁ : (α × List σ) × ℕ × ℕ → Option σ :=\n fun p =>\n let a := p.fst.fst;\n let IH := p.fst.snd;\n let n := p.snd.fst;\n let m := p.snd.snd;\n Option.bind (List.get? IH m) fun s =>\n Option.bind (List.get? IH (unpair m).fst) fun s₁ =>\n Option.map\n (fun s₂ =>\n bif bodd n then\n bif bodd (div2 n) then rf a (ofNat Code m, s)\n else pc a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else\n bif bodd (div2 n) then co a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else pr a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂))\n (List.get? IH (unpair m).snd)\n⊢ Primrec fun p =>\n (fun p s =>\n Option.bind (List.get? p.fst.snd (unpair p.snd.snd).fst) fun s₁ =>\n Option.map\n (fun s₂ =>\n bif bodd p.snd.fst then\n bif bodd (div2 p.snd.fst) then rf p.fst.fst (ofNat Code p.snd.snd, s)\n else pc p.fst.fst (ofNat Code (unpair p.snd.snd).fst, ofNat Code (unpair p.snd.snd).snd, s₁, s₂)\n else\n bif bodd (div2 p.snd.fst) then\n co p.fst.fst (ofNat Code (unpair p.snd.snd).fst, ofNat Code (unpair p.snd.snd).snd, s₁, s₂)\n else pr p.fst.fst (ofNat Code (unpair p.snd.snd).fst, ofNat Code (unpair p.snd.snd).snd, s₁, s₂))\n (List.get? p.fst.snd (unpair p.snd.snd).snd))\n p.fst p.snd",
"tactic": "refine'\n option_bind\n ((list_get?.comp (snd.comp fst)\n (fst.comp <| Primrec.unpair.comp (snd.comp snd))).comp fst) _"
},
{
"state_after": "α : Type u_1\nσ : Type u_2\ninst✝¹ : Primcodable α\ninst✝ : Primcodable σ\nc : α → Code\nhc : Primrec c\nz : α → σ\nhz : Primrec z\ns : α → σ\nhs : Primrec s\nl : α → σ\nhl : Primrec l\nr : α → σ\nhr : Primrec r\npr : α → Code × Code × σ × σ → σ\nhpr : Primrec₂ pr\nco : α → Code × Code × σ × σ → σ\nhco : Primrec₂ co\npc : α → Code × Code × σ × σ → σ\nhpc : Primrec₂ pc\nrf : α → Code × σ → σ\nhrf : Primrec₂ rf\nPR✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pr a (cf, cg, hf, hg)\nCO✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => co a (cf, cg, hf, hg)\nPC✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pc a (cf, cg, hf, hg)\nRF✝ : α → Code → σ → σ := fun a cf hf => rf a (cf, hf)\nF : α → Code → σ := fun a c => Code.recOn c (z a) (s a) (l a) (r a) (PR✝ a) (CO✝ a) (PC✝ a) (RF✝ a)\nG₁ : (α × List σ) × ℕ × ℕ → Option σ :=\n fun p =>\n let a := p.fst.fst;\n let IH := p.fst.snd;\n let n := p.snd.fst;\n let m := p.snd.snd;\n Option.bind (List.get? IH m) fun s =>\n Option.bind (List.get? IH (unpair m).fst) fun s₁ =>\n Option.map\n (fun s₂ =>\n bif bodd n then\n bif bodd (div2 n) then rf a (ofNat Code m, s)\n else pc a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else\n bif bodd (div2 n) then co a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else pr a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂))\n (List.get? IH (unpair m).snd)\n⊢ Primrec fun p =>\n (fun p s₁ =>\n Option.map\n (fun s₂ =>\n bif bodd p.fst.snd.fst then\n bif bodd (div2 p.fst.snd.fst) then rf p.fst.fst.fst (ofNat Code p.fst.snd.snd, p.snd)\n else\n pc p.fst.fst.fst (ofNat Code (unpair p.fst.snd.snd).fst, ofNat Code (unpair p.fst.snd.snd).snd, s₁, s₂)\n else\n bif bodd (div2 p.fst.snd.fst) then\n co p.fst.fst.fst (ofNat Code (unpair p.fst.snd.snd).fst, ofNat Code (unpair p.fst.snd.snd).snd, s₁, s₂)\n else\n pr p.fst.fst.fst (ofNat Code (unpair p.fst.snd.snd).fst, ofNat Code (unpair p.fst.snd.snd).snd, s₁, s₂))\n (List.get? p.fst.fst.snd (unpair p.fst.snd.snd).snd))\n p.fst p.snd",
"state_before": "α : Type u_1\nσ : Type u_2\ninst✝¹ : Primcodable α\ninst✝ : Primcodable σ\nc : α → Code\nhc : Primrec c\nz : α → σ\nhz : Primrec z\ns : α → σ\nhs : Primrec s\nl : α → σ\nhl : Primrec l\nr : α → σ\nhr : Primrec r\npr : α → Code × Code × σ × σ → σ\nhpr : Primrec₂ pr\nco : α → Code × Code × σ × σ → σ\nhco : Primrec₂ co\npc : α → Code × Code × σ × σ → σ\nhpc : Primrec₂ pc\nrf : α → Code × σ → σ\nhrf : Primrec₂ rf\nPR✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pr a (cf, cg, hf, hg)\nCO✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => co a (cf, cg, hf, hg)\nPC✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pc a (cf, cg, hf, hg)\nRF✝ : α → Code → σ → σ := fun a cf hf => rf a (cf, hf)\nF : α → Code → σ := fun a c => Code.recOn c (z a) (s a) (l a) (r a) (PR✝ a) (CO✝ a) (PC✝ a) (RF✝ a)\nG₁ : (α × List σ) × ℕ × ℕ → Option σ :=\n fun p =>\n let a := p.fst.fst;\n let IH := p.fst.snd;\n let n := p.snd.fst;\n let m := p.snd.snd;\n Option.bind (List.get? IH m) fun s =>\n Option.bind (List.get? IH (unpair m).fst) fun s₁ =>\n Option.map\n (fun s₂ =>\n bif bodd n then\n bif bodd (div2 n) then rf a (ofNat Code m, s)\n else pc a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else\n bif bodd (div2 n) then co a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else pr a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂))\n (List.get? IH (unpair m).snd)\n⊢ Primrec₂ fun p s₁ =>\n Option.map\n (fun s₂ =>\n bif bodd p.fst.snd.fst then\n bif bodd (div2 p.fst.snd.fst) then rf p.fst.fst.fst (ofNat Code p.fst.snd.snd, p.snd)\n else pc p.fst.fst.fst (ofNat Code (unpair p.fst.snd.snd).fst, ofNat Code (unpair p.fst.snd.snd).snd, s₁, s₂)\n else\n bif bodd (div2 p.fst.snd.fst) then\n co p.fst.fst.fst (ofNat Code (unpair p.fst.snd.snd).fst, ofNat Code (unpair p.fst.snd.snd).snd, s₁, s₂)\n else pr p.fst.fst.fst (ofNat Code (unpair p.fst.snd.snd).fst, ofNat Code (unpair p.fst.snd.snd).snd, s₁, s₂))\n (List.get? p.fst.fst.snd (unpair p.fst.snd.snd).snd)",
"tactic": "unfold Primrec₂"
},
{
"state_after": "α : Type u_1\nσ : Type u_2\ninst✝¹ : Primcodable α\ninst✝ : Primcodable σ\nc : α → Code\nhc : Primrec c\nz : α → σ\nhz : Primrec z\ns : α → σ\nhs : Primrec s\nl : α → σ\nhl : Primrec l\nr : α → σ\nhr : Primrec r\npr : α → Code × Code × σ × σ → σ\nhpr : Primrec₂ pr\nco : α → Code × Code × σ × σ → σ\nhco : Primrec₂ co\npc : α → Code × Code × σ × σ → σ\nhpc : Primrec₂ pc\nrf : α → Code × σ → σ\nhrf : Primrec₂ rf\nPR✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pr a (cf, cg, hf, hg)\nCO✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => co a (cf, cg, hf, hg)\nPC✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pc a (cf, cg, hf, hg)\nRF✝ : α → Code → σ → σ := fun a cf hf => rf a (cf, hf)\nF : α → Code → σ := fun a c => Code.recOn c (z a) (s a) (l a) (r a) (PR✝ a) (CO✝ a) (PC✝ a) (RF✝ a)\nG₁ : (α × List σ) × ℕ × ℕ → Option σ :=\n fun p =>\n let a := p.fst.fst;\n let IH := p.fst.snd;\n let n := p.snd.fst;\n let m := p.snd.snd;\n Option.bind (List.get? IH m) fun s =>\n Option.bind (List.get? IH (unpair m).fst) fun s₁ =>\n Option.map\n (fun s₂ =>\n bif bodd n then\n bif bodd (div2 n) then rf a (ofNat Code m, s)\n else pc a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else\n bif bodd (div2 n) then co a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else pr a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂))\n (List.get? IH (unpair m).snd)\n⊢ Primrec₂ fun p s₂ =>\n bif bodd p.fst.fst.snd.fst then\n bif bodd (div2 p.fst.fst.snd.fst) then rf p.fst.fst.fst.fst (ofNat Code p.fst.fst.snd.snd, p.fst.snd)\n else\n pc p.fst.fst.fst.fst\n (ofNat Code (unpair p.fst.fst.snd.snd).fst, ofNat Code (unpair p.fst.fst.snd.snd).snd, p.snd, s₂)\n else\n bif bodd (div2 p.fst.fst.snd.fst) then\n co p.fst.fst.fst.fst\n (ofNat Code (unpair p.fst.fst.snd.snd).fst, ofNat Code (unpair p.fst.fst.snd.snd).snd, p.snd, s₂)\n else\n pr p.fst.fst.fst.fst\n (ofNat Code (unpair p.fst.fst.snd.snd).fst, ofNat Code (unpair p.fst.fst.snd.snd).snd, p.snd, s₂)",
"state_before": "α : Type u_1\nσ : Type u_2\ninst✝¹ : Primcodable α\ninst✝ : Primcodable σ\nc : α → Code\nhc : Primrec c\nz : α → σ\nhz : Primrec z\ns : α → σ\nhs : Primrec s\nl : α → σ\nhl : Primrec l\nr : α → σ\nhr : Primrec r\npr : α → Code × Code × σ × σ → σ\nhpr : Primrec₂ pr\nco : α → Code × Code × σ × σ → σ\nhco : Primrec₂ co\npc : α → Code × Code × σ × σ → σ\nhpc : Primrec₂ pc\nrf : α → Code × σ → σ\nhrf : Primrec₂ rf\nPR✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pr a (cf, cg, hf, hg)\nCO✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => co a (cf, cg, hf, hg)\nPC✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pc a (cf, cg, hf, hg)\nRF✝ : α → Code → σ → σ := fun a cf hf => rf a (cf, hf)\nF : α → Code → σ := fun a c => Code.recOn c (z a) (s a) (l a) (r a) (PR✝ a) (CO✝ a) (PC✝ a) (RF✝ a)\nG₁ : (α × List σ) × ℕ × ℕ → Option σ :=\n fun p =>\n let a := p.fst.fst;\n let IH := p.fst.snd;\n let n := p.snd.fst;\n let m := p.snd.snd;\n Option.bind (List.get? IH m) fun s =>\n Option.bind (List.get? IH (unpair m).fst) fun s₁ =>\n Option.map\n (fun s₂ =>\n bif bodd n then\n bif bodd (div2 n) then rf a (ofNat Code m, s)\n else pc a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else\n bif bodd (div2 n) then co a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else pr a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂))\n (List.get? IH (unpair m).snd)\n⊢ Primrec fun p =>\n (fun p s₁ =>\n Option.map\n (fun s₂ =>\n bif bodd p.fst.snd.fst then\n bif bodd (div2 p.fst.snd.fst) then rf p.fst.fst.fst (ofNat Code p.fst.snd.snd, p.snd)\n else\n pc p.fst.fst.fst (ofNat Code (unpair p.fst.snd.snd).fst, ofNat Code (unpair p.fst.snd.snd).snd, s₁, s₂)\n else\n bif bodd (div2 p.fst.snd.fst) then\n co p.fst.fst.fst (ofNat Code (unpair p.fst.snd.snd).fst, ofNat Code (unpair p.fst.snd.snd).snd, s₁, s₂)\n else\n pr p.fst.fst.fst (ofNat Code (unpair p.fst.snd.snd).fst, ofNat Code (unpair p.fst.snd.snd).snd, s₁, s₂))\n (List.get? p.fst.fst.snd (unpair p.fst.snd.snd).snd))\n p.fst p.snd",
"tactic": "refine'\n option_map\n ((list_get?.comp (snd.comp fst)\n (snd.comp <| Primrec.unpair.comp (snd.comp snd))).comp <| fst.comp fst) _"
},
{
"state_after": "α : Type u_1\nσ : Type u_2\ninst✝¹ : Primcodable α\ninst✝ : Primcodable σ\nc : α → Code\nhc : Primrec c\nz : α → σ\nhz : Primrec z\ns : α → σ\nhs : Primrec s\nl : α → σ\nhl : Primrec l\nr : α → σ\nhr : Primrec r\npr : α → Code × Code × σ × σ → σ\nhpr : Primrec₂ pr\nco : α → Code × Code × σ × σ → σ\nhco : Primrec₂ co\npc : α → Code × Code × σ × σ → σ\nhpc : Primrec₂ pc\nrf : α → Code × σ → σ\nhrf : Primrec₂ rf\nPR✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pr a (cf, cg, hf, hg)\nCO✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => co a (cf, cg, hf, hg)\nPC✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pc a (cf, cg, hf, hg)\nRF✝ : α → Code → σ → σ := fun a cf hf => rf a (cf, hf)\nF : α → Code → σ := fun a c => Code.recOn c (z a) (s a) (l a) (r a) (PR✝ a) (CO✝ a) (PC✝ a) (RF✝ a)\nG₁ : (α × List σ) × ℕ × ℕ → Option σ :=\n fun p =>\n let a := p.fst.fst;\n let IH := p.fst.snd;\n let n := p.snd.fst;\n let m := p.snd.snd;\n Option.bind (List.get? IH m) fun s =>\n Option.bind (List.get? IH (unpair m).fst) fun s₁ =>\n Option.map\n (fun s₂ =>\n bif bodd n then\n bif bodd (div2 n) then rf a (ofNat Code m, s)\n else pc a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else\n bif bodd (div2 n) then co a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else pr a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂))\n (List.get? IH (unpair m).snd)\na : Primrec fun p => p.fst.fst.fst.fst.fst\n⊢ Primrec₂ fun p s₂ =>\n bif bodd p.fst.fst.snd.fst then\n bif bodd (div2 p.fst.fst.snd.fst) then rf p.fst.fst.fst.fst (ofNat Code p.fst.fst.snd.snd, p.fst.snd)\n else\n pc p.fst.fst.fst.fst\n (ofNat Code (unpair p.fst.fst.snd.snd).fst, ofNat Code (unpair p.fst.fst.snd.snd).snd, p.snd, s₂)\n else\n bif bodd (div2 p.fst.fst.snd.fst) then\n co p.fst.fst.fst.fst\n (ofNat Code (unpair p.fst.fst.snd.snd).fst, ofNat Code (unpair p.fst.fst.snd.snd).snd, p.snd, s₂)\n else\n pr p.fst.fst.fst.fst\n (ofNat Code (unpair p.fst.fst.snd.snd).fst, ofNat Code (unpair p.fst.fst.snd.snd).snd, p.snd, s₂)",
"state_before": "α : Type u_1\nσ : Type u_2\ninst✝¹ : Primcodable α\ninst✝ : Primcodable σ\nc : α → Code\nhc : Primrec c\nz : α → σ\nhz : Primrec z\ns : α → σ\nhs : Primrec s\nl : α → σ\nhl : Primrec l\nr : α → σ\nhr : Primrec r\npr : α → Code × Code × σ × σ → σ\nhpr : Primrec₂ pr\nco : α → Code × Code × σ × σ → σ\nhco : Primrec₂ co\npc : α → Code × Code × σ × σ → σ\nhpc : Primrec₂ pc\nrf : α → Code × σ → σ\nhrf : Primrec₂ rf\nPR✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pr a (cf, cg, hf, hg)\nCO✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => co a (cf, cg, hf, hg)\nPC✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pc a (cf, cg, hf, hg)\nRF✝ : α → Code → σ → σ := fun a cf hf => rf a (cf, hf)\nF : α → Code → σ := fun a c => Code.recOn c (z a) (s a) (l a) (r a) (PR✝ a) (CO✝ a) (PC✝ a) (RF✝ a)\nG₁ : (α × List σ) × ℕ × ℕ → Option σ :=\n fun p =>\n let a := p.fst.fst;\n let IH := p.fst.snd;\n let n := p.snd.fst;\n let m := p.snd.snd;\n Option.bind (List.get? IH m) fun s =>\n Option.bind (List.get? IH (unpair m).fst) fun s₁ =>\n Option.map\n (fun s₂ =>\n bif bodd n then\n bif bodd (div2 n) then rf a (ofNat Code m, s)\n else pc a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else\n bif bodd (div2 n) then co a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else pr a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂))\n (List.get? IH (unpair m).snd)\n⊢ Primrec₂ fun p s₂ =>\n bif bodd p.fst.fst.snd.fst then\n bif bodd (div2 p.fst.fst.snd.fst) then rf p.fst.fst.fst.fst (ofNat Code p.fst.fst.snd.snd, p.fst.snd)\n else\n pc p.fst.fst.fst.fst\n (ofNat Code (unpair p.fst.fst.snd.snd).fst, ofNat Code (unpair p.fst.fst.snd.snd).snd, p.snd, s₂)\n else\n bif bodd (div2 p.fst.fst.snd.fst) then\n co p.fst.fst.fst.fst\n (ofNat Code (unpair p.fst.fst.snd.snd).fst, ofNat Code (unpair p.fst.fst.snd.snd).snd, p.snd, s₂)\n else\n pr p.fst.fst.fst.fst\n (ofNat Code (unpair p.fst.fst.snd.snd).fst, ofNat Code (unpair p.fst.fst.snd.snd).snd, p.snd, s₂)",
"tactic": "have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) :=\n fst.comp (fst.comp <| fst.comp <| fst.comp fst)"
},
{
"state_after": "α : Type u_1\nσ : Type u_2\ninst✝¹ : Primcodable α\ninst✝ : Primcodable σ\nc : α → Code\nhc : Primrec c\nz : α → σ\nhz : Primrec z\ns : α → σ\nhs : Primrec s\nl : α → σ\nhl : Primrec l\nr : α → σ\nhr : Primrec r\npr : α → Code × Code × σ × σ → σ\nhpr : Primrec₂ pr\nco : α → Code × Code × σ × σ → σ\nhco : Primrec₂ co\npc : α → Code × Code × σ × σ → σ\nhpc : Primrec₂ pc\nrf : α → Code × σ → σ\nhrf : Primrec₂ rf\nPR✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pr a (cf, cg, hf, hg)\nCO✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => co a (cf, cg, hf, hg)\nPC✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pc a (cf, cg, hf, hg)\nRF✝ : α → Code → σ → σ := fun a cf hf => rf a (cf, hf)\nF : α → Code → σ := fun a c => Code.recOn c (z a) (s a) (l a) (r a) (PR✝ a) (CO✝ a) (PC✝ a) (RF✝ a)\nG₁ : (α × List σ) × ℕ × ℕ → Option σ :=\n fun p =>\n let a := p.fst.fst;\n let IH := p.fst.snd;\n let n := p.snd.fst;\n let m := p.snd.snd;\n Option.bind (List.get? IH m) fun s =>\n Option.bind (List.get? IH (unpair m).fst) fun s₁ =>\n Option.map\n (fun s₂ =>\n bif bodd n then\n bif bodd (div2 n) then rf a (ofNat Code m, s)\n else pc a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else\n bif bodd (div2 n) then co a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else pr a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂))\n (List.get? IH (unpair m).snd)\na : Primrec fun p => p.fst.fst.fst.fst.fst\nn : Primrec fun p => p.fst.fst.fst.snd.fst\n⊢ Primrec₂ fun p s₂ =>\n bif bodd p.fst.fst.snd.fst then\n bif bodd (div2 p.fst.fst.snd.fst) then rf p.fst.fst.fst.fst (ofNat Code p.fst.fst.snd.snd, p.fst.snd)\n else\n pc p.fst.fst.fst.fst\n (ofNat Code (unpair p.fst.fst.snd.snd).fst, ofNat Code (unpair p.fst.fst.snd.snd).snd, p.snd, s₂)\n else\n bif bodd (div2 p.fst.fst.snd.fst) then\n co p.fst.fst.fst.fst\n (ofNat Code (unpair p.fst.fst.snd.snd).fst, ofNat Code (unpair p.fst.fst.snd.snd).snd, p.snd, s₂)\n else\n pr p.fst.fst.fst.fst\n (ofNat Code (unpair p.fst.fst.snd.snd).fst, ofNat Code (unpair p.fst.fst.snd.snd).snd, p.snd, s₂)",
"state_before": "α : Type u_1\nσ : Type u_2\ninst✝¹ : Primcodable α\ninst✝ : Primcodable σ\nc : α → Code\nhc : Primrec c\nz : α → σ\nhz : Primrec z\ns : α → σ\nhs : Primrec s\nl : α → σ\nhl : Primrec l\nr : α → σ\nhr : Primrec r\npr : α → Code × Code × σ × σ → σ\nhpr : Primrec₂ pr\nco : α → Code × Code × σ × σ → σ\nhco : Primrec₂ co\npc : α → Code × Code × σ × σ → σ\nhpc : Primrec₂ pc\nrf : α → Code × σ → σ\nhrf : Primrec₂ rf\nPR✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pr a (cf, cg, hf, hg)\nCO✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => co a (cf, cg, hf, hg)\nPC✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pc a (cf, cg, hf, hg)\nRF✝ : α → Code → σ → σ := fun a cf hf => rf a (cf, hf)\nF : α → Code → σ := fun a c => Code.recOn c (z a) (s a) (l a) (r a) (PR✝ a) (CO✝ a) (PC✝ a) (RF✝ a)\nG₁ : (α × List σ) × ℕ × ℕ → Option σ :=\n fun p =>\n let a := p.fst.fst;\n let IH := p.fst.snd;\n let n := p.snd.fst;\n let m := p.snd.snd;\n Option.bind (List.get? IH m) fun s =>\n Option.bind (List.get? IH (unpair m).fst) fun s₁ =>\n Option.map\n (fun s₂ =>\n bif bodd n then\n bif bodd (div2 n) then rf a (ofNat Code m, s)\n else pc a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else\n bif bodd (div2 n) then co a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else pr a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂))\n (List.get? IH (unpair m).snd)\na : Primrec fun p => p.fst.fst.fst.fst.fst\n⊢ Primrec₂ fun p s₂ =>\n bif bodd p.fst.fst.snd.fst then\n bif bodd (div2 p.fst.fst.snd.fst) then rf p.fst.fst.fst.fst (ofNat Code p.fst.fst.snd.snd, p.fst.snd)\n else\n pc p.fst.fst.fst.fst\n (ofNat Code (unpair p.fst.fst.snd.snd).fst, ofNat Code (unpair p.fst.fst.snd.snd).snd, p.snd, s₂)\n else\n bif bodd (div2 p.fst.fst.snd.fst) then\n co p.fst.fst.fst.fst\n (ofNat Code (unpair p.fst.fst.snd.snd).fst, ofNat Code (unpair p.fst.fst.snd.snd).snd, p.snd, s₂)\n else\n pr p.fst.fst.fst.fst\n (ofNat Code (unpair p.fst.fst.snd.snd).fst, ofNat Code (unpair p.fst.fst.snd.snd).snd, p.snd, s₂)",
"tactic": "have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) :=\n fst.comp (snd.comp <| fst.comp <| fst.comp fst)"
},
{
"state_after": "α : Type u_1\nσ : Type u_2\ninst✝¹ : Primcodable α\ninst✝ : Primcodable σ\nc : α → Code\nhc : Primrec c\nz : α → σ\nhz : Primrec z\ns : α → σ\nhs : Primrec s\nl : α → σ\nhl : Primrec l\nr : α → σ\nhr : Primrec r\npr : α → Code × Code × σ × σ → σ\nhpr : Primrec₂ pr\nco : α → Code × Code × σ × σ → σ\nhco : Primrec₂ co\npc : α → Code × Code × σ × σ → σ\nhpc : Primrec₂ pc\nrf : α → Code × σ → σ\nhrf : Primrec₂ rf\nPR✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pr a (cf, cg, hf, hg)\nCO✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => co a (cf, cg, hf, hg)\nPC✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pc a (cf, cg, hf, hg)\nRF✝ : α → Code → σ → σ := fun a cf hf => rf a (cf, hf)\nF : α → Code → σ := fun a c => Code.recOn c (z a) (s a) (l a) (r a) (PR✝ a) (CO✝ a) (PC✝ a) (RF✝ a)\nG₁ : (α × List σ) × ℕ × ℕ → Option σ :=\n fun p =>\n let a := p.fst.fst;\n let IH := p.fst.snd;\n let n := p.snd.fst;\n let m := p.snd.snd;\n Option.bind (List.get? IH m) fun s =>\n Option.bind (List.get? IH (unpair m).fst) fun s₁ =>\n Option.map\n (fun s₂ =>\n bif bodd n then\n bif bodd (div2 n) then rf a (ofNat Code m, s)\n else pc a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else\n bif bodd (div2 n) then co a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else pr a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂))\n (List.get? IH (unpair m).snd)\na : Primrec fun p => p.fst.fst.fst.fst.fst\nn : Primrec fun p => p.fst.fst.fst.snd.fst\nm : Primrec fun p => p.fst.fst.fst.snd.snd\n⊢ Primrec₂ fun p s₂ =>\n bif bodd p.fst.fst.snd.fst then\n bif bodd (div2 p.fst.fst.snd.fst) then rf p.fst.fst.fst.fst (ofNat Code p.fst.fst.snd.snd, p.fst.snd)\n else\n pc p.fst.fst.fst.fst\n (ofNat Code (unpair p.fst.fst.snd.snd).fst, ofNat Code (unpair p.fst.fst.snd.snd).snd, p.snd, s₂)\n else\n bif bodd (div2 p.fst.fst.snd.fst) then\n co p.fst.fst.fst.fst\n (ofNat Code (unpair p.fst.fst.snd.snd).fst, ofNat Code (unpair p.fst.fst.snd.snd).snd, p.snd, s₂)\n else\n pr p.fst.fst.fst.fst\n (ofNat Code (unpair p.fst.fst.snd.snd).fst, ofNat Code (unpair p.fst.fst.snd.snd).snd, p.snd, s₂)",
"state_before": "α : Type u_1\nσ : Type u_2\ninst✝¹ : Primcodable α\ninst✝ : Primcodable σ\nc : α → Code\nhc : Primrec c\nz : α → σ\nhz : Primrec z\ns : α → σ\nhs : Primrec s\nl : α → σ\nhl : Primrec l\nr : α → σ\nhr : Primrec r\npr : α → Code × Code × σ × σ → σ\nhpr : Primrec₂ pr\nco : α → Code × Code × σ × σ → σ\nhco : Primrec₂ co\npc : α → Code × Code × σ × σ → σ\nhpc : Primrec₂ pc\nrf : α → Code × σ → σ\nhrf : Primrec₂ rf\nPR✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pr a (cf, cg, hf, hg)\nCO✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => co a (cf, cg, hf, hg)\nPC✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pc a (cf, cg, hf, hg)\nRF✝ : α → Code → σ → σ := fun a cf hf => rf a (cf, hf)\nF : α → Code → σ := fun a c => Code.recOn c (z a) (s a) (l a) (r a) (PR✝ a) (CO✝ a) (PC✝ a) (RF✝ a)\nG₁ : (α × List σ) × ℕ × ℕ → Option σ :=\n fun p =>\n let a := p.fst.fst;\n let IH := p.fst.snd;\n let n := p.snd.fst;\n let m := p.snd.snd;\n Option.bind (List.get? IH m) fun s =>\n Option.bind (List.get? IH (unpair m).fst) fun s₁ =>\n Option.map\n (fun s₂ =>\n bif bodd n then\n bif bodd (div2 n) then rf a (ofNat Code m, s)\n else pc a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else\n bif bodd (div2 n) then co a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else pr a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂))\n (List.get? IH (unpair m).snd)\na : Primrec fun p => p.fst.fst.fst.fst.fst\nn : Primrec fun p => p.fst.fst.fst.snd.fst\n⊢ Primrec₂ fun p s₂ =>\n bif bodd p.fst.fst.snd.fst then\n bif bodd (div2 p.fst.fst.snd.fst) then rf p.fst.fst.fst.fst (ofNat Code p.fst.fst.snd.snd, p.fst.snd)\n else\n pc p.fst.fst.fst.fst\n (ofNat Code (unpair p.fst.fst.snd.snd).fst, ofNat Code (unpair p.fst.fst.snd.snd).snd, p.snd, s₂)\n else\n bif bodd (div2 p.fst.fst.snd.fst) then\n co p.fst.fst.fst.fst\n (ofNat Code (unpair p.fst.fst.snd.snd).fst, ofNat Code (unpair p.fst.fst.snd.snd).snd, p.snd, s₂)\n else\n pr p.fst.fst.fst.fst\n (ofNat Code (unpair p.fst.fst.snd.snd).fst, ofNat Code (unpair p.fst.fst.snd.snd).snd, p.snd, s₂)",
"tactic": "have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) :=\n snd.comp (snd.comp <| fst.comp <| fst.comp fst)"
},
{
"state_after": "α : Type u_1\nσ : Type u_2\ninst✝¹ : Primcodable α\ninst✝ : Primcodable σ\nc : α → Code\nhc : Primrec c\nz : α → σ\nhz : Primrec z\ns : α → σ\nhs : Primrec s\nl : α → σ\nhl : Primrec l\nr : α → σ\nhr : Primrec r\npr : α → Code × Code × σ × σ → σ\nhpr : Primrec₂ pr\nco : α → Code × Code × σ × σ → σ\nhco : Primrec₂ co\npc : α → Code × Code × σ × σ → σ\nhpc : Primrec₂ pc\nrf : α → Code × σ → σ\nhrf : Primrec₂ rf\nPR✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pr a (cf, cg, hf, hg)\nCO✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => co a (cf, cg, hf, hg)\nPC✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pc a (cf, cg, hf, hg)\nRF✝ : α → Code → σ → σ := fun a cf hf => rf a (cf, hf)\nF : α → Code → σ := fun a c => Code.recOn c (z a) (s a) (l a) (r a) (PR✝ a) (CO✝ a) (PC✝ a) (RF✝ a)\nG₁ : (α × List σ) × ℕ × ℕ → Option σ :=\n fun p =>\n let a := p.fst.fst;\n let IH := p.fst.snd;\n let n := p.snd.fst;\n let m := p.snd.snd;\n Option.bind (List.get? IH m) fun s =>\n Option.bind (List.get? IH (unpair m).fst) fun s₁ =>\n Option.map\n (fun s₂ =>\n bif bodd n then\n bif bodd (div2 n) then rf a (ofNat Code m, s)\n else pc a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else\n bif bodd (div2 n) then co a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else pr a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂))\n (List.get? IH (unpair m).snd)\na : Primrec fun p => p.fst.fst.fst.fst.fst\nn : Primrec fun p => p.fst.fst.fst.snd.fst\nm : Primrec fun p => p.fst.fst.fst.snd.snd\nm₁ : Primrec fun a => (unpair a.fst.fst.fst.snd.snd).fst\n⊢ Primrec₂ fun p s₂ =>\n bif bodd p.fst.fst.snd.fst then\n bif bodd (div2 p.fst.fst.snd.fst) then rf p.fst.fst.fst.fst (ofNat Code p.fst.fst.snd.snd, p.fst.snd)\n else\n pc p.fst.fst.fst.fst\n (ofNat Code (unpair p.fst.fst.snd.snd).fst, ofNat Code (unpair p.fst.fst.snd.snd).snd, p.snd, s₂)\n else\n bif bodd (div2 p.fst.fst.snd.fst) then\n co p.fst.fst.fst.fst\n (ofNat Code (unpair p.fst.fst.snd.snd).fst, ofNat Code (unpair p.fst.fst.snd.snd).snd, p.snd, s₂)\n else\n pr p.fst.fst.fst.fst\n (ofNat Code (unpair p.fst.fst.snd.snd).fst, ofNat Code (unpair p.fst.fst.snd.snd).snd, p.snd, s₂)",
"state_before": "α : Type u_1\nσ : Type u_2\ninst✝¹ : Primcodable α\ninst✝ : Primcodable σ\nc : α → Code\nhc : Primrec c\nz : α → σ\nhz : Primrec z\ns : α → σ\nhs : Primrec s\nl : α → σ\nhl : Primrec l\nr : α → σ\nhr : Primrec r\npr : α → Code × Code × σ × σ → σ\nhpr : Primrec₂ pr\nco : α → Code × Code × σ × σ → σ\nhco : Primrec₂ co\npc : α → Code × Code × σ × σ → σ\nhpc : Primrec₂ pc\nrf : α → Code × σ → σ\nhrf : Primrec₂ rf\nPR✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pr a (cf, cg, hf, hg)\nCO✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => co a (cf, cg, hf, hg)\nPC✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pc a (cf, cg, hf, hg)\nRF✝ : α → Code → σ → σ := fun a cf hf => rf a (cf, hf)\nF : α → Code → σ := fun a c => Code.recOn c (z a) (s a) (l a) (r a) (PR✝ a) (CO✝ a) (PC✝ a) (RF✝ a)\nG₁ : (α × List σ) × ℕ × ℕ → Option σ :=\n fun p =>\n let a := p.fst.fst;\n let IH := p.fst.snd;\n let n := p.snd.fst;\n let m := p.snd.snd;\n Option.bind (List.get? IH m) fun s =>\n Option.bind (List.get? IH (unpair m).fst) fun s₁ =>\n Option.map\n (fun s₂ =>\n bif bodd n then\n bif bodd (div2 n) then rf a (ofNat Code m, s)\n else pc a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else\n bif bodd (div2 n) then co a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else pr a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂))\n (List.get? IH (unpair m).snd)\na : Primrec fun p => p.fst.fst.fst.fst.fst\nn : Primrec fun p => p.fst.fst.fst.snd.fst\nm : Primrec fun p => p.fst.fst.fst.snd.snd\n⊢ Primrec₂ fun p s₂ =>\n bif bodd p.fst.fst.snd.fst then\n bif bodd (div2 p.fst.fst.snd.fst) then rf p.fst.fst.fst.fst (ofNat Code p.fst.fst.snd.snd, p.fst.snd)\n else\n pc p.fst.fst.fst.fst\n (ofNat Code (unpair p.fst.fst.snd.snd).fst, ofNat Code (unpair p.fst.fst.snd.snd).snd, p.snd, s₂)\n else\n bif bodd (div2 p.fst.fst.snd.fst) then\n co p.fst.fst.fst.fst\n (ofNat Code (unpair p.fst.fst.snd.snd).fst, ofNat Code (unpair p.fst.fst.snd.snd).snd, p.snd, s₂)\n else\n pr p.fst.fst.fst.fst\n (ofNat Code (unpair p.fst.fst.snd.snd).fst, ofNat Code (unpair p.fst.fst.snd.snd).snd, p.snd, s₂)",
"tactic": "have m₁ := fst.comp (Primrec.unpair.comp m)"
},
{
"state_after": "α : Type u_1\nσ : Type u_2\ninst✝¹ : Primcodable α\ninst✝ : Primcodable σ\nc : α → Code\nhc : Primrec c\nz : α → σ\nhz : Primrec z\ns : α → σ\nhs : Primrec s\nl : α → σ\nhl : Primrec l\nr : α → σ\nhr : Primrec r\npr : α → Code × Code × σ × σ → σ\nhpr : Primrec₂ pr\nco : α → Code × Code × σ × σ → σ\nhco : Primrec₂ co\npc : α → Code × Code × σ × σ → σ\nhpc : Primrec₂ pc\nrf : α → Code × σ → σ\nhrf : Primrec₂ rf\nPR✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pr a (cf, cg, hf, hg)\nCO✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => co a (cf, cg, hf, hg)\nPC✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pc a (cf, cg, hf, hg)\nRF✝ : α → Code → σ → σ := fun a cf hf => rf a (cf, hf)\nF : α → Code → σ := fun a c => Code.recOn c (z a) (s a) (l a) (r a) (PR✝ a) (CO✝ a) (PC✝ a) (RF✝ a)\nG₁ : (α × List σ) × ℕ × ℕ → Option σ :=\n fun p =>\n let a := p.fst.fst;\n let IH := p.fst.snd;\n let n := p.snd.fst;\n let m := p.snd.snd;\n Option.bind (List.get? IH m) fun s =>\n Option.bind (List.get? IH (unpair m).fst) fun s₁ =>\n Option.map\n (fun s₂ =>\n bif bodd n then\n bif bodd (div2 n) then rf a (ofNat Code m, s)\n else pc a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else\n bif bodd (div2 n) then co a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else pr a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂))\n (List.get? IH (unpair m).snd)\na : Primrec fun p => p.fst.fst.fst.fst.fst\nn : Primrec fun p => p.fst.fst.fst.snd.fst\nm : Primrec fun p => p.fst.fst.fst.snd.snd\nm₁ : Primrec fun a => (unpair a.fst.fst.fst.snd.snd).fst\nm₂ : Primrec fun a => (unpair a.fst.fst.fst.snd.snd).snd\n⊢ Primrec₂ fun p s₂ =>\n bif bodd p.fst.fst.snd.fst then\n bif bodd (div2 p.fst.fst.snd.fst) then rf p.fst.fst.fst.fst (ofNat Code p.fst.fst.snd.snd, p.fst.snd)\n else\n pc p.fst.fst.fst.fst\n (ofNat Code (unpair p.fst.fst.snd.snd).fst, ofNat Code (unpair p.fst.fst.snd.snd).snd, p.snd, s₂)\n else\n bif bodd (div2 p.fst.fst.snd.fst) then\n co p.fst.fst.fst.fst\n (ofNat Code (unpair p.fst.fst.snd.snd).fst, ofNat Code (unpair p.fst.fst.snd.snd).snd, p.snd, s₂)\n else\n pr p.fst.fst.fst.fst\n (ofNat Code (unpair p.fst.fst.snd.snd).fst, ofNat Code (unpair p.fst.fst.snd.snd).snd, p.snd, s₂)",
"state_before": "α : Type u_1\nσ : Type u_2\ninst✝¹ : Primcodable α\ninst✝ : Primcodable σ\nc : α → Code\nhc : Primrec c\nz : α → σ\nhz : Primrec z\ns : α → σ\nhs : Primrec s\nl : α → σ\nhl : Primrec l\nr : α → σ\nhr : Primrec r\npr : α → Code × Code × σ × σ → σ\nhpr : Primrec₂ pr\nco : α → Code × Code × σ × σ → σ\nhco : Primrec₂ co\npc : α → Code × Code × σ × σ → σ\nhpc : Primrec₂ pc\nrf : α → Code × σ → σ\nhrf : Primrec₂ rf\nPR✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pr a (cf, cg, hf, hg)\nCO✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => co a (cf, cg, hf, hg)\nPC✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pc a (cf, cg, hf, hg)\nRF✝ : α → Code → σ → σ := fun a cf hf => rf a (cf, hf)\nF : α → Code → σ := fun a c => Code.recOn c (z a) (s a) (l a) (r a) (PR✝ a) (CO✝ a) (PC✝ a) (RF✝ a)\nG₁ : (α × List σ) × ℕ × ℕ → Option σ :=\n fun p =>\n let a := p.fst.fst;\n let IH := p.fst.snd;\n let n := p.snd.fst;\n let m := p.snd.snd;\n Option.bind (List.get? IH m) fun s =>\n Option.bind (List.get? IH (unpair m).fst) fun s₁ =>\n Option.map\n (fun s₂ =>\n bif bodd n then\n bif bodd (div2 n) then rf a (ofNat Code m, s)\n else pc a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else\n bif bodd (div2 n) then co a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else pr a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂))\n (List.get? IH (unpair m).snd)\na : Primrec fun p => p.fst.fst.fst.fst.fst\nn : Primrec fun p => p.fst.fst.fst.snd.fst\nm : Primrec fun p => p.fst.fst.fst.snd.snd\nm₁ : Primrec fun a => (unpair a.fst.fst.fst.snd.snd).fst\n⊢ Primrec₂ fun p s₂ =>\n bif bodd p.fst.fst.snd.fst then\n bif bodd (div2 p.fst.fst.snd.fst) then rf p.fst.fst.fst.fst (ofNat Code p.fst.fst.snd.snd, p.fst.snd)\n else\n pc p.fst.fst.fst.fst\n (ofNat Code (unpair p.fst.fst.snd.snd).fst, ofNat Code (unpair p.fst.fst.snd.snd).snd, p.snd, s₂)\n else\n bif bodd (div2 p.fst.fst.snd.fst) then\n co p.fst.fst.fst.fst\n (ofNat Code (unpair p.fst.fst.snd.snd).fst, ofNat Code (unpair p.fst.fst.snd.snd).snd, p.snd, s₂)\n else\n pr p.fst.fst.fst.fst\n (ofNat Code (unpair p.fst.fst.snd.snd).fst, ofNat Code (unpair p.fst.fst.snd.snd).snd, p.snd, s₂)",
"tactic": "have m₂ := snd.comp (Primrec.unpair.comp m)"
},
{
"state_after": "α : Type u_1\nσ : Type u_2\ninst✝¹ : Primcodable α\ninst✝ : Primcodable σ\nc : α → Code\nhc : Primrec c\nz : α → σ\nhz : Primrec z\ns✝ : α → σ\nhs : Primrec s✝\nl : α → σ\nhl : Primrec l\nr : α → σ\nhr : Primrec r\npr : α → Code × Code × σ × σ → σ\nhpr : Primrec₂ pr\nco : α → Code × Code × σ × σ → σ\nhco : Primrec₂ co\npc : α → Code × Code × σ × σ → σ\nhpc : Primrec₂ pc\nrf : α → Code × σ → σ\nhrf : Primrec₂ rf\nPR✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pr a (cf, cg, hf, hg)\nCO✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => co a (cf, cg, hf, hg)\nPC✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pc a (cf, cg, hf, hg)\nRF✝ : α → Code → σ → σ := fun a cf hf => rf a (cf, hf)\nF : α → Code → σ := fun a c => Code.recOn c (z a) (s✝ a) (l a) (r a) (PR✝ a) (CO✝ a) (PC✝ a) (RF✝ a)\nG₁ : (α × List σ) × ℕ × ℕ → Option σ :=\n fun p =>\n let a := p.fst.fst;\n let IH := p.fst.snd;\n let n := p.snd.fst;\n let m := p.snd.snd;\n Option.bind (List.get? IH m) fun s =>\n Option.bind (List.get? IH (unpair m).fst) fun s₁ =>\n Option.map\n (fun s₂ =>\n bif bodd n then\n bif bodd (div2 n) then rf a (ofNat Code m, s)\n else pc a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else\n bif bodd (div2 n) then co a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else pr a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂))\n (List.get? IH (unpair m).snd)\na : Primrec fun p => p.fst.fst.fst.fst.fst\nn : Primrec fun p => p.fst.fst.fst.snd.fst\nm : Primrec fun p => p.fst.fst.fst.snd.snd\nm₁ : Primrec fun a => (unpair a.fst.fst.fst.snd.snd).fst\nm₂ : Primrec fun a => (unpair a.fst.fst.fst.snd.snd).snd\ns : Primrec fun p => p.fst.fst.snd\n⊢ Primrec₂ fun p s₂ =>\n bif bodd p.fst.fst.snd.fst then\n bif bodd (div2 p.fst.fst.snd.fst) then rf p.fst.fst.fst.fst (ofNat Code p.fst.fst.snd.snd, p.fst.snd)\n else\n pc p.fst.fst.fst.fst\n (ofNat Code (unpair p.fst.fst.snd.snd).fst, ofNat Code (unpair p.fst.fst.snd.snd).snd, p.snd, s₂)\n else\n bif bodd (div2 p.fst.fst.snd.fst) then\n co p.fst.fst.fst.fst\n (ofNat Code (unpair p.fst.fst.snd.snd).fst, ofNat Code (unpair p.fst.fst.snd.snd).snd, p.snd, s₂)\n else\n pr p.fst.fst.fst.fst\n (ofNat Code (unpair p.fst.fst.snd.snd).fst, ofNat Code (unpair p.fst.fst.snd.snd).snd, p.snd, s₂)",
"state_before": "α : Type u_1\nσ : Type u_2\ninst✝¹ : Primcodable α\ninst✝ : Primcodable σ\nc : α → Code\nhc : Primrec c\nz : α → σ\nhz : Primrec z\ns : α → σ\nhs : Primrec s\nl : α → σ\nhl : Primrec l\nr : α → σ\nhr : Primrec r\npr : α → Code × Code × σ × σ → σ\nhpr : Primrec₂ pr\nco : α → Code × Code × σ × σ → σ\nhco : Primrec₂ co\npc : α → Code × Code × σ × σ → σ\nhpc : Primrec₂ pc\nrf : α → Code × σ → σ\nhrf : Primrec₂ rf\nPR✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pr a (cf, cg, hf, hg)\nCO✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => co a (cf, cg, hf, hg)\nPC✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pc a (cf, cg, hf, hg)\nRF✝ : α → Code → σ → σ := fun a cf hf => rf a (cf, hf)\nF : α → Code → σ := fun a c => Code.recOn c (z a) (s a) (l a) (r a) (PR✝ a) (CO✝ a) (PC✝ a) (RF✝ a)\nG₁ : (α × List σ) × ℕ × ℕ → Option σ :=\n fun p =>\n let a := p.fst.fst;\n let IH := p.fst.snd;\n let n := p.snd.fst;\n let m := p.snd.snd;\n Option.bind (List.get? IH m) fun s =>\n Option.bind (List.get? IH (unpair m).fst) fun s₁ =>\n Option.map\n (fun s₂ =>\n bif bodd n then\n bif bodd (div2 n) then rf a (ofNat Code m, s)\n else pc a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else\n bif bodd (div2 n) then co a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else pr a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂))\n (List.get? IH (unpair m).snd)\na : Primrec fun p => p.fst.fst.fst.fst.fst\nn : Primrec fun p => p.fst.fst.fst.snd.fst\nm : Primrec fun p => p.fst.fst.fst.snd.snd\nm₁ : Primrec fun a => (unpair a.fst.fst.fst.snd.snd).fst\nm₂ : Primrec fun a => (unpair a.fst.fst.fst.snd.snd).snd\n⊢ Primrec₂ fun p s₂ =>\n bif bodd p.fst.fst.snd.fst then\n bif bodd (div2 p.fst.fst.snd.fst) then rf p.fst.fst.fst.fst (ofNat Code p.fst.fst.snd.snd, p.fst.snd)\n else\n pc p.fst.fst.fst.fst\n (ofNat Code (unpair p.fst.fst.snd.snd).fst, ofNat Code (unpair p.fst.fst.snd.snd).snd, p.snd, s₂)\n else\n bif bodd (div2 p.fst.fst.snd.fst) then\n co p.fst.fst.fst.fst\n (ofNat Code (unpair p.fst.fst.snd.snd).fst, ofNat Code (unpair p.fst.fst.snd.snd).snd, p.snd, s₂)\n else\n pr p.fst.fst.fst.fst\n (ofNat Code (unpair p.fst.fst.snd.snd).fst, ofNat Code (unpair p.fst.fst.snd.snd).snd, p.snd, s₂)",
"tactic": "have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) :=\n snd.comp (fst.comp fst)"
},
{
"state_after": "α : Type u_1\nσ : Type u_2\ninst✝¹ : Primcodable α\ninst✝ : Primcodable σ\nc : α → Code\nhc : Primrec c\nz : α → σ\nhz : Primrec z\ns✝ : α → σ\nhs : Primrec s✝\nl : α → σ\nhl : Primrec l\nr : α → σ\nhr : Primrec r\npr : α → Code × Code × σ × σ → σ\nhpr : Primrec₂ pr\nco : α → Code × Code × σ × σ → σ\nhco : Primrec₂ co\npc : α → Code × Code × σ × σ → σ\nhpc : Primrec₂ pc\nrf : α → Code × σ → σ\nhrf : Primrec₂ rf\nPR✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pr a (cf, cg, hf, hg)\nCO✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => co a (cf, cg, hf, hg)\nPC✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pc a (cf, cg, hf, hg)\nRF✝ : α → Code → σ → σ := fun a cf hf => rf a (cf, hf)\nF : α → Code → σ := fun a c => Code.recOn c (z a) (s✝ a) (l a) (r a) (PR✝ a) (CO✝ a) (PC✝ a) (RF✝ a)\nG₁ : (α × List σ) × ℕ × ℕ → Option σ :=\n fun p =>\n let a := p.fst.fst;\n let IH := p.fst.snd;\n let n := p.snd.fst;\n let m := p.snd.snd;\n Option.bind (List.get? IH m) fun s =>\n Option.bind (List.get? IH (unpair m).fst) fun s₁ =>\n Option.map\n (fun s₂ =>\n bif bodd n then\n bif bodd (div2 n) then rf a (ofNat Code m, s)\n else pc a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else\n bif bodd (div2 n) then co a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else pr a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂))\n (List.get? IH (unpair m).snd)\na : Primrec fun p => p.fst.fst.fst.fst.fst\nn : Primrec fun p => p.fst.fst.fst.snd.fst\nm : Primrec fun p => p.fst.fst.fst.snd.snd\nm₁ : Primrec fun a => (unpair a.fst.fst.fst.snd.snd).fst\nm₂ : Primrec fun a => (unpair a.fst.fst.fst.snd.snd).snd\ns : Primrec fun p => p.fst.fst.snd\ns₁ : Primrec fun p => p.fst.snd\n⊢ Primrec₂ fun p s₂ =>\n bif bodd p.fst.fst.snd.fst then\n bif bodd (div2 p.fst.fst.snd.fst) then rf p.fst.fst.fst.fst (ofNat Code p.fst.fst.snd.snd, p.fst.snd)\n else\n pc p.fst.fst.fst.fst\n (ofNat Code (unpair p.fst.fst.snd.snd).fst, ofNat Code (unpair p.fst.fst.snd.snd).snd, p.snd, s₂)\n else\n bif bodd (div2 p.fst.fst.snd.fst) then\n co p.fst.fst.fst.fst\n (ofNat Code (unpair p.fst.fst.snd.snd).fst, ofNat Code (unpair p.fst.fst.snd.snd).snd, p.snd, s₂)\n else\n pr p.fst.fst.fst.fst\n (ofNat Code (unpair p.fst.fst.snd.snd).fst, ofNat Code (unpair p.fst.fst.snd.snd).snd, p.snd, s₂)",
"state_before": "α : Type u_1\nσ : Type u_2\ninst✝¹ : Primcodable α\ninst✝ : Primcodable σ\nc : α → Code\nhc : Primrec c\nz : α → σ\nhz : Primrec z\ns✝ : α → σ\nhs : Primrec s✝\nl : α → σ\nhl : Primrec l\nr : α → σ\nhr : Primrec r\npr : α → Code × Code × σ × σ → σ\nhpr : Primrec₂ pr\nco : α → Code × Code × σ × σ → σ\nhco : Primrec₂ co\npc : α → Code × Code × σ × σ → σ\nhpc : Primrec₂ pc\nrf : α → Code × σ → σ\nhrf : Primrec₂ rf\nPR✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pr a (cf, cg, hf, hg)\nCO✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => co a (cf, cg, hf, hg)\nPC✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pc a (cf, cg, hf, hg)\nRF✝ : α → Code → σ → σ := fun a cf hf => rf a (cf, hf)\nF : α → Code → σ := fun a c => Code.recOn c (z a) (s✝ a) (l a) (r a) (PR✝ a) (CO✝ a) (PC✝ a) (RF✝ a)\nG₁ : (α × List σ) × ℕ × ℕ → Option σ :=\n fun p =>\n let a := p.fst.fst;\n let IH := p.fst.snd;\n let n := p.snd.fst;\n let m := p.snd.snd;\n Option.bind (List.get? IH m) fun s =>\n Option.bind (List.get? IH (unpair m).fst) fun s₁ =>\n Option.map\n (fun s₂ =>\n bif bodd n then\n bif bodd (div2 n) then rf a (ofNat Code m, s)\n else pc a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else\n bif bodd (div2 n) then co a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else pr a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂))\n (List.get? IH (unpair m).snd)\na : Primrec fun p => p.fst.fst.fst.fst.fst\nn : Primrec fun p => p.fst.fst.fst.snd.fst\nm : Primrec fun p => p.fst.fst.fst.snd.snd\nm₁ : Primrec fun a => (unpair a.fst.fst.fst.snd.snd).fst\nm₂ : Primrec fun a => (unpair a.fst.fst.fst.snd.snd).snd\ns : Primrec fun p => p.fst.fst.snd\n⊢ Primrec₂ fun p s₂ =>\n bif bodd p.fst.fst.snd.fst then\n bif bodd (div2 p.fst.fst.snd.fst) then rf p.fst.fst.fst.fst (ofNat Code p.fst.fst.snd.snd, p.fst.snd)\n else\n pc p.fst.fst.fst.fst\n (ofNat Code (unpair p.fst.fst.snd.snd).fst, ofNat Code (unpair p.fst.fst.snd.snd).snd, p.snd, s₂)\n else\n bif bodd (div2 p.fst.fst.snd.fst) then\n co p.fst.fst.fst.fst\n (ofNat Code (unpair p.fst.fst.snd.snd).fst, ofNat Code (unpair p.fst.fst.snd.snd).snd, p.snd, s₂)\n else\n pr p.fst.fst.fst.fst\n (ofNat Code (unpair p.fst.fst.snd.snd).fst, ofNat Code (unpair p.fst.fst.snd.snd).snd, p.snd, s₂)",
"tactic": "have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) :=\n snd.comp fst"
},
{
"state_after": "α : Type u_1\nσ : Type u_2\ninst✝¹ : Primcodable α\ninst✝ : Primcodable σ\nc : α → Code\nhc : Primrec c\nz : α → σ\nhz : Primrec z\ns✝ : α → σ\nhs : Primrec s✝\nl : α → σ\nhl : Primrec l\nr : α → σ\nhr : Primrec r\npr : α → Code × Code × σ × σ → σ\nhpr : Primrec₂ pr\nco : α → Code × Code × σ × σ → σ\nhco : Primrec₂ co\npc : α → Code × Code × σ × σ → σ\nhpc : Primrec₂ pc\nrf : α → Code × σ → σ\nhrf : Primrec₂ rf\nPR✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pr a (cf, cg, hf, hg)\nCO✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => co a (cf, cg, hf, hg)\nPC✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pc a (cf, cg, hf, hg)\nRF✝ : α → Code → σ → σ := fun a cf hf => rf a (cf, hf)\nF : α → Code → σ := fun a c => Code.recOn c (z a) (s✝ a) (l a) (r a) (PR✝ a) (CO✝ a) (PC✝ a) (RF✝ a)\nG₁ : (α × List σ) × ℕ × ℕ → Option σ :=\n fun p =>\n let a := p.fst.fst;\n let IH := p.fst.snd;\n let n := p.snd.fst;\n let m := p.snd.snd;\n Option.bind (List.get? IH m) fun s =>\n Option.bind (List.get? IH (unpair m).fst) fun s₁ =>\n Option.map\n (fun s₂ =>\n bif bodd n then\n bif bodd (div2 n) then rf a (ofNat Code m, s)\n else pc a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else\n bif bodd (div2 n) then co a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else pr a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂))\n (List.get? IH (unpair m).snd)\na : Primrec fun p => p.fst.fst.fst.fst.fst\nn : Primrec fun p => p.fst.fst.fst.snd.fst\nm : Primrec fun p => p.fst.fst.fst.snd.snd\nm₁ : Primrec fun a => (unpair a.fst.fst.fst.snd.snd).fst\nm₂ : Primrec fun a => (unpair a.fst.fst.fst.snd.snd).snd\ns : Primrec fun p => p.fst.fst.snd\ns₁ : Primrec fun p => p.fst.snd\ns₂ : Primrec fun p => p.snd\n⊢ Primrec₂ fun p s₂ =>\n bif bodd p.fst.fst.snd.fst then\n bif bodd (div2 p.fst.fst.snd.fst) then rf p.fst.fst.fst.fst (ofNat Code p.fst.fst.snd.snd, p.fst.snd)\n else\n pc p.fst.fst.fst.fst\n (ofNat Code (unpair p.fst.fst.snd.snd).fst, ofNat Code (unpair p.fst.fst.snd.snd).snd, p.snd, s₂)\n else\n bif bodd (div2 p.fst.fst.snd.fst) then\n co p.fst.fst.fst.fst\n (ofNat Code (unpair p.fst.fst.snd.snd).fst, ofNat Code (unpair p.fst.fst.snd.snd).snd, p.snd, s₂)\n else\n pr p.fst.fst.fst.fst\n (ofNat Code (unpair p.fst.fst.snd.snd).fst, ofNat Code (unpair p.fst.fst.snd.snd).snd, p.snd, s₂)",
"state_before": "α : Type u_1\nσ : Type u_2\ninst✝¹ : Primcodable α\ninst✝ : Primcodable σ\nc : α → Code\nhc : Primrec c\nz : α → σ\nhz : Primrec z\ns✝ : α → σ\nhs : Primrec s✝\nl : α → σ\nhl : Primrec l\nr : α → σ\nhr : Primrec r\npr : α → Code × Code × σ × σ → σ\nhpr : Primrec₂ pr\nco : α → Code × Code × σ × σ → σ\nhco : Primrec₂ co\npc : α → Code × Code × σ × σ → σ\nhpc : Primrec₂ pc\nrf : α → Code × σ → σ\nhrf : Primrec₂ rf\nPR✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pr a (cf, cg, hf, hg)\nCO✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => co a (cf, cg, hf, hg)\nPC✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pc a (cf, cg, hf, hg)\nRF✝ : α → Code → σ → σ := fun a cf hf => rf a (cf, hf)\nF : α → Code → σ := fun a c => Code.recOn c (z a) (s✝ a) (l a) (r a) (PR✝ a) (CO✝ a) (PC✝ a) (RF✝ a)\nG₁ : (α × List σ) × ℕ × ℕ → Option σ :=\n fun p =>\n let a := p.fst.fst;\n let IH := p.fst.snd;\n let n := p.snd.fst;\n let m := p.snd.snd;\n Option.bind (List.get? IH m) fun s =>\n Option.bind (List.get? IH (unpair m).fst) fun s₁ =>\n Option.map\n (fun s₂ =>\n bif bodd n then\n bif bodd (div2 n) then rf a (ofNat Code m, s)\n else pc a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else\n bif bodd (div2 n) then co a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else pr a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂))\n (List.get? IH (unpair m).snd)\na : Primrec fun p => p.fst.fst.fst.fst.fst\nn : Primrec fun p => p.fst.fst.fst.snd.fst\nm : Primrec fun p => p.fst.fst.fst.snd.snd\nm₁ : Primrec fun a => (unpair a.fst.fst.fst.snd.snd).fst\nm₂ : Primrec fun a => (unpair a.fst.fst.fst.snd.snd).snd\ns : Primrec fun p => p.fst.fst.snd\ns₁ : Primrec fun p => p.fst.snd\n⊢ Primrec₂ fun p s₂ =>\n bif bodd p.fst.fst.snd.fst then\n bif bodd (div2 p.fst.fst.snd.fst) then rf p.fst.fst.fst.fst (ofNat Code p.fst.fst.snd.snd, p.fst.snd)\n else\n pc p.fst.fst.fst.fst\n (ofNat Code (unpair p.fst.fst.snd.snd).fst, ofNat Code (unpair p.fst.fst.snd.snd).snd, p.snd, s₂)\n else\n bif bodd (div2 p.fst.fst.snd.fst) then\n co p.fst.fst.fst.fst\n (ofNat Code (unpair p.fst.fst.snd.snd).fst, ofNat Code (unpair p.fst.fst.snd.snd).snd, p.snd, s₂)\n else\n pr p.fst.fst.fst.fst\n (ofNat Code (unpair p.fst.fst.snd.snd).fst, ofNat Code (unpair p.fst.fst.snd.snd).snd, p.snd, s₂)",
"tactic": "have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) :=\n snd"
},
{
"state_after": "α : Type u_1\nσ : Type u_2\ninst✝¹ : Primcodable α\ninst✝ : Primcodable σ\nc : α → Code\nhc : Primrec c\nz : α → σ\nhz : Primrec z\ns✝ : α → σ\nhs : Primrec s✝\nl : α → σ\nhl : Primrec l\nr : α → σ\nhr : Primrec r\npr : α → Code × Code × σ × σ → σ\nhpr : Primrec₂ pr\nco : α → Code × Code × σ × σ → σ\nhco : Primrec₂ co\npc : α → Code × Code × σ × σ → σ\nhpc : Primrec₂ pc\nrf : α → Code × σ → σ\nhrf : Primrec₂ rf\nPR✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pr a (cf, cg, hf, hg)\nCO✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => co a (cf, cg, hf, hg)\nPC✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pc a (cf, cg, hf, hg)\nRF✝ : α → Code → σ → σ := fun a cf hf => rf a (cf, hf)\nF : α → Code → σ := fun a c => Code.recOn c (z a) (s✝ a) (l a) (r a) (PR✝ a) (CO✝ a) (PC✝ a) (RF✝ a)\nG₁ : (α × List σ) × ℕ × ℕ → Option σ :=\n fun p =>\n let a := p.fst.fst;\n let IH := p.fst.snd;\n let n := p.snd.fst;\n let m := p.snd.snd;\n Option.bind (List.get? IH m) fun s =>\n Option.bind (List.get? IH (unpair m).fst) fun s₁ =>\n Option.map\n (fun s₂ =>\n bif bodd n then\n bif bodd (div2 n) then rf a (ofNat Code m, s)\n else pc a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else\n bif bodd (div2 n) then co a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else pr a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂))\n (List.get? IH (unpair m).snd)\na : Primrec fun p => p.fst.fst.fst.fst.fst\nn : Primrec fun p => p.fst.fst.fst.snd.fst\nm : Primrec fun p => p.fst.fst.fst.snd.snd\nm₁ : Primrec fun a => (unpair a.fst.fst.fst.snd.snd).fst\nm₂ : Primrec fun a => (unpair a.fst.fst.fst.snd.snd).snd\ns : Primrec fun p => p.fst.fst.snd\ns₁ : Primrec fun p => p.fst.snd\ns₂ : Primrec fun p => p.snd\n⊢ Primrec fun p =>\n (fun p s₂ =>\n bif bodd p.fst.fst.snd.fst then\n bif bodd (div2 p.fst.fst.snd.fst) then rf p.fst.fst.fst.fst (ofNat Code p.fst.fst.snd.snd, p.fst.snd)\n else\n pc p.fst.fst.fst.fst\n (ofNat Code (unpair p.fst.fst.snd.snd).fst, ofNat Code (unpair p.fst.fst.snd.snd).snd, p.snd, s₂)\n else\n bif bodd (div2 p.fst.fst.snd.fst) then\n co p.fst.fst.fst.fst\n (ofNat Code (unpair p.fst.fst.snd.snd).fst, ofNat Code (unpair p.fst.fst.snd.snd).snd, p.snd, s₂)\n else\n pr p.fst.fst.fst.fst\n (ofNat Code (unpair p.fst.fst.snd.snd).fst, ofNat Code (unpair p.fst.fst.snd.snd).snd, p.snd, s₂))\n p.fst p.snd",
"state_before": "α : Type u_1\nσ : Type u_2\ninst✝¹ : Primcodable α\ninst✝ : Primcodable σ\nc : α → Code\nhc : Primrec c\nz : α → σ\nhz : Primrec z\ns✝ : α → σ\nhs : Primrec s✝\nl : α → σ\nhl : Primrec l\nr : α → σ\nhr : Primrec r\npr : α → Code × Code × σ × σ → σ\nhpr : Primrec₂ pr\nco : α → Code × Code × σ × σ → σ\nhco : Primrec₂ co\npc : α → Code × Code × σ × σ → σ\nhpc : Primrec₂ pc\nrf : α → Code × σ → σ\nhrf : Primrec₂ rf\nPR✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pr a (cf, cg, hf, hg)\nCO✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => co a (cf, cg, hf, hg)\nPC✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pc a (cf, cg, hf, hg)\nRF✝ : α → Code → σ → σ := fun a cf hf => rf a (cf, hf)\nF : α → Code → σ := fun a c => Code.recOn c (z a) (s✝ a) (l a) (r a) (PR✝ a) (CO✝ a) (PC✝ a) (RF✝ a)\nG₁ : (α × List σ) × ℕ × ℕ → Option σ :=\n fun p =>\n let a := p.fst.fst;\n let IH := p.fst.snd;\n let n := p.snd.fst;\n let m := p.snd.snd;\n Option.bind (List.get? IH m) fun s =>\n Option.bind (List.get? IH (unpair m).fst) fun s₁ =>\n Option.map\n (fun s₂ =>\n bif bodd n then\n bif bodd (div2 n) then rf a (ofNat Code m, s)\n else pc a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else\n bif bodd (div2 n) then co a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else pr a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂))\n (List.get? IH (unpair m).snd)\na : Primrec fun p => p.fst.fst.fst.fst.fst\nn : Primrec fun p => p.fst.fst.fst.snd.fst\nm : Primrec fun p => p.fst.fst.fst.snd.snd\nm₁ : Primrec fun a => (unpair a.fst.fst.fst.snd.snd).fst\nm₂ : Primrec fun a => (unpair a.fst.fst.fst.snd.snd).snd\ns : Primrec fun p => p.fst.fst.snd\ns₁ : Primrec fun p => p.fst.snd\ns₂ : Primrec fun p => p.snd\n⊢ Primrec₂ fun p s₂ =>\n bif bodd p.fst.fst.snd.fst then\n bif bodd (div2 p.fst.fst.snd.fst) then rf p.fst.fst.fst.fst (ofNat Code p.fst.fst.snd.snd, p.fst.snd)\n else\n pc p.fst.fst.fst.fst\n (ofNat Code (unpair p.fst.fst.snd.snd).fst, ofNat Code (unpair p.fst.fst.snd.snd).snd, p.snd, s₂)\n else\n bif bodd (div2 p.fst.fst.snd.fst) then\n co p.fst.fst.fst.fst\n (ofNat Code (unpair p.fst.fst.snd.snd).fst, ofNat Code (unpair p.fst.fst.snd.snd).snd, p.snd, s₂)\n else\n pr p.fst.fst.fst.fst\n (ofNat Code (unpair p.fst.fst.snd.snd).fst, ofNat Code (unpair p.fst.fst.snd.snd).snd, p.snd, s₂)",
"tactic": "unfold Primrec₂"
},
{
"state_after": "no goals",
"state_before": "α : Type u_1\nσ : Type u_2\ninst✝¹ : Primcodable α\ninst✝ : Primcodable σ\nc : α → Code\nhc : Primrec c\nz : α → σ\nhz : Primrec z\ns✝ : α → σ\nhs : Primrec s✝\nl : α → σ\nhl : Primrec l\nr : α → σ\nhr : Primrec r\npr : α → Code × Code × σ × σ → σ\nhpr : Primrec₂ pr\nco : α → Code × Code × σ × σ → σ\nhco : Primrec₂ co\npc : α → Code × Code × σ × σ → σ\nhpc : Primrec₂ pc\nrf : α → Code × σ → σ\nhrf : Primrec₂ rf\nPR✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pr a (cf, cg, hf, hg)\nCO✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => co a (cf, cg, hf, hg)\nPC✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pc a (cf, cg, hf, hg)\nRF✝ : α → Code → σ → σ := fun a cf hf => rf a (cf, hf)\nF : α → Code → σ := fun a c => Code.recOn c (z a) (s✝ a) (l a) (r a) (PR✝ a) (CO✝ a) (PC✝ a) (RF✝ a)\nG₁ : (α × List σ) × ℕ × ℕ → Option σ :=\n fun p =>\n let a := p.fst.fst;\n let IH := p.fst.snd;\n let n := p.snd.fst;\n let m := p.snd.snd;\n Option.bind (List.get? IH m) fun s =>\n Option.bind (List.get? IH (unpair m).fst) fun s₁ =>\n Option.map\n (fun s₂ =>\n bif bodd n then\n bif bodd (div2 n) then rf a (ofNat Code m, s)\n else pc a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else\n bif bodd (div2 n) then co a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else pr a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂))\n (List.get? IH (unpair m).snd)\na : Primrec fun p => p.fst.fst.fst.fst.fst\nn : Primrec fun p => p.fst.fst.fst.snd.fst\nm : Primrec fun p => p.fst.fst.fst.snd.snd\nm₁ : Primrec fun a => (unpair a.fst.fst.fst.snd.snd).fst\nm₂ : Primrec fun a => (unpair a.fst.fst.fst.snd.snd).snd\ns : Primrec fun p => p.fst.fst.snd\ns₁ : Primrec fun p => p.fst.snd\ns₂ : Primrec fun p => p.snd\n⊢ Primrec fun p =>\n (fun p s₂ =>\n bif bodd p.fst.fst.snd.fst then\n bif bodd (div2 p.fst.fst.snd.fst) then rf p.fst.fst.fst.fst (ofNat Code p.fst.fst.snd.snd, p.fst.snd)\n else\n pc p.fst.fst.fst.fst\n (ofNat Code (unpair p.fst.fst.snd.snd).fst, ofNat Code (unpair p.fst.fst.snd.snd).snd, p.snd, s₂)\n else\n bif bodd (div2 p.fst.fst.snd.fst) then\n co p.fst.fst.fst.fst\n (ofNat Code (unpair p.fst.fst.snd.snd).fst, ofNat Code (unpair p.fst.fst.snd.snd).snd, p.snd, s₂)\n else\n pr p.fst.fst.fst.fst\n (ofNat Code (unpair p.fst.fst.snd.snd).fst, ofNat Code (unpair p.fst.fst.snd.snd).snd, p.snd, s₂))\n p.fst p.snd",
"tactic": "exact\n (nat_bodd.comp n).cond\n ((nat_bodd.comp <| nat_div2.comp n).cond (hrf.comp a (((Primrec.ofNat Code).comp m).pair s))\n (hpc.comp a\n (((Primrec.ofNat Code).comp m₁).pair <|\n ((Primrec.ofNat Code).comp m₂).pair <| s₁.pair s₂)))\n (Primrec.cond (nat_bodd.comp <| nat_div2.comp n)\n (hco.comp a\n (((Primrec.ofNat Code).comp m₁).pair <|\n ((Primrec.ofNat Code).comp m₂).pair <| s₁.pair s₂))\n (hpr.comp a\n (((Primrec.ofNat Code).comp m₁).pair <|\n ((Primrec.ofNat Code).comp m₂).pair <| s₁.pair s₂)))"
},
{
"state_after": "α : Type u_1\nσ : Type u_2\ninst✝¹ : Primcodable α\ninst✝ : Primcodable σ\nc : α → Code\nhc : Primrec c\nz : α → σ\nhz : Primrec z\ns : α → σ\nhs : Primrec s\nl : α → σ\nhl : Primrec l\nr : α → σ\nhr : Primrec r\npr : α → Code × Code × σ × σ → σ\nhpr : Primrec₂ pr\nco : α → Code × Code × σ × σ → σ\nhco : Primrec₂ co\npc : α → Code × Code × σ × σ → σ\nhpc : Primrec₂ pc\nrf : α → Code × σ → σ\nhrf : Primrec₂ rf\nPR✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pr a (cf, cg, hf, hg)\nCO✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => co a (cf, cg, hf, hg)\nPC✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pc a (cf, cg, hf, hg)\nRF✝ : α → Code → σ → σ := fun a cf hf => rf a (cf, hf)\nF : α → Code → σ := fun a c => Code.recOn c (z a) (s a) (l a) (r a) (PR✝ a) (CO✝ a) (PC✝ a) (RF✝ a)\nG₁ : (α × List σ) × ℕ × ℕ → Option σ :=\n fun p =>\n let a := p.fst.fst;\n let IH := p.fst.snd;\n let n := p.snd.fst;\n let m := p.snd.snd;\n Option.bind (List.get? IH m) fun s =>\n Option.bind (List.get? IH (unpair m).fst) fun s₁ =>\n Option.map\n (fun s₂ =>\n bif bodd n then\n bif bodd (div2 n) then rf a (ofNat Code m, s)\n else pc a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else\n bif bodd (div2 n) then co a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else pr a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂))\n (List.get? IH (unpair m).snd)\nthis : Primrec G₁\nG : α → List σ → Option σ :=\n fun a IH =>\n Nat.casesOn (List.length IH) (some (z a)) fun n =>\n Nat.casesOn n (some (s a)) fun n =>\n Nat.casesOn n (some (l a)) fun n => Nat.casesOn n (some (r a)) fun n => G₁ ((a, IH), n, div2 (div2 n))\n⊢ Primrec fun p => G p.fst p.snd",
"state_before": "α : Type u_1\nσ : Type u_2\ninst✝¹ : Primcodable α\ninst✝ : Primcodable σ\nc : α → Code\nhc : Primrec c\nz : α → σ\nhz : Primrec z\ns : α → σ\nhs : Primrec s\nl : α → σ\nhl : Primrec l\nr : α → σ\nhr : Primrec r\npr : α → Code × Code × σ × σ → σ\nhpr : Primrec₂ pr\nco : α → Code × Code × σ × σ → σ\nhco : Primrec₂ co\npc : α → Code × Code × σ × σ → σ\nhpc : Primrec₂ pc\nrf : α → Code × σ → σ\nhrf : Primrec₂ rf\nPR✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pr a (cf, cg, hf, hg)\nCO✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => co a (cf, cg, hf, hg)\nPC✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pc a (cf, cg, hf, hg)\nRF✝ : α → Code → σ → σ := fun a cf hf => rf a (cf, hf)\nF : α → Code → σ := fun a c => Code.recOn c (z a) (s a) (l a) (r a) (PR✝ a) (CO✝ a) (PC✝ a) (RF✝ a)\nG₁ : (α × List σ) × ℕ × ℕ → Option σ :=\n fun p =>\n let a := p.fst.fst;\n let IH := p.fst.snd;\n let n := p.snd.fst;\n let m := p.snd.snd;\n Option.bind (List.get? IH m) fun s =>\n Option.bind (List.get? IH (unpair m).fst) fun s₁ =>\n Option.map\n (fun s₂ =>\n bif bodd n then\n bif bodd (div2 n) then rf a (ofNat Code m, s)\n else pc a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else\n bif bodd (div2 n) then co a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else pr a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂))\n (List.get? IH (unpair m).snd)\nthis : Primrec G₁\nG : α → List σ → Option σ :=\n fun a IH =>\n Nat.casesOn (List.length IH) (some (z a)) fun n =>\n Nat.casesOn n (some (s a)) fun n =>\n Nat.casesOn n (some (l a)) fun n => Nat.casesOn n (some (r a)) fun n => G₁ ((a, IH), n, div2 (div2 n))\n⊢ Primrec₂ G",
"tactic": "unfold Primrec₂"
},
{
"state_after": "α : Type u_1\nσ : Type u_2\ninst✝¹ : Primcodable α\ninst✝ : Primcodable σ\nc : α → Code\nhc : Primrec c\nz : α → σ\nhz : Primrec z\ns : α → σ\nhs : Primrec s\nl : α → σ\nhl : Primrec l\nr : α → σ\nhr : Primrec r\npr : α → Code × Code × σ × σ → σ\nhpr : Primrec₂ pr\nco : α → Code × Code × σ × σ → σ\nhco : Primrec₂ co\npc : α → Code × Code × σ × σ → σ\nhpc : Primrec₂ pc\nrf : α → Code × σ → σ\nhrf : Primrec₂ rf\nPR✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pr a (cf, cg, hf, hg)\nCO✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => co a (cf, cg, hf, hg)\nPC✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pc a (cf, cg, hf, hg)\nRF✝ : α → Code → σ → σ := fun a cf hf => rf a (cf, hf)\nF : α → Code → σ := fun a c => Code.recOn c (z a) (s a) (l a) (r a) (PR✝ a) (CO✝ a) (PC✝ a) (RF✝ a)\nG₁ : (α × List σ) × ℕ × ℕ → Option σ :=\n fun p =>\n let a := p.fst.fst;\n let IH := p.fst.snd;\n let n := p.snd.fst;\n let m := p.snd.snd;\n Option.bind (List.get? IH m) fun s =>\n Option.bind (List.get? IH (unpair m).fst) fun s₁ =>\n Option.map\n (fun s₂ =>\n bif bodd n then\n bif bodd (div2 n) then rf a (ofNat Code m, s)\n else pc a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else\n bif bodd (div2 n) then co a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else pr a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂))\n (List.get? IH (unpair m).snd)\nthis : Primrec G₁\nG : α → List σ → Option σ :=\n fun a IH =>\n Nat.casesOn (List.length IH) (some (z a)) fun n =>\n Nat.casesOn n (some (s a)) fun n =>\n Nat.casesOn n (some (l a)) fun n => Nat.casesOn n (some (r a)) fun n => G₁ ((a, IH), n, div2 (div2 n))\n⊢ Primrec₂ fun p n =>\n (fun n =>\n Nat.casesOn n (some (s p.fst)) fun n =>\n Nat.casesOn n (some (l p.fst)) fun n =>\n Nat.casesOn n (some (r p.fst)) fun n => G₁ ((p.fst, p.snd), n, div2 (div2 n)))\n n",
"state_before": "α : Type u_1\nσ : Type u_2\ninst✝¹ : Primcodable α\ninst✝ : Primcodable σ\nc : α → Code\nhc : Primrec c\nz : α → σ\nhz : Primrec z\ns : α → σ\nhs : Primrec s\nl : α → σ\nhl : Primrec l\nr : α → σ\nhr : Primrec r\npr : α → Code × Code × σ × σ → σ\nhpr : Primrec₂ pr\nco : α → Code × Code × σ × σ → σ\nhco : Primrec₂ co\npc : α → Code × Code × σ × σ → σ\nhpc : Primrec₂ pc\nrf : α → Code × σ → σ\nhrf : Primrec₂ rf\nPR✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pr a (cf, cg, hf, hg)\nCO✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => co a (cf, cg, hf, hg)\nPC✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pc a (cf, cg, hf, hg)\nRF✝ : α → Code → σ → σ := fun a cf hf => rf a (cf, hf)\nF : α → Code → σ := fun a c => Code.recOn c (z a) (s a) (l a) (r a) (PR✝ a) (CO✝ a) (PC✝ a) (RF✝ a)\nG₁ : (α × List σ) × ℕ × ℕ → Option σ :=\n fun p =>\n let a := p.fst.fst;\n let IH := p.fst.snd;\n let n := p.snd.fst;\n let m := p.snd.snd;\n Option.bind (List.get? IH m) fun s =>\n Option.bind (List.get? IH (unpair m).fst) fun s₁ =>\n Option.map\n (fun s₂ =>\n bif bodd n then\n bif bodd (div2 n) then rf a (ofNat Code m, s)\n else pc a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else\n bif bodd (div2 n) then co a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else pr a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂))\n (List.get? IH (unpair m).snd)\nthis : Primrec G₁\nG : α → List σ → Option σ :=\n fun a IH =>\n Nat.casesOn (List.length IH) (some (z a)) fun n =>\n Nat.casesOn n (some (s a)) fun n =>\n Nat.casesOn n (some (l a)) fun n => Nat.casesOn n (some (r a)) fun n => G₁ ((a, IH), n, div2 (div2 n))\n⊢ Primrec fun p => G p.fst p.snd",
"tactic": "refine nat_casesOn\n (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_"
},
{
"state_after": "α : Type u_1\nσ : Type u_2\ninst✝¹ : Primcodable α\ninst✝ : Primcodable σ\nc : α → Code\nhc : Primrec c\nz : α → σ\nhz : Primrec z\ns : α → σ\nhs : Primrec s\nl : α → σ\nhl : Primrec l\nr : α → σ\nhr : Primrec r\npr : α → Code × Code × σ × σ → σ\nhpr : Primrec₂ pr\nco : α → Code × Code × σ × σ → σ\nhco : Primrec₂ co\npc : α → Code × Code × σ × σ → σ\nhpc : Primrec₂ pc\nrf : α → Code × σ → σ\nhrf : Primrec₂ rf\nPR✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pr a (cf, cg, hf, hg)\nCO✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => co a (cf, cg, hf, hg)\nPC✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pc a (cf, cg, hf, hg)\nRF✝ : α → Code → σ → σ := fun a cf hf => rf a (cf, hf)\nF : α → Code → σ := fun a c => Code.recOn c (z a) (s a) (l a) (r a) (PR✝ a) (CO✝ a) (PC✝ a) (RF✝ a)\nG₁ : (α × List σ) × ℕ × ℕ → Option σ :=\n fun p =>\n let a := p.fst.fst;\n let IH := p.fst.snd;\n let n := p.snd.fst;\n let m := p.snd.snd;\n Option.bind (List.get? IH m) fun s =>\n Option.bind (List.get? IH (unpair m).fst) fun s₁ =>\n Option.map\n (fun s₂ =>\n bif bodd n then\n bif bodd (div2 n) then rf a (ofNat Code m, s)\n else pc a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else\n bif bodd (div2 n) then co a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else pr a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂))\n (List.get? IH (unpair m).snd)\nthis : Primrec G₁\nG : α → List σ → Option σ :=\n fun a IH =>\n Nat.casesOn (List.length IH) (some (z a)) fun n =>\n Nat.casesOn n (some (s a)) fun n =>\n Nat.casesOn n (some (l a)) fun n => Nat.casesOn n (some (r a)) fun n => G₁ ((a, IH), n, div2 (div2 n))\n⊢ Primrec fun p =>\n (fun p n =>\n (fun n =>\n Nat.casesOn n (some (s p.fst)) fun n =>\n Nat.casesOn n (some (l p.fst)) fun n =>\n Nat.casesOn n (some (r p.fst)) fun n => G₁ ((p.fst, p.snd), n, div2 (div2 n)))\n n)\n p.fst p.snd",
"state_before": "α : Type u_1\nσ : Type u_2\ninst✝¹ : Primcodable α\ninst✝ : Primcodable σ\nc : α → Code\nhc : Primrec c\nz : α → σ\nhz : Primrec z\ns : α → σ\nhs : Primrec s\nl : α → σ\nhl : Primrec l\nr : α → σ\nhr : Primrec r\npr : α → Code × Code × σ × σ → σ\nhpr : Primrec₂ pr\nco : α → Code × Code × σ × σ → σ\nhco : Primrec₂ co\npc : α → Code × Code × σ × σ → σ\nhpc : Primrec₂ pc\nrf : α → Code × σ → σ\nhrf : Primrec₂ rf\nPR✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pr a (cf, cg, hf, hg)\nCO✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => co a (cf, cg, hf, hg)\nPC✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pc a (cf, cg, hf, hg)\nRF✝ : α → Code → σ → σ := fun a cf hf => rf a (cf, hf)\nF : α → Code → σ := fun a c => Code.recOn c (z a) (s a) (l a) (r a) (PR✝ a) (CO✝ a) (PC✝ a) (RF✝ a)\nG₁ : (α × List σ) × ℕ × ℕ → Option σ :=\n fun p =>\n let a := p.fst.fst;\n let IH := p.fst.snd;\n let n := p.snd.fst;\n let m := p.snd.snd;\n Option.bind (List.get? IH m) fun s =>\n Option.bind (List.get? IH (unpair m).fst) fun s₁ =>\n Option.map\n (fun s₂ =>\n bif bodd n then\n bif bodd (div2 n) then rf a (ofNat Code m, s)\n else pc a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else\n bif bodd (div2 n) then co a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else pr a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂))\n (List.get? IH (unpair m).snd)\nthis : Primrec G₁\nG : α → List σ → Option σ :=\n fun a IH =>\n Nat.casesOn (List.length IH) (some (z a)) fun n =>\n Nat.casesOn n (some (s a)) fun n =>\n Nat.casesOn n (some (l a)) fun n => Nat.casesOn n (some (r a)) fun n => G₁ ((a, IH), n, div2 (div2 n))\n⊢ Primrec₂ fun p n =>\n (fun n =>\n Nat.casesOn n (some (s p.fst)) fun n =>\n Nat.casesOn n (some (l p.fst)) fun n =>\n Nat.casesOn n (some (r p.fst)) fun n => G₁ ((p.fst, p.snd), n, div2 (div2 n)))\n n",
"tactic": "unfold Primrec₂"
},
{
"state_after": "α : Type u_1\nσ : Type u_2\ninst✝¹ : Primcodable α\ninst✝ : Primcodable σ\nc : α → Code\nhc : Primrec c\nz : α → σ\nhz : Primrec z\ns : α → σ\nhs : Primrec s\nl : α → σ\nhl : Primrec l\nr : α → σ\nhr : Primrec r\npr : α → Code × Code × σ × σ → σ\nhpr : Primrec₂ pr\nco : α → Code × Code × σ × σ → σ\nhco : Primrec₂ co\npc : α → Code × Code × σ × σ → σ\nhpc : Primrec₂ pc\nrf : α → Code × σ → σ\nhrf : Primrec₂ rf\nPR✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pr a (cf, cg, hf, hg)\nCO✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => co a (cf, cg, hf, hg)\nPC✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pc a (cf, cg, hf, hg)\nRF✝ : α → Code → σ → σ := fun a cf hf => rf a (cf, hf)\nF : α → Code → σ := fun a c => Code.recOn c (z a) (s a) (l a) (r a) (PR✝ a) (CO✝ a) (PC✝ a) (RF✝ a)\nG₁ : (α × List σ) × ℕ × ℕ → Option σ :=\n fun p =>\n let a := p.fst.fst;\n let IH := p.fst.snd;\n let n := p.snd.fst;\n let m := p.snd.snd;\n Option.bind (List.get? IH m) fun s =>\n Option.bind (List.get? IH (unpair m).fst) fun s₁ =>\n Option.map\n (fun s₂ =>\n bif bodd n then\n bif bodd (div2 n) then rf a (ofNat Code m, s)\n else pc a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else\n bif bodd (div2 n) then co a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else pr a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂))\n (List.get? IH (unpair m).snd)\nthis : Primrec G₁\nG : α → List σ → Option σ :=\n fun a IH =>\n Nat.casesOn (List.length IH) (some (z a)) fun n =>\n Nat.casesOn n (some (s a)) fun n =>\n Nat.casesOn n (some (l a)) fun n => Nat.casesOn n (some (r a)) fun n => G₁ ((a, IH), n, div2 (div2 n))\n⊢ Primrec₂ fun p n =>\n (fun n =>\n Nat.casesOn n (some (l p.fst.fst)) fun n =>\n Nat.casesOn n (some (r p.fst.fst)) fun n => G₁ ((p.fst.fst, p.fst.snd), n, div2 (div2 n)))\n n",
"state_before": "α : Type u_1\nσ : Type u_2\ninst✝¹ : Primcodable α\ninst✝ : Primcodable σ\nc : α → Code\nhc : Primrec c\nz : α → σ\nhz : Primrec z\ns : α → σ\nhs : Primrec s\nl : α → σ\nhl : Primrec l\nr : α → σ\nhr : Primrec r\npr : α → Code × Code × σ × σ → σ\nhpr : Primrec₂ pr\nco : α → Code × Code × σ × σ → σ\nhco : Primrec₂ co\npc : α → Code × Code × σ × σ → σ\nhpc : Primrec₂ pc\nrf : α → Code × σ → σ\nhrf : Primrec₂ rf\nPR✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pr a (cf, cg, hf, hg)\nCO✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => co a (cf, cg, hf, hg)\nPC✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pc a (cf, cg, hf, hg)\nRF✝ : α → Code → σ → σ := fun a cf hf => rf a (cf, hf)\nF : α → Code → σ := fun a c => Code.recOn c (z a) (s a) (l a) (r a) (PR✝ a) (CO✝ a) (PC✝ a) (RF✝ a)\nG₁ : (α × List σ) × ℕ × ℕ → Option σ :=\n fun p =>\n let a := p.fst.fst;\n let IH := p.fst.snd;\n let n := p.snd.fst;\n let m := p.snd.snd;\n Option.bind (List.get? IH m) fun s =>\n Option.bind (List.get? IH (unpair m).fst) fun s₁ =>\n Option.map\n (fun s₂ =>\n bif bodd n then\n bif bodd (div2 n) then rf a (ofNat Code m, s)\n else pc a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else\n bif bodd (div2 n) then co a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else pr a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂))\n (List.get? IH (unpair m).snd)\nthis : Primrec G₁\nG : α → List σ → Option σ :=\n fun a IH =>\n Nat.casesOn (List.length IH) (some (z a)) fun n =>\n Nat.casesOn n (some (s a)) fun n =>\n Nat.casesOn n (some (l a)) fun n => Nat.casesOn n (some (r a)) fun n => G₁ ((a, IH), n, div2 (div2 n))\n⊢ Primrec fun p =>\n (fun p n =>\n (fun n =>\n Nat.casesOn n (some (s p.fst)) fun n =>\n Nat.casesOn n (some (l p.fst)) fun n =>\n Nat.casesOn n (some (r p.fst)) fun n => G₁ ((p.fst, p.snd), n, div2 (div2 n)))\n n)\n p.fst p.snd",
"tactic": "refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_"
},
{
"state_after": "α : Type u_1\nσ : Type u_2\ninst✝¹ : Primcodable α\ninst✝ : Primcodable σ\nc : α → Code\nhc : Primrec c\nz : α → σ\nhz : Primrec z\ns : α → σ\nhs : Primrec s\nl : α → σ\nhl : Primrec l\nr : α → σ\nhr : Primrec r\npr : α → Code × Code × σ × σ → σ\nhpr : Primrec₂ pr\nco : α → Code × Code × σ × σ → σ\nhco : Primrec₂ co\npc : α → Code × Code × σ × σ → σ\nhpc : Primrec₂ pc\nrf : α → Code × σ → σ\nhrf : Primrec₂ rf\nPR✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pr a (cf, cg, hf, hg)\nCO✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => co a (cf, cg, hf, hg)\nPC✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pc a (cf, cg, hf, hg)\nRF✝ : α → Code → σ → σ := fun a cf hf => rf a (cf, hf)\nF : α → Code → σ := fun a c => Code.recOn c (z a) (s a) (l a) (r a) (PR✝ a) (CO✝ a) (PC✝ a) (RF✝ a)\nG₁ : (α × List σ) × ℕ × ℕ → Option σ :=\n fun p =>\n let a := p.fst.fst;\n let IH := p.fst.snd;\n let n := p.snd.fst;\n let m := p.snd.snd;\n Option.bind (List.get? IH m) fun s =>\n Option.bind (List.get? IH (unpair m).fst) fun s₁ =>\n Option.map\n (fun s₂ =>\n bif bodd n then\n bif bodd (div2 n) then rf a (ofNat Code m, s)\n else pc a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else\n bif bodd (div2 n) then co a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else pr a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂))\n (List.get? IH (unpair m).snd)\nthis : Primrec G₁\nG : α → List σ → Option σ :=\n fun a IH =>\n Nat.casesOn (List.length IH) (some (z a)) fun n =>\n Nat.casesOn n (some (s a)) fun n =>\n Nat.casesOn n (some (l a)) fun n => Nat.casesOn n (some (r a)) fun n => G₁ ((a, IH), n, div2 (div2 n))\n⊢ Primrec fun p =>\n (fun p n =>\n (fun n =>\n Nat.casesOn n (some (l p.fst.fst)) fun n =>\n Nat.casesOn n (some (r p.fst.fst)) fun n => G₁ ((p.fst.fst, p.fst.snd), n, div2 (div2 n)))\n n)\n p.fst p.snd",
"state_before": "α : Type u_1\nσ : Type u_2\ninst✝¹ : Primcodable α\ninst✝ : Primcodable σ\nc : α → Code\nhc : Primrec c\nz : α → σ\nhz : Primrec z\ns : α → σ\nhs : Primrec s\nl : α → σ\nhl : Primrec l\nr : α → σ\nhr : Primrec r\npr : α → Code × Code × σ × σ → σ\nhpr : Primrec₂ pr\nco : α → Code × Code × σ × σ → σ\nhco : Primrec₂ co\npc : α → Code × Code × σ × σ → σ\nhpc : Primrec₂ pc\nrf : α → Code × σ → σ\nhrf : Primrec₂ rf\nPR✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pr a (cf, cg, hf, hg)\nCO✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => co a (cf, cg, hf, hg)\nPC✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pc a (cf, cg, hf, hg)\nRF✝ : α → Code → σ → σ := fun a cf hf => rf a (cf, hf)\nF : α → Code → σ := fun a c => Code.recOn c (z a) (s a) (l a) (r a) (PR✝ a) (CO✝ a) (PC✝ a) (RF✝ a)\nG₁ : (α × List σ) × ℕ × ℕ → Option σ :=\n fun p =>\n let a := p.fst.fst;\n let IH := p.fst.snd;\n let n := p.snd.fst;\n let m := p.snd.snd;\n Option.bind (List.get? IH m) fun s =>\n Option.bind (List.get? IH (unpair m).fst) fun s₁ =>\n Option.map\n (fun s₂ =>\n bif bodd n then\n bif bodd (div2 n) then rf a (ofNat Code m, s)\n else pc a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else\n bif bodd (div2 n) then co a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else pr a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂))\n (List.get? IH (unpair m).snd)\nthis : Primrec G₁\nG : α → List σ → Option σ :=\n fun a IH =>\n Nat.casesOn (List.length IH) (some (z a)) fun n =>\n Nat.casesOn n (some (s a)) fun n =>\n Nat.casesOn n (some (l a)) fun n => Nat.casesOn n (some (r a)) fun n => G₁ ((a, IH), n, div2 (div2 n))\n⊢ Primrec₂ fun p n =>\n (fun n =>\n Nat.casesOn n (some (l p.fst.fst)) fun n =>\n Nat.casesOn n (some (r p.fst.fst)) fun n => G₁ ((p.fst.fst, p.fst.snd), n, div2 (div2 n)))\n n",
"tactic": "unfold Primrec₂"
},
{
"state_after": "α : Type u_1\nσ : Type u_2\ninst✝¹ : Primcodable α\ninst✝ : Primcodable σ\nc : α → Code\nhc : Primrec c\nz : α → σ\nhz : Primrec z\ns : α → σ\nhs : Primrec s\nl : α → σ\nhl : Primrec l\nr : α → σ\nhr : Primrec r\npr : α → Code × Code × σ × σ → σ\nhpr : Primrec₂ pr\nco : α → Code × Code × σ × σ → σ\nhco : Primrec₂ co\npc : α → Code × Code × σ × σ → σ\nhpc : Primrec₂ pc\nrf : α → Code × σ → σ\nhrf : Primrec₂ rf\nPR✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pr a (cf, cg, hf, hg)\nCO✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => co a (cf, cg, hf, hg)\nPC✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pc a (cf, cg, hf, hg)\nRF✝ : α → Code → σ → σ := fun a cf hf => rf a (cf, hf)\nF : α → Code → σ := fun a c => Code.recOn c (z a) (s a) (l a) (r a) (PR✝ a) (CO✝ a) (PC✝ a) (RF✝ a)\nG₁ : (α × List σ) × ℕ × ℕ → Option σ :=\n fun p =>\n let a := p.fst.fst;\n let IH := p.fst.snd;\n let n := p.snd.fst;\n let m := p.snd.snd;\n Option.bind (List.get? IH m) fun s =>\n Option.bind (List.get? IH (unpair m).fst) fun s₁ =>\n Option.map\n (fun s₂ =>\n bif bodd n then\n bif bodd (div2 n) then rf a (ofNat Code m, s)\n else pc a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else\n bif bodd (div2 n) then co a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else pr a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂))\n (List.get? IH (unpair m).snd)\nthis : Primrec G₁\nG : α → List σ → Option σ :=\n fun a IH =>\n Nat.casesOn (List.length IH) (some (z a)) fun n =>\n Nat.casesOn n (some (s a)) fun n =>\n Nat.casesOn n (some (l a)) fun n => Nat.casesOn n (some (r a)) fun n => G₁ ((a, IH), n, div2 (div2 n))\n⊢ Primrec₂ fun p n =>\n (fun n => Nat.casesOn n (some (r p.fst.fst.fst)) fun n => G₁ ((p.fst.fst.fst, p.fst.fst.snd), n, div2 (div2 n))) n",
"state_before": "α : Type u_1\nσ : Type u_2\ninst✝¹ : Primcodable α\ninst✝ : Primcodable σ\nc : α → Code\nhc : Primrec c\nz : α → σ\nhz : Primrec z\ns : α → σ\nhs : Primrec s\nl : α → σ\nhl : Primrec l\nr : α → σ\nhr : Primrec r\npr : α → Code × Code × σ × σ → σ\nhpr : Primrec₂ pr\nco : α → Code × Code × σ × σ → σ\nhco : Primrec₂ co\npc : α → Code × Code × σ × σ → σ\nhpc : Primrec₂ pc\nrf : α → Code × σ → σ\nhrf : Primrec₂ rf\nPR✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pr a (cf, cg, hf, hg)\nCO✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => co a (cf, cg, hf, hg)\nPC✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pc a (cf, cg, hf, hg)\nRF✝ : α → Code → σ → σ := fun a cf hf => rf a (cf, hf)\nF : α → Code → σ := fun a c => Code.recOn c (z a) (s a) (l a) (r a) (PR✝ a) (CO✝ a) (PC✝ a) (RF✝ a)\nG₁ : (α × List σ) × ℕ × ℕ → Option σ :=\n fun p =>\n let a := p.fst.fst;\n let IH := p.fst.snd;\n let n := p.snd.fst;\n let m := p.snd.snd;\n Option.bind (List.get? IH m) fun s =>\n Option.bind (List.get? IH (unpair m).fst) fun s₁ =>\n Option.map\n (fun s₂ =>\n bif bodd n then\n bif bodd (div2 n) then rf a (ofNat Code m, s)\n else pc a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else\n bif bodd (div2 n) then co a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else pr a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂))\n (List.get? IH (unpair m).snd)\nthis : Primrec G₁\nG : α → List σ → Option σ :=\n fun a IH =>\n Nat.casesOn (List.length IH) (some (z a)) fun n =>\n Nat.casesOn n (some (s a)) fun n =>\n Nat.casesOn n (some (l a)) fun n => Nat.casesOn n (some (r a)) fun n => G₁ ((a, IH), n, div2 (div2 n))\n⊢ Primrec fun p =>\n (fun p n =>\n (fun n =>\n Nat.casesOn n (some (l p.fst.fst)) fun n =>\n Nat.casesOn n (some (r p.fst.fst)) fun n => G₁ ((p.fst.fst, p.fst.snd), n, div2 (div2 n)))\n n)\n p.fst p.snd",
"tactic": "refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <| fst.comp fst))) ?_"
},
{
"state_after": "α : Type u_1\nσ : Type u_2\ninst✝¹ : Primcodable α\ninst✝ : Primcodable σ\nc : α → Code\nhc : Primrec c\nz : α → σ\nhz : Primrec z\ns : α → σ\nhs : Primrec s\nl : α → σ\nhl : Primrec l\nr : α → σ\nhr : Primrec r\npr : α → Code × Code × σ × σ → σ\nhpr : Primrec₂ pr\nco : α → Code × Code × σ × σ → σ\nhco : Primrec₂ co\npc : α → Code × Code × σ × σ → σ\nhpc : Primrec₂ pc\nrf : α → Code × σ → σ\nhrf : Primrec₂ rf\nPR✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pr a (cf, cg, hf, hg)\nCO✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => co a (cf, cg, hf, hg)\nPC✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pc a (cf, cg, hf, hg)\nRF✝ : α → Code → σ → σ := fun a cf hf => rf a (cf, hf)\nF : α → Code → σ := fun a c => Code.recOn c (z a) (s a) (l a) (r a) (PR✝ a) (CO✝ a) (PC✝ a) (RF✝ a)\nG₁ : (α × List σ) × ℕ × ℕ → Option σ :=\n fun p =>\n let a := p.fst.fst;\n let IH := p.fst.snd;\n let n := p.snd.fst;\n let m := p.snd.snd;\n Option.bind (List.get? IH m) fun s =>\n Option.bind (List.get? IH (unpair m).fst) fun s₁ =>\n Option.map\n (fun s₂ =>\n bif bodd n then\n bif bodd (div2 n) then rf a (ofNat Code m, s)\n else pc a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else\n bif bodd (div2 n) then co a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else pr a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂))\n (List.get? IH (unpair m).snd)\nthis : Primrec G₁\nG : α → List σ → Option σ :=\n fun a IH =>\n Nat.casesOn (List.length IH) (some (z a)) fun n =>\n Nat.casesOn n (some (s a)) fun n =>\n Nat.casesOn n (some (l a)) fun n => Nat.casesOn n (some (r a)) fun n => G₁ ((a, IH), n, div2 (div2 n))\n⊢ Primrec fun p =>\n (fun p n =>\n (fun n => Nat.casesOn n (some (r p.fst.fst.fst)) fun n => G₁ ((p.fst.fst.fst, p.fst.fst.snd), n, div2 (div2 n)))\n n)\n p.fst p.snd",
"state_before": "α : Type u_1\nσ : Type u_2\ninst✝¹ : Primcodable α\ninst✝ : Primcodable σ\nc : α → Code\nhc : Primrec c\nz : α → σ\nhz : Primrec z\ns : α → σ\nhs : Primrec s\nl : α → σ\nhl : Primrec l\nr : α → σ\nhr : Primrec r\npr : α → Code × Code × σ × σ → σ\nhpr : Primrec₂ pr\nco : α → Code × Code × σ × σ → σ\nhco : Primrec₂ co\npc : α → Code × Code × σ × σ → σ\nhpc : Primrec₂ pc\nrf : α → Code × σ → σ\nhrf : Primrec₂ rf\nPR✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pr a (cf, cg, hf, hg)\nCO✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => co a (cf, cg, hf, hg)\nPC✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pc a (cf, cg, hf, hg)\nRF✝ : α → Code → σ → σ := fun a cf hf => rf a (cf, hf)\nF : α → Code → σ := fun a c => Code.recOn c (z a) (s a) (l a) (r a) (PR✝ a) (CO✝ a) (PC✝ a) (RF✝ a)\nG₁ : (α × List σ) × ℕ × ℕ → Option σ :=\n fun p =>\n let a := p.fst.fst;\n let IH := p.fst.snd;\n let n := p.snd.fst;\n let m := p.snd.snd;\n Option.bind (List.get? IH m) fun s =>\n Option.bind (List.get? IH (unpair m).fst) fun s₁ =>\n Option.map\n (fun s₂ =>\n bif bodd n then\n bif bodd (div2 n) then rf a (ofNat Code m, s)\n else pc a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else\n bif bodd (div2 n) then co a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else pr a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂))\n (List.get? IH (unpair m).snd)\nthis : Primrec G₁\nG : α → List σ → Option σ :=\n fun a IH =>\n Nat.casesOn (List.length IH) (some (z a)) fun n =>\n Nat.casesOn n (some (s a)) fun n =>\n Nat.casesOn n (some (l a)) fun n => Nat.casesOn n (some (r a)) fun n => G₁ ((a, IH), n, div2 (div2 n))\n⊢ Primrec₂ fun p n =>\n (fun n => Nat.casesOn n (some (r p.fst.fst.fst)) fun n => G₁ ((p.fst.fst.fst, p.fst.fst.snd), n, div2 (div2 n))) n",
"tactic": "unfold Primrec₂"
},
{
"state_after": "α : Type u_1\nσ : Type u_2\ninst✝¹ : Primcodable α\ninst✝ : Primcodable σ\nc : α → Code\nhc : Primrec c\nz : α → σ\nhz : Primrec z\ns : α → σ\nhs : Primrec s\nl : α → σ\nhl : Primrec l\nr : α → σ\nhr : Primrec r\npr : α → Code × Code × σ × σ → σ\nhpr : Primrec₂ pr\nco : α → Code × Code × σ × σ → σ\nhco : Primrec₂ co\npc : α → Code × Code × σ × σ → σ\nhpc : Primrec₂ pc\nrf : α → Code × σ → σ\nhrf : Primrec₂ rf\nPR✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pr a (cf, cg, hf, hg)\nCO✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => co a (cf, cg, hf, hg)\nPC✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pc a (cf, cg, hf, hg)\nRF✝ : α → Code → σ → σ := fun a cf hf => rf a (cf, hf)\nF : α → Code → σ := fun a c => Code.recOn c (z a) (s a) (l a) (r a) (PR✝ a) (CO✝ a) (PC✝ a) (RF✝ a)\nG₁ : (α × List σ) × ℕ × ℕ → Option σ :=\n fun p =>\n let a := p.fst.fst;\n let IH := p.fst.snd;\n let n := p.snd.fst;\n let m := p.snd.snd;\n Option.bind (List.get? IH m) fun s =>\n Option.bind (List.get? IH (unpair m).fst) fun s₁ =>\n Option.map\n (fun s₂ =>\n bif bodd n then\n bif bodd (div2 n) then rf a (ofNat Code m, s)\n else pc a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else\n bif bodd (div2 n) then co a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else pr a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂))\n (List.get? IH (unpair m).snd)\nthis : Primrec G₁\nG : α → List σ → Option σ :=\n fun a IH =>\n Nat.casesOn (List.length IH) (some (z a)) fun n =>\n Nat.casesOn n (some (s a)) fun n =>\n Nat.casesOn n (some (l a)) fun n => Nat.casesOn n (some (r a)) fun n => G₁ ((a, IH), n, div2 (div2 n))\n⊢ Primrec₂ fun p n => (fun n => G₁ ((p.fst.fst.fst.fst, p.fst.fst.fst.snd), n, div2 (div2 n))) n",
"state_before": "α : Type u_1\nσ : Type u_2\ninst✝¹ : Primcodable α\ninst✝ : Primcodable σ\nc : α → Code\nhc : Primrec c\nz : α → σ\nhz : Primrec z\ns : α → σ\nhs : Primrec s\nl : α → σ\nhl : Primrec l\nr : α → σ\nhr : Primrec r\npr : α → Code × Code × σ × σ → σ\nhpr : Primrec₂ pr\nco : α → Code × Code × σ × σ → σ\nhco : Primrec₂ co\npc : α → Code × Code × σ × σ → σ\nhpc : Primrec₂ pc\nrf : α → Code × σ → σ\nhrf : Primrec₂ rf\nPR✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pr a (cf, cg, hf, hg)\nCO✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => co a (cf, cg, hf, hg)\nPC✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pc a (cf, cg, hf, hg)\nRF✝ : α → Code → σ → σ := fun a cf hf => rf a (cf, hf)\nF : α → Code → σ := fun a c => Code.recOn c (z a) (s a) (l a) (r a) (PR✝ a) (CO✝ a) (PC✝ a) (RF✝ a)\nG₁ : (α × List σ) × ℕ × ℕ → Option σ :=\n fun p =>\n let a := p.fst.fst;\n let IH := p.fst.snd;\n let n := p.snd.fst;\n let m := p.snd.snd;\n Option.bind (List.get? IH m) fun s =>\n Option.bind (List.get? IH (unpair m).fst) fun s₁ =>\n Option.map\n (fun s₂ =>\n bif bodd n then\n bif bodd (div2 n) then rf a (ofNat Code m, s)\n else pc a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else\n bif bodd (div2 n) then co a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else pr a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂))\n (List.get? IH (unpair m).snd)\nthis : Primrec G₁\nG : α → List σ → Option σ :=\n fun a IH =>\n Nat.casesOn (List.length IH) (some (z a)) fun n =>\n Nat.casesOn n (some (s a)) fun n =>\n Nat.casesOn n (some (l a)) fun n => Nat.casesOn n (some (r a)) fun n => G₁ ((a, IH), n, div2 (div2 n))\n⊢ Primrec fun p =>\n (fun p n =>\n (fun n => Nat.casesOn n (some (r p.fst.fst.fst)) fun n => G₁ ((p.fst.fst.fst, p.fst.fst.snd), n, div2 (div2 n)))\n n)\n p.fst p.snd",
"tactic": "refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <| fst.comp <| fst.comp fst))) ?_"
},
{
"state_after": "α : Type u_1\nσ : Type u_2\ninst✝¹ : Primcodable α\ninst✝ : Primcodable σ\nc : α → Code\nhc : Primrec c\nz : α → σ\nhz : Primrec z\ns : α → σ\nhs : Primrec s\nl : α → σ\nhl : Primrec l\nr : α → σ\nhr : Primrec r\npr : α → Code × Code × σ × σ → σ\nhpr : Primrec₂ pr\nco : α → Code × Code × σ × σ → σ\nhco : Primrec₂ co\npc : α → Code × Code × σ × σ → σ\nhpc : Primrec₂ pc\nrf : α → Code × σ → σ\nhrf : Primrec₂ rf\nPR✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pr a (cf, cg, hf, hg)\nCO✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => co a (cf, cg, hf, hg)\nPC✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pc a (cf, cg, hf, hg)\nRF✝ : α → Code → σ → σ := fun a cf hf => rf a (cf, hf)\nF : α → Code → σ := fun a c => Code.recOn c (z a) (s a) (l a) (r a) (PR✝ a) (CO✝ a) (PC✝ a) (RF✝ a)\nG₁ : (α × List σ) × ℕ × ℕ → Option σ :=\n fun p =>\n let a := p.fst.fst;\n let IH := p.fst.snd;\n let n := p.snd.fst;\n let m := p.snd.snd;\n Option.bind (List.get? IH m) fun s =>\n Option.bind (List.get? IH (unpair m).fst) fun s₁ =>\n Option.map\n (fun s₂ =>\n bif bodd n then\n bif bodd (div2 n) then rf a (ofNat Code m, s)\n else pc a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else\n bif bodd (div2 n) then co a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else pr a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂))\n (List.get? IH (unpair m).snd)\nthis : Primrec G₁\nG : α → List σ → Option σ :=\n fun a IH =>\n Nat.casesOn (List.length IH) (some (z a)) fun n =>\n Nat.casesOn n (some (s a)) fun n =>\n Nat.casesOn n (some (l a)) fun n => Nat.casesOn n (some (r a)) fun n => G₁ ((a, IH), n, div2 (div2 n))\n⊢ Primrec fun p => (fun p n => (fun n => G₁ ((p.fst.fst.fst.fst, p.fst.fst.fst.snd), n, div2 (div2 n))) n) p.fst p.snd",
"state_before": "α : Type u_1\nσ : Type u_2\ninst✝¹ : Primcodable α\ninst✝ : Primcodable σ\nc : α → Code\nhc : Primrec c\nz : α → σ\nhz : Primrec z\ns : α → σ\nhs : Primrec s\nl : α → σ\nhl : Primrec l\nr : α → σ\nhr : Primrec r\npr : α → Code × Code × σ × σ → σ\nhpr : Primrec₂ pr\nco : α → Code × Code × σ × σ → σ\nhco : Primrec₂ co\npc : α → Code × Code × σ × σ → σ\nhpc : Primrec₂ pc\nrf : α → Code × σ → σ\nhrf : Primrec₂ rf\nPR✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pr a (cf, cg, hf, hg)\nCO✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => co a (cf, cg, hf, hg)\nPC✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pc a (cf, cg, hf, hg)\nRF✝ : α → Code → σ → σ := fun a cf hf => rf a (cf, hf)\nF : α → Code → σ := fun a c => Code.recOn c (z a) (s a) (l a) (r a) (PR✝ a) (CO✝ a) (PC✝ a) (RF✝ a)\nG₁ : (α × List σ) × ℕ × ℕ → Option σ :=\n fun p =>\n let a := p.fst.fst;\n let IH := p.fst.snd;\n let n := p.snd.fst;\n let m := p.snd.snd;\n Option.bind (List.get? IH m) fun s =>\n Option.bind (List.get? IH (unpair m).fst) fun s₁ =>\n Option.map\n (fun s₂ =>\n bif bodd n then\n bif bodd (div2 n) then rf a (ofNat Code m, s)\n else pc a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else\n bif bodd (div2 n) then co a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else pr a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂))\n (List.get? IH (unpair m).snd)\nthis : Primrec G₁\nG : α → List σ → Option σ :=\n fun a IH =>\n Nat.casesOn (List.length IH) (some (z a)) fun n =>\n Nat.casesOn n (some (s a)) fun n =>\n Nat.casesOn n (some (l a)) fun n => Nat.casesOn n (some (r a)) fun n => G₁ ((a, IH), n, div2 (div2 n))\n⊢ Primrec₂ fun p n => (fun n => G₁ ((p.fst.fst.fst.fst, p.fst.fst.fst.snd), n, div2 (div2 n))) n",
"tactic": "unfold Primrec₂"
},
{
"state_after": "no goals",
"state_before": "α : Type u_1\nσ : Type u_2\ninst✝¹ : Primcodable α\ninst✝ : Primcodable σ\nc : α → Code\nhc : Primrec c\nz : α → σ\nhz : Primrec z\ns : α → σ\nhs : Primrec s\nl : α → σ\nhl : Primrec l\nr : α → σ\nhr : Primrec r\npr : α → Code × Code × σ × σ → σ\nhpr : Primrec₂ pr\nco : α → Code × Code × σ × σ → σ\nhco : Primrec₂ co\npc : α → Code × Code × σ × σ → σ\nhpc : Primrec₂ pc\nrf : α → Code × σ → σ\nhrf : Primrec₂ rf\nPR✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pr a (cf, cg, hf, hg)\nCO✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => co a (cf, cg, hf, hg)\nPC✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pc a (cf, cg, hf, hg)\nRF✝ : α → Code → σ → σ := fun a cf hf => rf a (cf, hf)\nF : α → Code → σ := fun a c => Code.recOn c (z a) (s a) (l a) (r a) (PR✝ a) (CO✝ a) (PC✝ a) (RF✝ a)\nG₁ : (α × List σ) × ℕ × ℕ → Option σ :=\n fun p =>\n let a := p.fst.fst;\n let IH := p.fst.snd;\n let n := p.snd.fst;\n let m := p.snd.snd;\n Option.bind (List.get? IH m) fun s =>\n Option.bind (List.get? IH (unpair m).fst) fun s₁ =>\n Option.map\n (fun s₂ =>\n bif bodd n then\n bif bodd (div2 n) then rf a (ofNat Code m, s)\n else pc a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else\n bif bodd (div2 n) then co a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else pr a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂))\n (List.get? IH (unpair m).snd)\nthis : Primrec G₁\nG : α → List σ → Option σ :=\n fun a IH =>\n Nat.casesOn (List.length IH) (some (z a)) fun n =>\n Nat.casesOn n (some (s a)) fun n =>\n Nat.casesOn n (some (l a)) fun n => Nat.casesOn n (some (r a)) fun n => G₁ ((a, IH), n, div2 (div2 n))\n⊢ Primrec fun p => (fun p n => (fun n => G₁ ((p.fst.fst.fst.fst, p.fst.fst.fst.snd), n, div2 (div2 n))) n) p.fst p.snd",
"tactic": "exact this.comp <|\n ((fst.pair snd).comp <| fst.comp <| fst.comp <| fst.comp <| fst).pair <|\n snd.pair <| nat_div2.comp <| nat_div2.comp snd"
},
{
"state_after": "no goals",
"state_before": "α : Type u_1\nσ : Type u_2\ninst✝¹ : Primcodable α\ninst✝ : Primcodable σ\nc : α → Code\nhc : Primrec c\nz : α → σ\nhz : Primrec z\ns : α → σ\nhs : Primrec s\nl : α → σ\nhl : Primrec l\nr : α → σ\nhr : Primrec r\npr : α → Code × Code × σ × σ → σ\nhpr : Primrec₂ pr\nco : α → Code × Code × σ × σ → σ\nhco : Primrec₂ co\npc : α → Code × Code × σ × σ → σ\nhpc : Primrec₂ pc\nrf : α → Code × σ → σ\nhrf : Primrec₂ rf\nPR✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pr a (cf, cg, hf, hg)\nCO✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => co a (cf, cg, hf, hg)\nPC✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pc a (cf, cg, hf, hg)\nRF✝ : α → Code → σ → σ := fun a cf hf => rf a (cf, hf)\nF : α → Code → σ := fun a c => Code.recOn c (z a) (s a) (l a) (r a) (PR✝ a) (CO✝ a) (PC✝ a) (RF✝ a)\nG₁ : (α × List σ) × ℕ × ℕ → Option σ :=\n fun p =>\n let a := p.fst.fst;\n let IH := p.fst.snd;\n let n := p.snd.fst;\n let m := p.snd.snd;\n Option.bind (List.get? IH m) fun s =>\n Option.bind (List.get? IH (unpair m).fst) fun s₁ =>\n Option.map\n (fun s₂ =>\n bif bodd n then\n bif bodd (div2 n) then rf a (ofNat Code m, s)\n else pc a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else\n bif bodd (div2 n) then co a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else pr a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂))\n (List.get? IH (unpair m).snd)\nthis✝ : Primrec G₁\nG : α → List σ → Option σ :=\n fun a IH =>\n Nat.casesOn (List.length IH) (some (z a)) fun n =>\n Nat.casesOn n (some (s a)) fun n =>\n Nat.casesOn n (some (l a)) fun n => Nat.casesOn n (some (r a)) fun n => G₁ ((a, IH), n, div2 (div2 n))\nthis : Primrec₂ G\na : α\n⊢ F (id a) (ofNat Code (encode (c a))) = F a (c a)",
"tactic": "simp"
},
{
"state_after": "case succ.succ.succ.zero\nα : Type u_1\nσ : Type u_2\ninst✝¹ : Primcodable α\ninst✝ : Primcodable σ\nc : α → Code\nhc : Primrec c\nz : α → σ\nhz : Primrec z\ns : α → σ\nhs : Primrec s\nl : α → σ\nhl : Primrec l\nr : α → σ\nhr : Primrec r\npr : α → Code × Code × σ × σ → σ\nhpr : Primrec₂ pr\nco : α → Code × Code × σ × σ → σ\nhco : Primrec₂ co\npc : α → Code × Code × σ × σ → σ\nhpc : Primrec₂ pc\nrf : α → Code × σ → σ\nhrf : Primrec₂ rf\nPR✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pr a (cf, cg, hf, hg)\nCO✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => co a (cf, cg, hf, hg)\nPC✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pc a (cf, cg, hf, hg)\nRF✝ : α → Code → σ → σ := fun a cf hf => rf a (cf, hf)\nF : α → Code → σ := fun a c => Code.recOn c (z a) (s a) (l a) (r a) (PR✝ a) (CO✝ a) (PC✝ a) (RF✝ a)\nG₁ : (α × List σ) × ℕ × ℕ → Option σ :=\n fun p =>\n let a := p.fst.fst;\n let IH := p.fst.snd;\n let n := p.snd.fst;\n let m := p.snd.snd;\n Option.bind (List.get? IH m) fun s =>\n Option.bind (List.get? IH (unpair m).fst) fun s₁ =>\n Option.map\n (fun s₂ =>\n bif bodd n then\n bif bodd (div2 n) then rf a (ofNat Code m, s)\n else pc a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else\n bif bodd (div2 n) then co a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else pr a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂))\n (List.get? IH (unpair m).snd)\nthis✝ : Primrec G₁\nG : α → List σ → Option σ :=\n fun a IH =>\n Nat.casesOn (List.length IH) (some (z a)) fun n =>\n Nat.casesOn n (some (s a)) fun n =>\n Nat.casesOn n (some (l a)) fun n => Nat.casesOn n (some (r a)) fun n => G₁ ((a, IH), n, div2 (div2 n))\nthis : Primrec₂ G\na : α\n⊢ G a (List.map (fun n => F a (ofNat Code n)) (List.range (Nat.succ (Nat.succ (Nat.succ Nat.zero))))) =\n some (F a (ofNat Code (Nat.succ (Nat.succ (Nat.succ Nat.zero)))))\n\ncase succ.succ.succ.succ\nα : Type u_1\nσ : Type u_2\ninst✝¹ : Primcodable α\ninst✝ : Primcodable σ\nc : α → Code\nhc : Primrec c\nz : α → σ\nhz : Primrec z\ns : α → σ\nhs : Primrec s\nl : α → σ\nhl : Primrec l\nr : α → σ\nhr : Primrec r\npr : α → Code × Code × σ × σ → σ\nhpr : Primrec₂ pr\nco : α → Code × Code × σ × σ → σ\nhco : Primrec₂ co\npc : α → Code × Code × σ × σ → σ\nhpc : Primrec₂ pc\nrf : α → Code × σ → σ\nhrf : Primrec₂ rf\nPR✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pr a (cf, cg, hf, hg)\nCO✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => co a (cf, cg, hf, hg)\nPC✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pc a (cf, cg, hf, hg)\nRF✝ : α → Code → σ → σ := fun a cf hf => rf a (cf, hf)\nF : α → Code → σ := fun a c => Code.recOn c (z a) (s a) (l a) (r a) (PR✝ a) (CO✝ a) (PC✝ a) (RF✝ a)\nG₁ : (α × List σ) × ℕ × ℕ → Option σ :=\n fun p =>\n let a := p.fst.fst;\n let IH := p.fst.snd;\n let n := p.snd.fst;\n let m := p.snd.snd;\n Option.bind (List.get? IH m) fun s =>\n Option.bind (List.get? IH (unpair m).fst) fun s₁ =>\n Option.map\n (fun s₂ =>\n bif bodd n then\n bif bodd (div2 n) then rf a (ofNat Code m, s)\n else pc a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else\n bif bodd (div2 n) then co a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else pr a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂))\n (List.get? IH (unpair m).snd)\nthis✝ : Primrec G₁\nG : α → List σ → Option σ :=\n fun a IH =>\n Nat.casesOn (List.length IH) (some (z a)) fun n =>\n Nat.casesOn n (some (s a)) fun n =>\n Nat.casesOn n (some (l a)) fun n => Nat.casesOn n (some (r a)) fun n => G₁ ((a, IH), n, div2 (div2 n))\nthis : Primrec₂ G\na : α\nn : ℕ\n⊢ G a (List.map (fun n => F a (ofNat Code n)) (List.range (Nat.succ (Nat.succ (Nat.succ (Nat.succ n)))))) =\n some (F a (ofNat Code (Nat.succ (Nat.succ (Nat.succ (Nat.succ n))))))",
"state_before": "case succ.succ.succ\nα : Type u_1\nσ : Type u_2\ninst✝¹ : Primcodable α\ninst✝ : Primcodable σ\nc : α → Code\nhc : Primrec c\nz : α → σ\nhz : Primrec z\ns : α → σ\nhs : Primrec s\nl : α → σ\nhl : Primrec l\nr : α → σ\nhr : Primrec r\npr : α → Code × Code × σ × σ → σ\nhpr : Primrec₂ pr\nco : α → Code × Code × σ × σ → σ\nhco : Primrec₂ co\npc : α → Code × Code × σ × σ → σ\nhpc : Primrec₂ pc\nrf : α → Code × σ → σ\nhrf : Primrec₂ rf\nPR✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pr a (cf, cg, hf, hg)\nCO✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => co a (cf, cg, hf, hg)\nPC✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pc a (cf, cg, hf, hg)\nRF✝ : α → Code → σ → σ := fun a cf hf => rf a (cf, hf)\nF : α → Code → σ := fun a c => Code.recOn c (z a) (s a) (l a) (r a) (PR✝ a) (CO✝ a) (PC✝ a) (RF✝ a)\nG₁ : (α × List σ) × ℕ × ℕ → Option σ :=\n fun p =>\n let a := p.fst.fst;\n let IH := p.fst.snd;\n let n := p.snd.fst;\n let m := p.snd.snd;\n Option.bind (List.get? IH m) fun s =>\n Option.bind (List.get? IH (unpair m).fst) fun s₁ =>\n Option.map\n (fun s₂ =>\n bif bodd n then\n bif bodd (div2 n) then rf a (ofNat Code m, s)\n else pc a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else\n bif bodd (div2 n) then co a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else pr a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂))\n (List.get? IH (unpair m).snd)\nthis✝ : Primrec G₁\nG : α → List σ → Option σ :=\n fun a IH =>\n Nat.casesOn (List.length IH) (some (z a)) fun n =>\n Nat.casesOn n (some (s a)) fun n =>\n Nat.casesOn n (some (l a)) fun n => Nat.casesOn n (some (r a)) fun n => G₁ ((a, IH), n, div2 (div2 n))\nthis : Primrec₂ G\na : α\nn : ℕ\n⊢ G a (List.map (fun n => F a (ofNat Code n)) (List.range (Nat.succ (Nat.succ (Nat.succ n))))) =\n some (F a (ofNat Code (Nat.succ (Nat.succ (Nat.succ n)))))",
"tactic": "cases' n with n"
},
{
"state_after": "case succ.succ.succ.zero\nα : Type u_1\nσ : Type u_2\ninst✝¹ : Primcodable α\ninst✝ : Primcodable σ\nc : α → Code\nhc : Primrec c\nz : α → σ\nhz : Primrec z\ns : α → σ\nhs : Primrec s\nl : α → σ\nhl : Primrec l\nr : α → σ\nhr : Primrec r\npr : α → Code × Code × σ × σ → σ\nhpr : Primrec₂ pr\nco : α → Code × Code × σ × σ → σ\nhco : Primrec₂ co\npc : α → Code × Code × σ × σ → σ\nhpc : Primrec₂ pc\nrf : α → Code × σ → σ\nhrf : Primrec₂ rf\nPR✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pr a (cf, cg, hf, hg)\nCO✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => co a (cf, cg, hf, hg)\nPC✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pc a (cf, cg, hf, hg)\nRF✝ : α → Code → σ → σ := fun a cf hf => rf a (cf, hf)\nF : α → Code → σ := fun a c => Code.recOn c (z a) (s a) (l a) (r a) (PR✝ a) (CO✝ a) (PC✝ a) (RF✝ a)\nG₁ : (α × List σ) × ℕ × ℕ → Option σ :=\n fun p =>\n let a := p.fst.fst;\n let IH := p.fst.snd;\n let n := p.snd.fst;\n let m := p.snd.snd;\n Option.bind (List.get? IH m) fun s =>\n Option.bind (List.get? IH (unpair m).fst) fun s₁ =>\n Option.map\n (fun s₂ =>\n bif bodd n then\n bif bodd (div2 n) then rf a (ofNat Code m, s)\n else pc a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else\n bif bodd (div2 n) then co a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else pr a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂))\n (List.get? IH (unpair m).snd)\nthis✝ : Primrec G₁\nG : α → List σ → Option σ :=\n fun a IH =>\n Nat.casesOn (List.length IH) (some (z a)) fun n =>\n Nat.casesOn n (some (s a)) fun n =>\n Nat.casesOn n (some (l a)) fun n => Nat.casesOn n (some (r a)) fun n => G₁ ((a, IH), n, div2 (div2 n))\nthis : Primrec₂ G\na : α\n⊢ G a [F a zero, F a succ, F a left] = some (F a (ofNatCode (Nat.succ (Nat.succ (Nat.succ 0)))))",
"state_before": "case succ.succ.succ.zero\nα : Type u_1\nσ : Type u_2\ninst✝¹ : Primcodable α\ninst✝ : Primcodable σ\nc : α → Code\nhc : Primrec c\nz : α → σ\nhz : Primrec z\ns : α → σ\nhs : Primrec s\nl : α → σ\nhl : Primrec l\nr : α → σ\nhr : Primrec r\npr : α → Code × Code × σ × σ → σ\nhpr : Primrec₂ pr\nco : α → Code × Code × σ × σ → σ\nhco : Primrec₂ co\npc : α → Code × Code × σ × σ → σ\nhpc : Primrec₂ pc\nrf : α → Code × σ → σ\nhrf : Primrec₂ rf\nPR✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pr a (cf, cg, hf, hg)\nCO✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => co a (cf, cg, hf, hg)\nPC✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pc a (cf, cg, hf, hg)\nRF✝ : α → Code → σ → σ := fun a cf hf => rf a (cf, hf)\nF : α → Code → σ := fun a c => Code.recOn c (z a) (s a) (l a) (r a) (PR✝ a) (CO✝ a) (PC✝ a) (RF✝ a)\nG₁ : (α × List σ) × ℕ × ℕ → Option σ :=\n fun p =>\n let a := p.fst.fst;\n let IH := p.fst.snd;\n let n := p.snd.fst;\n let m := p.snd.snd;\n Option.bind (List.get? IH m) fun s =>\n Option.bind (List.get? IH (unpair m).fst) fun s₁ =>\n Option.map\n (fun s₂ =>\n bif bodd n then\n bif bodd (div2 n) then rf a (ofNat Code m, s)\n else pc a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else\n bif bodd (div2 n) then co a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else pr a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂))\n (List.get? IH (unpair m).snd)\nthis✝ : Primrec G₁\nG : α → List σ → Option σ :=\n fun a IH =>\n Nat.casesOn (List.length IH) (some (z a)) fun n =>\n Nat.casesOn n (some (s a)) fun n =>\n Nat.casesOn n (some (l a)) fun n => Nat.casesOn n (some (r a)) fun n => G₁ ((a, IH), n, div2 (div2 n))\nthis : Primrec₂ G\na : α\n⊢ G a (List.map (fun n => F a (ofNat Code n)) (List.range (Nat.succ (Nat.succ (Nat.succ Nat.zero))))) =\n some (F a (ofNat Code (Nat.succ (Nat.succ (Nat.succ Nat.zero)))))",
"tactic": "simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]"
},
{
"state_after": "no goals",
"state_before": "case succ.succ.succ.zero\nα : Type u_1\nσ : Type u_2\ninst✝¹ : Primcodable α\ninst✝ : Primcodable σ\nc : α → Code\nhc : Primrec c\nz : α → σ\nhz : Primrec z\ns : α → σ\nhs : Primrec s\nl : α → σ\nhl : Primrec l\nr : α → σ\nhr : Primrec r\npr : α → Code × Code × σ × σ → σ\nhpr : Primrec₂ pr\nco : α → Code × Code × σ × σ → σ\nhco : Primrec₂ co\npc : α → Code × Code × σ × σ → σ\nhpc : Primrec₂ pc\nrf : α → Code × σ → σ\nhrf : Primrec₂ rf\nPR✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pr a (cf, cg, hf, hg)\nCO✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => co a (cf, cg, hf, hg)\nPC✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pc a (cf, cg, hf, hg)\nRF✝ : α → Code → σ → σ := fun a cf hf => rf a (cf, hf)\nF : α → Code → σ := fun a c => Code.recOn c (z a) (s a) (l a) (r a) (PR✝ a) (CO✝ a) (PC✝ a) (RF✝ a)\nG₁ : (α × List σ) × ℕ × ℕ → Option σ :=\n fun p =>\n let a := p.fst.fst;\n let IH := p.fst.snd;\n let n := p.snd.fst;\n let m := p.snd.snd;\n Option.bind (List.get? IH m) fun s =>\n Option.bind (List.get? IH (unpair m).fst) fun s₁ =>\n Option.map\n (fun s₂ =>\n bif bodd n then\n bif bodd (div2 n) then rf a (ofNat Code m, s)\n else pc a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else\n bif bodd (div2 n) then co a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else pr a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂))\n (List.get? IH (unpair m).snd)\nthis✝ : Primrec G₁\nG : α → List σ → Option σ :=\n fun a IH =>\n Nat.casesOn (List.length IH) (some (z a)) fun n =>\n Nat.casesOn n (some (s a)) fun n =>\n Nat.casesOn n (some (l a)) fun n => Nat.casesOn n (some (r a)) fun n => G₁ ((a, IH), n, div2 (div2 n))\nthis : Primrec₂ G\na : α\n⊢ G a [F a zero, F a succ, F a left] = some (F a (ofNatCode (Nat.succ (Nat.succ (Nat.succ 0)))))",
"tactic": "rfl"
},
{
"state_after": "α : Type u_1\nσ : Type u_2\ninst✝¹ : Primcodable α\ninst✝ : Primcodable σ\nc : α → Code\nhc : Primrec c\nz : α → σ\nhz : Primrec z\ns : α → σ\nhs : Primrec s\nl : α → σ\nhl : Primrec l\nr : α → σ\nhr : Primrec r\npr : α → Code × Code × σ × σ → σ\nhpr : Primrec₂ pr\nco : α → Code × Code × σ × σ → σ\nhco : Primrec₂ co\npc : α → Code × Code × σ × σ → σ\nhpc : Primrec₂ pc\nrf : α → Code × σ → σ\nhrf : Primrec₂ rf\nPR✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pr a (cf, cg, hf, hg)\nCO✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => co a (cf, cg, hf, hg)\nPC✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pc a (cf, cg, hf, hg)\nRF✝ : α → Code → σ → σ := fun a cf hf => rf a (cf, hf)\nF : α → Code → σ := fun a c => Code.recOn c (z a) (s a) (l a) (r a) (PR✝ a) (CO✝ a) (PC✝ a) (RF✝ a)\nG₁ : (α × List σ) × ℕ × ℕ → Option σ :=\n fun p =>\n let a := p.fst.fst;\n let IH := p.fst.snd;\n let n := p.snd.fst;\n let m := p.snd.snd;\n Option.bind (List.get? IH m) fun s =>\n Option.bind (List.get? IH (unpair m).fst) fun s₁ =>\n Option.map\n (fun s₂ =>\n bif bodd n then\n bif bodd (div2 n) then rf a (ofNat Code m, s)\n else pc a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else\n bif bodd (div2 n) then co a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else pr a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂))\n (List.get? IH (unpair m).snd)\nthis✝ : Primrec G₁\nG : α → List σ → Option σ :=\n fun a IH =>\n Nat.casesOn (List.length IH) (some (z a)) fun n =>\n Nat.casesOn n (some (s a)) fun n =>\n Nat.casesOn n (some (l a)) fun n => Nat.casesOn n (some (r a)) fun n => G₁ ((a, IH), n, div2 (div2 n))\nthis : Primrec₂ G\na : α\nn : ℕ\nm : ℕ := div2 (div2 n)\n⊢ n / 2 / 2 < n + 4",
"state_before": "α : Type u_1\nσ : Type u_2\ninst✝¹ : Primcodable α\ninst✝ : Primcodable σ\nc : α → Code\nhc : Primrec c\nz : α → σ\nhz : Primrec z\ns : α → σ\nhs : Primrec s\nl : α → σ\nhl : Primrec l\nr : α → σ\nhr : Primrec r\npr : α → Code × Code × σ × σ → σ\nhpr : Primrec₂ pr\nco : α → Code × Code × σ × σ → σ\nhco : Primrec₂ co\npc : α → Code × Code × σ × σ → σ\nhpc : Primrec₂ pc\nrf : α → Code × σ → σ\nhrf : Primrec₂ rf\nPR✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pr a (cf, cg, hf, hg)\nCO✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => co a (cf, cg, hf, hg)\nPC✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pc a (cf, cg, hf, hg)\nRF✝ : α → Code → σ → σ := fun a cf hf => rf a (cf, hf)\nF : α → Code → σ := fun a c => Code.recOn c (z a) (s a) (l a) (r a) (PR✝ a) (CO✝ a) (PC✝ a) (RF✝ a)\nG₁ : (α × List σ) × ℕ × ℕ → Option σ :=\n fun p =>\n let a := p.fst.fst;\n let IH := p.fst.snd;\n let n := p.snd.fst;\n let m := p.snd.snd;\n Option.bind (List.get? IH m) fun s =>\n Option.bind (List.get? IH (unpair m).fst) fun s₁ =>\n Option.map\n (fun s₂ =>\n bif bodd n then\n bif bodd (div2 n) then rf a (ofNat Code m, s)\n else pc a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else\n bif bodd (div2 n) then co a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else pr a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂))\n (List.get? IH (unpair m).snd)\nthis✝ : Primrec G₁\nG : α → List σ → Option σ :=\n fun a IH =>\n Nat.casesOn (List.length IH) (some (z a)) fun n =>\n Nat.casesOn n (some (s a)) fun n =>\n Nat.casesOn n (some (l a)) fun n => Nat.casesOn n (some (r a)) fun n => G₁ ((a, IH), n, div2 (div2 n))\nthis : Primrec₂ G\na : α\nn : ℕ\nm : ℕ := div2 (div2 n)\n⊢ m < n + 4",
"tactic": "simp [Nat.div2_val]"
},
{
"state_after": "no goals",
"state_before": "α : Type u_1\nσ : Type u_2\ninst✝¹ : Primcodable α\ninst✝ : Primcodable σ\nc : α → Code\nhc : Primrec c\nz : α → σ\nhz : Primrec z\ns : α → σ\nhs : Primrec s\nl : α → σ\nhl : Primrec l\nr : α → σ\nhr : Primrec r\npr : α → Code × Code × σ × σ → σ\nhpr : Primrec₂ pr\nco : α → Code × Code × σ × σ → σ\nhco : Primrec₂ co\npc : α → Code × Code × σ × σ → σ\nhpc : Primrec₂ pc\nrf : α → Code × σ → σ\nhrf : Primrec₂ rf\nPR✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pr a (cf, cg, hf, hg)\nCO✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => co a (cf, cg, hf, hg)\nPC✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pc a (cf, cg, hf, hg)\nRF✝ : α → Code → σ → σ := fun a cf hf => rf a (cf, hf)\nF : α → Code → σ := fun a c => Code.recOn c (z a) (s a) (l a) (r a) (PR✝ a) (CO✝ a) (PC✝ a) (RF✝ a)\nG₁ : (α × List σ) × ℕ × ℕ → Option σ :=\n fun p =>\n let a := p.fst.fst;\n let IH := p.fst.snd;\n let n := p.snd.fst;\n let m := p.snd.snd;\n Option.bind (List.get? IH m) fun s =>\n Option.bind (List.get? IH (unpair m).fst) fun s₁ =>\n Option.map\n (fun s₂ =>\n bif bodd n then\n bif bodd (div2 n) then rf a (ofNat Code m, s)\n else pc a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else\n bif bodd (div2 n) then co a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂)\n else pr a (ofNat Code (unpair m).fst, ofNat Code (unpair m).snd, s₁, s₂))\n (List.get? IH (unpair m).snd)\nthis✝ : Primrec G₁\nG : α → List σ → Option σ :=\n fun a IH =>\n Nat.casesOn (List.length IH) (some (z a)) fun n =>\n Nat.casesOn n (some (s a)) fun n =>\n Nat.casesOn n (some (l a)) fun n => Nat.casesOn n (some (r a)) fun n => G₁ ((a, IH), n, div2 (div2 n))\nthis : Primrec₂ G\na : α\nn : ℕ\nm : ℕ := div2 (div2 n)\n⊢ n / 2 / 2 < n + 4",
"tactic": "exact\n lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _))\n (Nat.succ_le_succ (Nat.le_add_right _ _))"
}
] |
[
385,
45
] |
5a919533f110b7d76410134a237ee374f24eaaad
|
https://github.com/leanprover-community/mathlib4
|
[
279,
1
] |
Mathlib/Dynamics/Circle/RotationNumber/TranslationNumber.lean
|
CircleDeg1Lift.translationNumber_conj_eq'
|
[] |
[
767,
34
] |
5a919533f110b7d76410134a237ee374f24eaaad
|
https://github.com/leanprover-community/mathlib4
|
[
765,
1
] |
Mathlib/Analysis/SpecialFunctions/Pow/Real.lean
|
Real.rpow_lt_rpow_of_exponent_lt
|
[
{
"state_after": "x y z : ℝ\nhx : 1 < x\nhyz : y < z\n⊢ exp (log x * y) < exp (log x * z)",
"state_before": "x y z : ℝ\nhx : 1 < x\nhyz : y < z\n⊢ x ^ y < x ^ z",
"tactic": "repeat' rw [rpow_def_of_pos (lt_trans zero_lt_one hx)]"
},
{
"state_after": "x y z : ℝ\nhx : 1 < x\nhyz : y < z\n⊢ log x * y < log x * z",
"state_before": "x y z : ℝ\nhx : 1 < x\nhyz : y < z\n⊢ exp (log x * y) < exp (log x * z)",
"tactic": "rw [exp_lt_exp]"
},
{
"state_after": "no goals",
"state_before": "x y z : ℝ\nhx : 1 < x\nhyz : y < z\n⊢ log x * y < log x * z",
"tactic": "exact mul_lt_mul_of_pos_left hyz (log_pos hx)"
},
{
"state_after": "x y z : ℝ\nhx : 1 < x\nhyz : y < z\n⊢ exp (log x * y) < exp (log x * z)",
"state_before": "x y z : ℝ\nhx : 1 < x\nhyz : y < z\n⊢ exp (log x * y) < exp (log x * z)",
"tactic": "rw [rpow_def_of_pos (lt_trans zero_lt_one hx)]"
}
] |
[
472,
65
] |
5a919533f110b7d76410134a237ee374f24eaaad
|
https://github.com/leanprover-community/mathlib4
|
[
470,
1
] |
Mathlib/Order/Filter/Basic.lean
|
Filter.eventuallyEq_univ
|
[
{
"state_after": "no goals",
"state_before": "α : Type u\nβ : Type v\nγ : Type w\nδ : Type ?u.183630\nι : Sort x\ns : Set α\nl : Filter α\n⊢ s =ᶠ[l] univ ↔ s ∈ l",
"tactic": "simp [eventuallyEq_set]"
}
] |
[
1455,
26
] |
5a919533f110b7d76410134a237ee374f24eaaad
|
https://github.com/leanprover-community/mathlib4
|
[
1454,
1
] |
Mathlib/LinearAlgebra/Basic.lean
|
Submodule.ofLe_apply
|
[] |
[
629,
6
] |
5a919533f110b7d76410134a237ee374f24eaaad
|
https://github.com/leanprover-community/mathlib4
|
[
628,
1
] |
Mathlib/Topology/NhdsSet.lean
|
principal_le_nhdsSet
|
[] |
[
83,
65
] |
5a919533f110b7d76410134a237ee374f24eaaad
|
https://github.com/leanprover-community/mathlib4
|
[
82,
1
] |
Mathlib/Data/Sign.lean
|
SignType.pos_iff
|
[
{
"state_after": "no goals",
"state_before": "a : SignType\n⊢ 0 < a ↔ a = 1",
"tactic": "cases a <;> decide"
}
] |
[
196,
72
] |
5a919533f110b7d76410134a237ee374f24eaaad
|
https://github.com/leanprover-community/mathlib4
|
[
196,
1
] |
Mathlib/LinearAlgebra/LinearIndependent.lean
|
linearIndependent_subtype
|
[
{
"state_after": "no goals",
"state_before": "ι : Type u'\nι' : Type ?u.197690\nR : Type u_2\nK : Type ?u.197696\nM : Type u_1\nM' : Type ?u.197702\nM'' : Type ?u.197705\nV : Type u\nV' : Type ?u.197710\nv : ι → M\ninst✝⁶ : Semiring R\ninst✝⁵ : AddCommMonoid M\ninst✝⁴ : AddCommMonoid M'\ninst✝³ : AddCommMonoid M''\ninst✝² : Module R M\ninst✝¹ : Module R M'\ninst✝ : Module R M''\na b : R\nx y : M\ns : Set M\n⊢ (LinearIndependent R fun x => ↑x) ↔\n ∀ (l : M →₀ R), l ∈ Finsupp.supported R R s → ↑(Finsupp.total M M R id) l = 0 → l = 0",
"tactic": "apply @linearIndependent_comp_subtype _ _ _ id"
}
] |
[
384,
52
] |
5a919533f110b7d76410134a237ee374f24eaaad
|
https://github.com/leanprover-community/mathlib4
|
[
381,
1
] |
Mathlib/Topology/Algebra/Module/Basic.lean
|
ContinuousLinearEquiv.trans_toLinearEquiv
|
[
{
"state_after": "case h\nR₁ : Type u_1\nR₂ : Type u_2\nR₃ : Type u_5\ninst✝²⁴ : Semiring R₁\ninst✝²³ : Semiring R₂\ninst✝²² : Semiring R₃\nσ₁₂ : R₁ →+* R₂\nσ₂₁ : R₂ →+* R₁\ninst✝²¹ : RingHomInvPair σ₁₂ σ₂₁\ninst✝²⁰ : RingHomInvPair σ₂₁ σ₁₂\nσ₂₃ : R₂ →+* R₃\nσ₃₂ : R₃ →+* R₂\ninst✝¹⁹ : RingHomInvPair σ₂₃ σ₃₂\ninst✝¹⁸ : RingHomInvPair σ₃₂ σ₂₃\nσ₁₃ : R₁ →+* R₃\nσ₃₁ : R₃ →+* R₁\ninst✝¹⁷ : RingHomInvPair σ₁₃ σ₃₁\ninst✝¹⁶ : RingHomInvPair σ₃₁ σ₁₃\ninst✝¹⁵ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃\ninst✝¹⁴ : RingHomCompTriple σ₃₂ σ₂₁ σ₃₁\nM₁ : Type u_3\ninst✝¹³ : TopologicalSpace M₁\ninst✝¹² : AddCommMonoid M₁\nM'₁ : Type ?u.1545569\ninst✝¹¹ : TopologicalSpace M'₁\ninst✝¹⁰ : AddCommMonoid M'₁\nM₂ : Type u_4\ninst✝⁹ : TopologicalSpace M₂\ninst✝⁸ : AddCommMonoid M₂\nM₃ : Type u_6\ninst✝⁷ : TopologicalSpace M₃\ninst✝⁶ : AddCommMonoid M₃\nM₄ : Type ?u.1545596\ninst✝⁵ : TopologicalSpace M₄\ninst✝⁴ : AddCommMonoid M₄\ninst✝³ : Module R₁ M₁\ninst✝² : Module R₁ M'₁\ninst✝¹ : Module R₂ M₂\ninst✝ : Module R₃ M₃\ne₁ : M₁ ≃SL[σ₁₂] M₂\ne₂ : M₂ ≃SL[σ₂₃] M₃\nx✝ : M₁\n⊢ ↑(ContinuousLinearEquiv.trans e₁ e₂).toLinearEquiv x✝ = ↑(LinearEquiv.trans e₁.toLinearEquiv e₂.toLinearEquiv) x✝",
"state_before": "R₁ : Type u_1\nR₂ : Type u_2\nR₃ : Type u_5\ninst✝²⁴ : Semiring R₁\ninst✝²³ : Semiring R₂\ninst✝²² : Semiring R₃\nσ₁₂ : R₁ →+* R₂\nσ₂₁ : R₂ →+* R₁\ninst✝²¹ : RingHomInvPair σ₁₂ σ₂₁\ninst✝²⁰ : RingHomInvPair σ₂₁ σ₁₂\nσ₂₃ : R₂ →+* R₃\nσ₃₂ : R₃ →+* R₂\ninst✝¹⁹ : RingHomInvPair σ₂₃ σ₃₂\ninst✝¹⁸ : RingHomInvPair σ₃₂ σ₂₃\nσ₁₃ : R₁ →+* R₃\nσ₃₁ : R₃ →+* R₁\ninst✝¹⁷ : RingHomInvPair σ₁₃ σ₃₁\ninst✝¹⁶ : RingHomInvPair σ₃₁ σ₁₃\ninst✝¹⁵ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃\ninst✝¹⁴ : RingHomCompTriple σ₃₂ σ₂₁ σ₃₁\nM₁ : Type u_3\ninst✝¹³ : TopologicalSpace M₁\ninst✝¹² : AddCommMonoid M₁\nM'₁ : Type ?u.1545569\ninst✝¹¹ : TopologicalSpace M'₁\ninst✝¹⁰ : AddCommMonoid M'₁\nM₂ : Type u_4\ninst✝⁹ : TopologicalSpace M₂\ninst✝⁸ : AddCommMonoid M₂\nM₃ : Type u_6\ninst✝⁷ : TopologicalSpace M₃\ninst✝⁶ : AddCommMonoid M₃\nM₄ : Type ?u.1545596\ninst✝⁵ : TopologicalSpace M₄\ninst✝⁴ : AddCommMonoid M₄\ninst✝³ : Module R₁ M₁\ninst✝² : Module R₁ M'₁\ninst✝¹ : Module R₂ M₂\ninst✝ : Module R₃ M₃\ne₁ : M₁ ≃SL[σ₁₂] M₂\ne₂ : M₂ ≃SL[σ₂₃] M₃\n⊢ (ContinuousLinearEquiv.trans e₁ e₂).toLinearEquiv = LinearEquiv.trans e₁.toLinearEquiv e₂.toLinearEquiv",
"tactic": "ext"
},
{
"state_after": "no goals",
"state_before": "case h\nR₁ : Type u_1\nR₂ : Type u_2\nR₃ : Type u_5\ninst✝²⁴ : Semiring R₁\ninst✝²³ : Semiring R₂\ninst✝²² : Semiring R₃\nσ₁₂ : R₁ →+* R₂\nσ₂₁ : R₂ →+* R₁\ninst✝²¹ : RingHomInvPair σ₁₂ σ₂₁\ninst✝²⁰ : RingHomInvPair σ₂₁ σ₁₂\nσ₂₃ : R₂ →+* R₃\nσ₃₂ : R₃ →+* R₂\ninst✝¹⁹ : RingHomInvPair σ₂₃ σ₃₂\ninst✝¹⁸ : RingHomInvPair σ₃₂ σ₂₃\nσ₁₃ : R₁ →+* R₃\nσ₃₁ : R₃ →+* R₁\ninst✝¹⁷ : RingHomInvPair σ₁₃ σ₃₁\ninst✝¹⁶ : RingHomInvPair σ₃₁ σ₁₃\ninst✝¹⁵ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃\ninst✝¹⁴ : RingHomCompTriple σ₃₂ σ₂₁ σ₃₁\nM₁ : Type u_3\ninst✝¹³ : TopologicalSpace M₁\ninst✝¹² : AddCommMonoid M₁\nM'₁ : Type ?u.1545569\ninst✝¹¹ : TopologicalSpace M'₁\ninst✝¹⁰ : AddCommMonoid M'₁\nM₂ : Type u_4\ninst✝⁹ : TopologicalSpace M₂\ninst✝⁸ : AddCommMonoid M₂\nM₃ : Type u_6\ninst✝⁷ : TopologicalSpace M₃\ninst✝⁶ : AddCommMonoid M₃\nM₄ : Type ?u.1545596\ninst✝⁵ : TopologicalSpace M₄\ninst✝⁴ : AddCommMonoid M₄\ninst✝³ : Module R₁ M₁\ninst✝² : Module R₁ M'₁\ninst✝¹ : Module R₂ M₂\ninst✝ : Module R₃ M₃\ne₁ : M₁ ≃SL[σ₁₂] M₂\ne₂ : M₂ ≃SL[σ₂₃] M₃\nx✝ : M₁\n⊢ ↑(ContinuousLinearEquiv.trans e₁ e₂).toLinearEquiv x✝ = ↑(LinearEquiv.trans e₁.toLinearEquiv e₂.toLinearEquiv) x✝",
"tactic": "rfl"
}
] |
[
1988,
6
] |
5a919533f110b7d76410134a237ee374f24eaaad
|
https://github.com/leanprover-community/mathlib4
|
[
1985,
1
] |
Mathlib/ModelTheory/Basic.lean
|
FirstOrder.Language.Embedding.comp_apply
|
[] |
[
718,
6
] |
5a919533f110b7d76410134a237ee374f24eaaad
|
https://github.com/leanprover-community/mathlib4
|
[
717,
1
] |
Mathlib/Data/Int/Parity.lean
|
Int.odd_add
|
[
{
"state_after": "no goals",
"state_before": "m n : ℤ\n⊢ Odd (m + n) ↔ (Odd m ↔ Even n)",
"tactic": "rw [odd_iff_not_even, even_add, not_iff, odd_iff_not_even]"
}
] |
[
176,
61
] |
5a919533f110b7d76410134a237ee374f24eaaad
|
https://github.com/leanprover-community/mathlib4
|
[
175,
1
] |
Mathlib/SetTheory/Ordinal/Basic.lean
|
Ordinal.card_univ
|
[] |
[
1556,
6
] |
5a919533f110b7d76410134a237ee374f24eaaad
|
https://github.com/leanprover-community/mathlib4
|
[
1555,
1
] |
Mathlib/Data/Nat/Interval.lean
|
Finset.range_image_pred_top_sub
|
[
{
"state_after": "case zero\na b c : ℕ\n⊢ image (fun j => zero - 1 - j) (range zero) = range zero\n\ncase succ\na b c n✝ : ℕ\n⊢ image (fun j => succ n✝ - 1 - j) (range (succ n✝)) = range (succ n✝)",
"state_before": "a b c n : ℕ\n⊢ image (fun j => n - 1 - j) (range n) = range n",
"tactic": "cases n"
},
{
"state_after": "no goals",
"state_before": "case zero\na b c : ℕ\n⊢ image (fun j => zero - 1 - j) (range zero) = range zero",
"tactic": "rw [range_zero, image_empty]"
},
{
"state_after": "case succ\na b c n✝ : ℕ\n⊢ Ico (succ n✝ - 1 + 1 - succ n✝) (succ n✝ - 1 + 1 - 0) = Ico 0 (succ n✝)",
"state_before": "case succ\na b c n✝ : ℕ\n⊢ image (fun j => succ n✝ - 1 - j) (range (succ n✝)) = range (succ n✝)",
"tactic": "rw [Finset.range_eq_Ico, Nat.Ico_image_const_sub_eq_Ico (Nat.zero_le _)]"
},
{
"state_after": "no goals",
"state_before": "case succ\na b c n✝ : ℕ\n⊢ Ico (succ n✝ - 1 + 1 - succ n✝) (succ n✝ - 1 + 1 - 0) = Ico 0 (succ n✝)",
"tactic": "simp_rw [succ_sub_succ, tsub_zero, tsub_self]"
}
] |
[
332,
50
] |
5a919533f110b7d76410134a237ee374f24eaaad
|
https://github.com/leanprover-community/mathlib4
|
[
327,
1
] |
Mathlib/Analysis/BoxIntegral/Partition/Filter.lean
|
BoxIntegral.IntegrationParams.rCond_of_bRiemann_eq_false
|
[
{
"state_after": "no goals",
"state_before": "ι✝ : Type ?u.29939\ninst✝ : Fintype ι✝\nI J : Box ι✝\nc c₁ c₂ : ℝ≥0\nr✝ r₁ r₂ : (ι✝ → ℝ) → ↑(Set.Ioi 0)\nπ π₁ π₂ : TaggedPrepartition I\nl✝ l₁ l₂ : IntegrationParams\nι : Type u_1\nl : IntegrationParams\nhl : l.bRiemann = false\nr : (ι → ℝ) → ↑(Set.Ioi 0)\n⊢ RCond l r",
"tactic": "simp [RCond, hl]"
}
] |
[
351,
19
] |
5a919533f110b7d76410134a237ee374f24eaaad
|
https://github.com/leanprover-community/mathlib4
|
[
349,
1
] |
Mathlib/GroupTheory/FreeAbelianGroup.lean
|
FreeAbelianGroup.neg_bind
|
[] |
[
256,
21
] |
5a919533f110b7d76410134a237ee374f24eaaad
|
https://github.com/leanprover-community/mathlib4
|
[
255,
1
] |
Mathlib/Data/Bool/Basic.lean
|
Bool.or_and_distrib_left
|
[
{
"state_after": "no goals",
"state_before": "a b c : Bool\n⊢ (a || b && c) = ((a || b) && (a || c))",
"tactic": "cases a <;> simp"
}
] |
[
191,
19
] |
5a919533f110b7d76410134a237ee374f24eaaad
|
https://github.com/leanprover-community/mathlib4
|
[
190,
1
] |
Mathlib/Data/Polynomial/Derivative.lean
|
Polynomial.iterate_derivative_add
|
[] |
[
169,
50
] |
5a919533f110b7d76410134a237ee374f24eaaad
|
https://github.com/leanprover-community/mathlib4
|
[
167,
1
] |
Mathlib/MeasureTheory/Measure/MeasureSpaceDef.lean
|
MeasureTheory.exists_measurable_superset₂
|
[
{
"state_after": "no goals",
"state_before": "α : Type u_1\nβ : Type ?u.15260\nγ : Type ?u.15263\nδ : Type ?u.15266\nι : Type ?u.15269\ninst✝ : MeasurableSpace α\nμ✝ μ₁ μ₂ : Measure α\ns✝ s₁ s₂ t : Set α\nμ ν : Measure α\ns : Set α\n⊢ ∃ t, s ⊆ t ∧ MeasurableSet t ∧ ↑↑μ t = ↑↑μ s ∧ ↑↑ν t = ↑↑ν s",
"tactic": "simpa only [Bool.forall_bool.trans and_comm] using\n exists_measurable_superset_forall_eq (fun b => cond b μ ν) s"
}
] |
[
224,
65
] |
5a919533f110b7d76410134a237ee374f24eaaad
|
https://github.com/leanprover-community/mathlib4
|
[
221,
1
] |
Mathlib/Topology/UniformSpace/Basic.lean
|
ball_eq_of_symmetry
|
[
{
"state_after": "case h\nα : Type ua\nβ : Type ub\nγ : Type uc\nδ : Type ud\nι : Sort ?u.55168\ninst✝ : UniformSpace α\nV : Set (β × β)\nhV : SymmetricRel V\nx y : β\n⊢ y ∈ ball x V ↔ y ∈ {y | (y, x) ∈ V}",
"state_before": "α : Type ua\nβ : Type ub\nγ : Type uc\nδ : Type ud\nι : Sort ?u.55168\ninst✝ : UniformSpace α\nV : Set (β × β)\nhV : SymmetricRel V\nx : β\n⊢ ball x V = {y | (y, x) ∈ V}",
"tactic": "ext y"
},
{
"state_after": "case h\nα : Type ua\nβ : Type ub\nγ : Type uc\nδ : Type ud\nι : Sort ?u.55168\ninst✝ : UniformSpace α\nV : Set (β × β)\nhV : SymmetricRel V\nx y : β\n⊢ x ∈ ball y V ↔ y ∈ {y | (y, x) ∈ V}",
"state_before": "case h\nα : Type ua\nβ : Type ub\nγ : Type uc\nδ : Type ud\nι : Sort ?u.55168\ninst✝ : UniformSpace α\nV : Set (β × β)\nhV : SymmetricRel V\nx y : β\n⊢ y ∈ ball x V ↔ y ∈ {y | (y, x) ∈ V}",
"tactic": "rw [mem_ball_symmetry hV]"
},
{
"state_after": "no goals",
"state_before": "case h\nα : Type ua\nβ : Type ub\nγ : Type uc\nδ : Type ud\nι : Sort ?u.55168\ninst✝ : UniformSpace α\nV : Set (β × β)\nhV : SymmetricRel V\nx y : β\n⊢ x ∈ ball y V ↔ y ∈ {y | (y, x) ∈ V}",
"tactic": "exact Iff.rfl"
}
] |
[
661,
16
] |
5a919533f110b7d76410134a237ee374f24eaaad
|
https://github.com/leanprover-community/mathlib4
|
[
657,
1
] |
Mathlib/Order/Antisymmetrization.lean
|
toAntisymmetrization_lt_toAntisymmetrization_iff
|
[] |
[
191,
10
] |
5a919533f110b7d76410134a237ee374f24eaaad
|
https://github.com/leanprover-community/mathlib4
|
[
189,
1
] |
Mathlib/Order/Cover.lean
|
wcovby_iff_le_and_eq_or_eq
|
[] |
[
167,
69
] |
5a919533f110b7d76410134a237ee374f24eaaad
|
https://github.com/leanprover-community/mathlib4
|
[
166,
1
] |
Mathlib/LinearAlgebra/SesquilinearForm.lean
|
LinearMap.separatingLeft_congr_iff
|
[
{
"state_after": "case h.e'_15\nR : Type u_1\nR₁ : Type ?u.510521\nR₂ : Type ?u.510524\nR₃ : Type ?u.510527\nM : Type ?u.510530\nM₁ : Type ?u.510533\nM₂ : Type ?u.510536\nMₗ₁ : Type u_4\nMₗ₁' : Type u_2\nMₗ₂ : Type u_5\nMₗ₂' : Type u_3\nK : Type ?u.510551\nK₁ : Type ?u.510554\nK₂ : Type ?u.510557\nV : Type ?u.510560\nV₁ : Type ?u.510563\nV₂ : Type ?u.510566\nn : Type ?u.510569\ninst✝¹⁴ : CommSemiring R\ninst✝¹³ : CommSemiring R₁\ninst✝¹² : AddCommMonoid M₁\ninst✝¹¹ : Module R₁ M₁\ninst✝¹⁰ : CommSemiring R₂\ninst✝⁹ : AddCommMonoid M₂\ninst✝⁸ : Module R₂ M₂\nI₁ : R₁ →+* R\nI₂ : R₂ →+* R\nI₁' : R₁ →+* R\ninst✝⁷ : AddCommMonoid Mₗ₁\ninst✝⁶ : AddCommMonoid Mₗ₂\ninst✝⁵ : AddCommMonoid Mₗ₁'\ninst✝⁴ : AddCommMonoid Mₗ₂'\ninst✝³ : Module R Mₗ₁\ninst✝² : Module R Mₗ₂\ninst✝¹ : Module R Mₗ₁'\ninst✝ : Module R Mₗ₂'\nB : Mₗ₁ →ₗ[R] Mₗ₂ →ₗ[R] R\ne₁ : Mₗ₁ ≃ₗ[R] Mₗ₁'\ne₂ : Mₗ₂ ≃ₗ[R] Mₗ₂'\nh : SeparatingLeft (↑(LinearEquiv.arrowCongr e₁ (LinearEquiv.arrowCongr e₂ (LinearEquiv.refl R R))) B)\n⊢ B =\n ↑(LinearEquiv.arrowCongr (LinearEquiv.symm e₁)\n (LinearEquiv.arrowCongr (LinearEquiv.symm e₂) (LinearEquiv.refl R R)))\n (↑(LinearEquiv.arrowCongr e₁ (LinearEquiv.arrowCongr e₂ (LinearEquiv.refl R R))) B)",
"state_before": "R : Type u_1\nR₁ : Type ?u.510521\nR₂ : Type ?u.510524\nR₃ : Type ?u.510527\nM : Type ?u.510530\nM₁ : Type ?u.510533\nM₂ : Type ?u.510536\nMₗ₁ : Type u_4\nMₗ₁' : Type u_2\nMₗ₂ : Type u_5\nMₗ₂' : Type u_3\nK : Type ?u.510551\nK₁ : Type ?u.510554\nK₂ : Type ?u.510557\nV : Type ?u.510560\nV₁ : Type ?u.510563\nV₂ : Type ?u.510566\nn : Type ?u.510569\ninst✝¹⁴ : CommSemiring R\ninst✝¹³ : CommSemiring R₁\ninst✝¹² : AddCommMonoid M₁\ninst✝¹¹ : Module R₁ M₁\ninst✝¹⁰ : CommSemiring R₂\ninst✝⁹ : AddCommMonoid M₂\ninst✝⁸ : Module R₂ M₂\nI₁ : R₁ →+* R\nI₂ : R₂ →+* R\nI₁' : R₁ →+* R\ninst✝⁷ : AddCommMonoid Mₗ₁\ninst✝⁶ : AddCommMonoid Mₗ₂\ninst✝⁵ : AddCommMonoid Mₗ₁'\ninst✝⁴ : AddCommMonoid Mₗ₂'\ninst✝³ : Module R Mₗ₁\ninst✝² : Module R Mₗ₂\ninst✝¹ : Module R Mₗ₁'\ninst✝ : Module R Mₗ₂'\nB : Mₗ₁ →ₗ[R] Mₗ₂ →ₗ[R] R\ne₁ : Mₗ₁ ≃ₗ[R] Mₗ₁'\ne₂ : Mₗ₂ ≃ₗ[R] Mₗ₂'\nh : SeparatingLeft (↑(LinearEquiv.arrowCongr e₁ (LinearEquiv.arrowCongr e₂ (LinearEquiv.refl R R))) B)\n⊢ SeparatingLeft B",
"tactic": "convert h.congr e₁.symm e₂.symm"
},
{
"state_after": "case h.e'_15.h.h\nR : Type u_1\nR₁ : Type ?u.510521\nR₂ : Type ?u.510524\nR₃ : Type ?u.510527\nM : Type ?u.510530\nM₁ : Type ?u.510533\nM₂ : Type ?u.510536\nMₗ₁ : Type u_4\nMₗ₁' : Type u_2\nMₗ₂ : Type u_5\nMₗ₂' : Type u_3\nK : Type ?u.510551\nK₁ : Type ?u.510554\nK₂ : Type ?u.510557\nV : Type ?u.510560\nV₁ : Type ?u.510563\nV₂ : Type ?u.510566\nn : Type ?u.510569\ninst✝¹⁴ : CommSemiring R\ninst✝¹³ : CommSemiring R₁\ninst✝¹² : AddCommMonoid M₁\ninst✝¹¹ : Module R₁ M₁\ninst✝¹⁰ : CommSemiring R₂\ninst✝⁹ : AddCommMonoid M₂\ninst✝⁸ : Module R₂ M₂\nI₁ : R₁ →+* R\nI₂ : R₂ →+* R\nI₁' : R₁ →+* R\ninst✝⁷ : AddCommMonoid Mₗ₁\ninst✝⁶ : AddCommMonoid Mₗ₂\ninst✝⁵ : AddCommMonoid Mₗ₁'\ninst✝⁴ : AddCommMonoid Mₗ₂'\ninst✝³ : Module R Mₗ₁\ninst✝² : Module R Mₗ₂\ninst✝¹ : Module R Mₗ₁'\ninst✝ : Module R Mₗ₂'\nB : Mₗ₁ →ₗ[R] Mₗ₂ →ₗ[R] R\ne₁ : Mₗ₁ ≃ₗ[R] Mₗ₁'\ne₂ : Mₗ₂ ≃ₗ[R] Mₗ₂'\nh : SeparatingLeft (↑(LinearEquiv.arrowCongr e₁ (LinearEquiv.arrowCongr e₂ (LinearEquiv.refl R R))) B)\nx : Mₗ₁\ny : Mₗ₂\n⊢ ↑(↑B x) y =\n ↑(↑(↑(LinearEquiv.arrowCongr (LinearEquiv.symm e₁)\n (LinearEquiv.arrowCongr (LinearEquiv.symm e₂) (LinearEquiv.refl R R)))\n (↑(LinearEquiv.arrowCongr e₁ (LinearEquiv.arrowCongr e₂ (LinearEquiv.refl R R))) B))\n x)\n y",
"state_before": "case h.e'_15\nR : Type u_1\nR₁ : Type ?u.510521\nR₂ : Type ?u.510524\nR₃ : Type ?u.510527\nM : Type ?u.510530\nM₁ : Type ?u.510533\nM₂ : Type ?u.510536\nMₗ₁ : Type u_4\nMₗ₁' : Type u_2\nMₗ₂ : Type u_5\nMₗ₂' : Type u_3\nK : Type ?u.510551\nK₁ : Type ?u.510554\nK₂ : Type ?u.510557\nV : Type ?u.510560\nV₁ : Type ?u.510563\nV₂ : Type ?u.510566\nn : Type ?u.510569\ninst✝¹⁴ : CommSemiring R\ninst✝¹³ : CommSemiring R₁\ninst✝¹² : AddCommMonoid M₁\ninst✝¹¹ : Module R₁ M₁\ninst✝¹⁰ : CommSemiring R₂\ninst✝⁹ : AddCommMonoid M₂\ninst✝⁸ : Module R₂ M₂\nI₁ : R₁ →+* R\nI₂ : R₂ →+* R\nI₁' : R₁ →+* R\ninst✝⁷ : AddCommMonoid Mₗ₁\ninst✝⁶ : AddCommMonoid Mₗ₂\ninst✝⁵ : AddCommMonoid Mₗ₁'\ninst✝⁴ : AddCommMonoid Mₗ₂'\ninst✝³ : Module R Mₗ₁\ninst✝² : Module R Mₗ₂\ninst✝¹ : Module R Mₗ₁'\ninst✝ : Module R Mₗ₂'\nB : Mₗ₁ →ₗ[R] Mₗ₂ →ₗ[R] R\ne₁ : Mₗ₁ ≃ₗ[R] Mₗ₁'\ne₂ : Mₗ₂ ≃ₗ[R] Mₗ₂'\nh : SeparatingLeft (↑(LinearEquiv.arrowCongr e₁ (LinearEquiv.arrowCongr e₂ (LinearEquiv.refl R R))) B)\n⊢ B =\n ↑(LinearEquiv.arrowCongr (LinearEquiv.symm e₁)\n (LinearEquiv.arrowCongr (LinearEquiv.symm e₂) (LinearEquiv.refl R R)))\n (↑(LinearEquiv.arrowCongr e₁ (LinearEquiv.arrowCongr e₂ (LinearEquiv.refl R R))) B)",
"tactic": "ext (x y)"
},
{
"state_after": "no goals",
"state_before": "case h.e'_15.h.h\nR : Type u_1\nR₁ : Type ?u.510521\nR₂ : Type ?u.510524\nR₃ : Type ?u.510527\nM : Type ?u.510530\nM₁ : Type ?u.510533\nM₂ : Type ?u.510536\nMₗ₁ : Type u_4\nMₗ₁' : Type u_2\nMₗ₂ : Type u_5\nMₗ₂' : Type u_3\nK : Type ?u.510551\nK₁ : Type ?u.510554\nK₂ : Type ?u.510557\nV : Type ?u.510560\nV₁ : Type ?u.510563\nV₂ : Type ?u.510566\nn : Type ?u.510569\ninst✝¹⁴ : CommSemiring R\ninst✝¹³ : CommSemiring R₁\ninst✝¹² : AddCommMonoid M₁\ninst✝¹¹ : Module R₁ M₁\ninst✝¹⁰ : CommSemiring R₂\ninst✝⁹ : AddCommMonoid M₂\ninst✝⁸ : Module R₂ M₂\nI₁ : R₁ →+* R\nI₂ : R₂ →+* R\nI₁' : R₁ →+* R\ninst✝⁷ : AddCommMonoid Mₗ₁\ninst✝⁶ : AddCommMonoid Mₗ₂\ninst✝⁵ : AddCommMonoid Mₗ₁'\ninst✝⁴ : AddCommMonoid Mₗ₂'\ninst✝³ : Module R Mₗ₁\ninst✝² : Module R Mₗ₂\ninst✝¹ : Module R Mₗ₁'\ninst✝ : Module R Mₗ₂'\nB : Mₗ₁ →ₗ[R] Mₗ₂ →ₗ[R] R\ne₁ : Mₗ₁ ≃ₗ[R] Mₗ₁'\ne₂ : Mₗ₂ ≃ₗ[R] Mₗ₂'\nh : SeparatingLeft (↑(LinearEquiv.arrowCongr e₁ (LinearEquiv.arrowCongr e₂ (LinearEquiv.refl R R))) B)\nx : Mₗ₁\ny : Mₗ₂\n⊢ ↑(↑B x) y =\n ↑(↑(↑(LinearEquiv.arrowCongr (LinearEquiv.symm e₁)\n (LinearEquiv.arrowCongr (LinearEquiv.symm e₂) (LinearEquiv.refl R R)))\n (↑(LinearEquiv.arrowCongr e₁ (LinearEquiv.arrowCongr e₂ (LinearEquiv.refl R R))) B))\n x)\n y",
"tactic": "simp"
}
] |
[
667,
31
] |
5a919533f110b7d76410134a237ee374f24eaaad
|
https://github.com/leanprover-community/mathlib4
|
[
661,
1
] |
Mathlib/Analysis/Calculus/Taylor.lean
|
continuousOn_taylorWithinEval
|
[
{
"state_after": "𝕜 : Type ?u.239708\nE : Type u_1\nF : Type ?u.239714\ninst✝¹ : NormedAddCommGroup E\ninst✝ : NormedSpace ℝ E\nf : ℝ → E\nx : ℝ\nn : ℕ\ns : Set ℝ\nhs : UniqueDiffOn ℝ s\nhf : ContDiffOn ℝ (↑n) f s\n⊢ ContinuousOn (fun t => ∑ k in Finset.range (n + 1), ((↑k !)⁻¹ * (x - t) ^ k) • iteratedDerivWithin k f s t) s",
"state_before": "𝕜 : Type ?u.239708\nE : Type u_1\nF : Type ?u.239714\ninst✝¹ : NormedAddCommGroup E\ninst✝ : NormedSpace ℝ E\nf : ℝ → E\nx : ℝ\nn : ℕ\ns : Set ℝ\nhs : UniqueDiffOn ℝ s\nhf : ContDiffOn ℝ (↑n) f s\n⊢ ContinuousOn (fun t => taylorWithinEval f n s t x) s",
"tactic": "simp_rw [taylor_within_apply]"
},
{
"state_after": "𝕜 : Type ?u.239708\nE : Type u_1\nF : Type ?u.239714\ninst✝¹ : NormedAddCommGroup E\ninst✝ : NormedSpace ℝ E\nf : ℝ → E\nx : ℝ\nn : ℕ\ns : Set ℝ\nhs : UniqueDiffOn ℝ s\nhf : ContDiffOn ℝ (↑n) f s\ni : ℕ\nhi : i ∈ Finset.range (n + 1)\n⊢ ContinuousOn (fun t => ((↑i !)⁻¹ * (x - t) ^ i) • iteratedDerivWithin i f s t) s",
"state_before": "𝕜 : Type ?u.239708\nE : Type u_1\nF : Type ?u.239714\ninst✝¹ : NormedAddCommGroup E\ninst✝ : NormedSpace ℝ E\nf : ℝ → E\nx : ℝ\nn : ℕ\ns : Set ℝ\nhs : UniqueDiffOn ℝ s\nhf : ContDiffOn ℝ (↑n) f s\n⊢ ContinuousOn (fun t => ∑ k in Finset.range (n + 1), ((↑k !)⁻¹ * (x - t) ^ k) • iteratedDerivWithin k f s t) s",
"tactic": "refine' continuousOn_finset_sum (Finset.range (n + 1)) fun i hi => _"
},
{
"state_after": "𝕜 : Type ?u.239708\nE : Type u_1\nF : Type ?u.239714\ninst✝¹ : NormedAddCommGroup E\ninst✝ : NormedSpace ℝ E\nf : ℝ → E\nx : ℝ\nn : ℕ\ns : Set ℝ\nhs : UniqueDiffOn ℝ s\nhf : ContDiffOn ℝ (↑n) f s\ni : ℕ\nhi : i ∈ Finset.range (n + 1)\n⊢ ContinuousOn (fun t => iteratedDerivWithin i f s t) s",
"state_before": "𝕜 : Type ?u.239708\nE : Type u_1\nF : Type ?u.239714\ninst✝¹ : NormedAddCommGroup E\ninst✝ : NormedSpace ℝ E\nf : ℝ → E\nx : ℝ\nn : ℕ\ns : Set ℝ\nhs : UniqueDiffOn ℝ s\nhf : ContDiffOn ℝ (↑n) f s\ni : ℕ\nhi : i ∈ Finset.range (n + 1)\n⊢ ContinuousOn (fun t => ((↑i !)⁻¹ * (x - t) ^ i) • iteratedDerivWithin i f s t) s",
"tactic": "refine' (continuousOn_const.mul ((continuousOn_const.sub continuousOn_id).pow _)).smul _"
},
{
"state_after": "𝕜 : Type ?u.239708\nE : Type u_1\nF : Type ?u.239714\ninst✝¹ : NormedAddCommGroup E\ninst✝ : NormedSpace ℝ E\nf : ℝ → E\nx : ℝ\nn : ℕ\ns : Set ℝ\nhs : UniqueDiffOn ℝ s\nhf :\n (∀ (m : ℕ), ↑m ≤ ↑n → ContinuousOn (iteratedDerivWithin m f s) s) ∧\n ∀ (m : ℕ), ↑m < ↑n → DifferentiableOn ℝ (iteratedDerivWithin m f s) s\ni : ℕ\nhi : i ∈ Finset.range (n + 1)\n⊢ ContinuousOn (fun t => iteratedDerivWithin i f s t) s",
"state_before": "𝕜 : Type ?u.239708\nE : Type u_1\nF : Type ?u.239714\ninst✝¹ : NormedAddCommGroup E\ninst✝ : NormedSpace ℝ E\nf : ℝ → E\nx : ℝ\nn : ℕ\ns : Set ℝ\nhs : UniqueDiffOn ℝ s\nhf : ContDiffOn ℝ (↑n) f s\ni : ℕ\nhi : i ∈ Finset.range (n + 1)\n⊢ ContinuousOn (fun t => iteratedDerivWithin i f s t) s",
"tactic": "rw [contDiffOn_iff_continuousOn_differentiableOn_deriv hs] at hf"
},
{
"state_after": "case intro\n𝕜 : Type ?u.239708\nE : Type u_1\nF : Type ?u.239714\ninst✝¹ : NormedAddCommGroup E\ninst✝ : NormedSpace ℝ E\nf : ℝ → E\nx : ℝ\nn : ℕ\ns : Set ℝ\nhs : UniqueDiffOn ℝ s\ni : ℕ\nhi : i ∈ Finset.range (n + 1)\nhf_left : ∀ (m : ℕ), ↑m ≤ ↑n → ContinuousOn (iteratedDerivWithin m f s) s\nright✝ : ∀ (m : ℕ), ↑m < ↑n → DifferentiableOn ℝ (iteratedDerivWithin m f s) s\n⊢ ContinuousOn (fun t => iteratedDerivWithin i f s t) s",
"state_before": "𝕜 : Type ?u.239708\nE : Type u_1\nF : Type ?u.239714\ninst✝¹ : NormedAddCommGroup E\ninst✝ : NormedSpace ℝ E\nf : ℝ → E\nx : ℝ\nn : ℕ\ns : Set ℝ\nhs : UniqueDiffOn ℝ s\nhf :\n (∀ (m : ℕ), ↑m ≤ ↑n → ContinuousOn (iteratedDerivWithin m f s) s) ∧\n ∀ (m : ℕ), ↑m < ↑n → DifferentiableOn ℝ (iteratedDerivWithin m f s) s\ni : ℕ\nhi : i ∈ Finset.range (n + 1)\n⊢ ContinuousOn (fun t => iteratedDerivWithin i f s t) s",
"tactic": "cases' hf with hf_left"
},
{
"state_after": "case intro\n𝕜 : Type ?u.239708\nE : Type u_1\nF : Type ?u.239714\ninst✝¹ : NormedAddCommGroup E\ninst✝ : NormedSpace ℝ E\nf : ℝ → E\nx : ℝ\nn : ℕ\ns : Set ℝ\nhs : UniqueDiffOn ℝ s\ni : ℕ\nhi : i ∈ Finset.range (n + 1)\nright✝ : ∀ (m : ℕ), ↑m < ↑n → DifferentiableOn ℝ (iteratedDerivWithin m f s) s\nhf_left : ↑i ≤ ↑n → ContinuousOn (iteratedDerivWithin i f s) s\n⊢ ContinuousOn (fun t => iteratedDerivWithin i f s t) s",
"state_before": "case intro\n𝕜 : Type ?u.239708\nE : Type u_1\nF : Type ?u.239714\ninst✝¹ : NormedAddCommGroup E\ninst✝ : NormedSpace ℝ E\nf : ℝ → E\nx : ℝ\nn : ℕ\ns : Set ℝ\nhs : UniqueDiffOn ℝ s\ni : ℕ\nhi : i ∈ Finset.range (n + 1)\nhf_left : ∀ (m : ℕ), ↑m ≤ ↑n → ContinuousOn (iteratedDerivWithin m f s) s\nright✝ : ∀ (m : ℕ), ↑m < ↑n → DifferentiableOn ℝ (iteratedDerivWithin m f s) s\n⊢ ContinuousOn (fun t => iteratedDerivWithin i f s t) s",
"tactic": "specialize hf_left i"
},
{
"state_after": "case intro\n𝕜 : Type ?u.239708\nE : Type u_1\nF : Type ?u.239714\ninst✝¹ : NormedAddCommGroup E\ninst✝ : NormedSpace ℝ E\nf : ℝ → E\nx : ℝ\nn : ℕ\ns : Set ℝ\nhs : UniqueDiffOn ℝ s\ni : ℕ\nright✝ : ∀ (m : ℕ), ↑m < ↑n → DifferentiableOn ℝ (iteratedDerivWithin m f s) s\nhf_left : ↑i ≤ ↑n → ContinuousOn (iteratedDerivWithin i f s) s\nhi : i < n + 1\n⊢ ContinuousOn (fun t => iteratedDerivWithin i f s t) s",
"state_before": "case intro\n𝕜 : Type ?u.239708\nE : Type u_1\nF : Type ?u.239714\ninst✝¹ : NormedAddCommGroup E\ninst✝ : NormedSpace ℝ E\nf : ℝ → E\nx : ℝ\nn : ℕ\ns : Set ℝ\nhs : UniqueDiffOn ℝ s\ni : ℕ\nhi : i ∈ Finset.range (n + 1)\nright✝ : ∀ (m : ℕ), ↑m < ↑n → DifferentiableOn ℝ (iteratedDerivWithin m f s) s\nhf_left : ↑i ≤ ↑n → ContinuousOn (iteratedDerivWithin i f s) s\n⊢ ContinuousOn (fun t => iteratedDerivWithin i f s t) s",
"tactic": "simp only [Finset.mem_range] at hi"
},
{
"state_after": "case intro\n𝕜 : Type ?u.239708\nE : Type u_1\nF : Type ?u.239714\ninst✝¹ : NormedAddCommGroup E\ninst✝ : NormedSpace ℝ E\nf : ℝ → E\nx : ℝ\nn : ℕ\ns : Set ℝ\nhs : UniqueDiffOn ℝ s\ni : ℕ\nright✝ : ∀ (m : ℕ), ↑m < ↑n → DifferentiableOn ℝ (iteratedDerivWithin m f s) s\nhf_left : ↑i ≤ ↑n → ContinuousOn (iteratedDerivWithin i f s) s\nhi : i < n + 1\n⊢ ↑i ≤ ↑n",
"state_before": "case intro\n𝕜 : Type ?u.239708\nE : Type u_1\nF : Type ?u.239714\ninst✝¹ : NormedAddCommGroup E\ninst✝ : NormedSpace ℝ E\nf : ℝ → E\nx : ℝ\nn : ℕ\ns : Set ℝ\nhs : UniqueDiffOn ℝ s\ni : ℕ\nright✝ : ∀ (m : ℕ), ↑m < ↑n → DifferentiableOn ℝ (iteratedDerivWithin m f s) s\nhf_left : ↑i ≤ ↑n → ContinuousOn (iteratedDerivWithin i f s) s\nhi : i < n + 1\n⊢ ContinuousOn (fun t => iteratedDerivWithin i f s t) s",
"tactic": "refine' hf_left _"
},
{
"state_after": "no goals",
"state_before": "case intro\n𝕜 : Type ?u.239708\nE : Type u_1\nF : Type ?u.239714\ninst✝¹ : NormedAddCommGroup E\ninst✝ : NormedSpace ℝ E\nf : ℝ → E\nx : ℝ\nn : ℕ\ns : Set ℝ\nhs : UniqueDiffOn ℝ s\ni : ℕ\nright✝ : ∀ (m : ℕ), ↑m < ↑n → DifferentiableOn ℝ (iteratedDerivWithin m f s) s\nhf_left : ↑i ≤ ↑n → ContinuousOn (iteratedDerivWithin i f s) s\nhi : i < n + 1\n⊢ ↑i ≤ ↑n",
"tactic": "simp only [WithTop.coe_le_coe, Nat.cast_le, Nat.lt_succ_iff.mp hi]"
}
] |
[
139,
69
] |
5a919533f110b7d76410134a237ee374f24eaaad
|
https://github.com/leanprover-community/mathlib4
|
[
128,
1
] |
Mathlib/Topology/PathConnected.lean
|
PathConnectedSpace.exists_path_through_family'
|
[
{
"state_after": "X : Type u_1\nY : Type ?u.698693\ninst✝² : TopologicalSpace X\ninst✝¹ : TopologicalSpace Y\nx y z : X\nι : Type ?u.698708\nF : Set X\ninst✝ : PathConnectedSpace X\nn : ℕ\np : Fin (n + 1) → X\nthis : IsPathConnected univ\n⊢ ∃ γ t, ∀ (i : Fin (n + 1)), ↑γ (t i) = p i",
"state_before": "X : Type u_1\nY : Type ?u.698693\ninst✝² : TopologicalSpace X\ninst✝¹ : TopologicalSpace Y\nx y z : X\nι : Type ?u.698708\nF : Set X\ninst✝ : PathConnectedSpace X\nn : ℕ\np : Fin (n + 1) → X\n⊢ ∃ γ t, ∀ (i : Fin (n + 1)), ↑γ (t i) = p i",
"tactic": "have : IsPathConnected (univ : Set X) := pathConnectedSpace_iff_univ.mp (by infer_instance)"
},
{
"state_after": "case intro.intro.intro\nX : Type u_1\nY : Type ?u.698693\ninst✝² : TopologicalSpace X\ninst✝¹ : TopologicalSpace Y\nx y z : X\nι : Type ?u.698708\nF : Set X\ninst✝ : PathConnectedSpace X\nn : ℕ\np : Fin (n + 1) → X\nthis : IsPathConnected univ\nγ : Path (p 0) (p ↑n)\nt : Fin (n + 1) → ↑I\nh : ∀ (i : Fin (n + 1)), ↑γ (t i) = p i\n⊢ ∃ γ t, ∀ (i : Fin (n + 1)), ↑γ (t i) = p i",
"state_before": "X : Type u_1\nY : Type ?u.698693\ninst✝² : TopologicalSpace X\ninst✝¹ : TopologicalSpace Y\nx y z : X\nι : Type ?u.698708\nF : Set X\ninst✝ : PathConnectedSpace X\nn : ℕ\np : Fin (n + 1) → X\nthis : IsPathConnected univ\n⊢ ∃ γ t, ∀ (i : Fin (n + 1)), ↑γ (t i) = p i",
"tactic": "rcases this.exists_path_through_family' p fun _i => True.intro with ⟨γ, t, -, h⟩"
},
{
"state_after": "no goals",
"state_before": "case intro.intro.intro\nX : Type u_1\nY : Type ?u.698693\ninst✝² : TopologicalSpace X\ninst✝¹ : TopologicalSpace Y\nx y z : X\nι : Type ?u.698708\nF : Set X\ninst✝ : PathConnectedSpace X\nn : ℕ\np : Fin (n + 1) → X\nthis : IsPathConnected univ\nγ : Path (p 0) (p ↑n)\nt : Fin (n + 1) → ↑I\nh : ∀ (i : Fin (n + 1)), ↑γ (t i) = p i\n⊢ ∃ γ t, ∀ (i : Fin (n + 1)), ↑γ (t i) = p i",
"tactic": "exact ⟨γ, t, h⟩"
},
{
"state_after": "no goals",
"state_before": "X : Type u_1\nY : Type ?u.698693\ninst✝² : TopologicalSpace X\ninst✝¹ : TopologicalSpace Y\nx y z : X\nι : Type ?u.698708\nF : Set X\ninst✝ : PathConnectedSpace X\nn : ℕ\np : Fin (n + 1) → X\n⊢ PathConnectedSpace X",
"tactic": "infer_instance"
}
] |
[
1183,
18
] |
5a919533f110b7d76410134a237ee374f24eaaad
|
https://github.com/leanprover-community/mathlib4
|
[
1179,
1
] |
Mathlib/Analysis/Calculus/FDeriv/Basic.lean
|
Differentiable.continuous
|
[] |
[
747,
60
] |
5a919533f110b7d76410134a237ee374f24eaaad
|
https://github.com/leanprover-community/mathlib4
|
[
746,
1
] |
Mathlib/MeasureTheory/Measure/VectorMeasure.lean
|
MeasureTheory.VectorMeasure.empty
|
[] |
[
102,
11
] |
5a919533f110b7d76410134a237ee374f24eaaad
|
https://github.com/leanprover-community/mathlib4
|
[
101,
1
] |
Mathlib/Data/PNat/Prime.lean
|
PNat.dvd_prime
|
[
{
"state_after": "p m : ℕ+\npp : Prime p\n⊢ ↑m ∣ ↑p ↔ m = 1 ∨ m = p",
"state_before": "p m : ℕ+\npp : Prime p\n⊢ m ∣ p ↔ m = 1 ∨ m = p",
"tactic": "rw [PNat.dvd_iff]"
},
{
"state_after": "p m : ℕ+\npp : Prime p\n⊢ ↑m = 1 ∨ ↑m = ↑p ↔ m = 1 ∨ m = p",
"state_before": "p m : ℕ+\npp : Prime p\n⊢ ↑m ∣ ↑p ↔ m = 1 ∨ m = p",
"tactic": "rw [Nat.dvd_prime pp]"
},
{
"state_after": "no goals",
"state_before": "p m : ℕ+\npp : Prime p\n⊢ ↑m = 1 ∨ ↑m = ↑p ↔ m = 1 ∨ m = p",
"tactic": "simp"
}
] |
[
132,
7
] |
5a919533f110b7d76410134a237ee374f24eaaad
|
https://github.com/leanprover-community/mathlib4
|
[
129,
1
] |
Mathlib/Data/MvPolynomial/CommRing.lean
|
MvPolynomial.degreeOf_sub_lt
|
[
{
"state_after": "R : Type u\nS : Type v\nσ : Type u_1\na a' a₁ a₂ : R\ne : ℕ\nn m : σ\ns : σ →₀ ℕ\ninst✝ : CommRing R\np q : MvPolynomial σ R\nx : σ\nf g : MvPolynomial σ R\nk : ℕ\nh : 0 < k\nhf : ∀ (m : σ →₀ ℕ), m ∈ support f → k ≤ ↑m x → coeff m f = coeff m g\nhg : ∀ (m : σ →₀ ℕ), m ∈ support g → k ≤ ↑m x → coeff m f = coeff m g\n⊢ ∀ (m : σ →₀ ℕ), m ∈ support (f - g) → ↑m x < k",
"state_before": "R : Type u\nS : Type v\nσ : Type u_1\na a' a₁ a₂ : R\ne : ℕ\nn m : σ\ns : σ →₀ ℕ\ninst✝ : CommRing R\np q : MvPolynomial σ R\nx : σ\nf g : MvPolynomial σ R\nk : ℕ\nh : 0 < k\nhf : ∀ (m : σ →₀ ℕ), m ∈ support f → k ≤ ↑m x → coeff m f = coeff m g\nhg : ∀ (m : σ →₀ ℕ), m ∈ support g → k ≤ ↑m x → coeff m f = coeff m g\n⊢ degreeOf x (f - g) < k",
"tactic": "rw [degreeOf_lt_iff h]"
},
{
"state_after": "R : Type u\nS : Type v\nσ : Type u_1\na a' a₁ a₂ : R\ne : ℕ\nn m✝ : σ\ns : σ →₀ ℕ\ninst✝ : CommRing R\np q : MvPolynomial σ R\nx : σ\nf g : MvPolynomial σ R\nk : ℕ\nh : 0 < k\nhf : ∀ (m : σ →₀ ℕ), m ∈ support f → k ≤ ↑m x → coeff m f = coeff m g\nhg : ∀ (m : σ →₀ ℕ), m ∈ support g → k ≤ ↑m x → coeff m f = coeff m g\nm : σ →₀ ℕ\nhm : m ∈ support (f - g)\n⊢ ↑m x < k",
"state_before": "R : Type u\nS : Type v\nσ : Type u_1\na a' a₁ a₂ : R\ne : ℕ\nn m : σ\ns : σ →₀ ℕ\ninst✝ : CommRing R\np q : MvPolynomial σ R\nx : σ\nf g : MvPolynomial σ R\nk : ℕ\nh : 0 < k\nhf : ∀ (m : σ →₀ ℕ), m ∈ support f → k ≤ ↑m x → coeff m f = coeff m g\nhg : ∀ (m : σ →₀ ℕ), m ∈ support g → k ≤ ↑m x → coeff m f = coeff m g\n⊢ ∀ (m : σ →₀ ℕ), m ∈ support (f - g) → ↑m x < k",
"tactic": "intro m hm"
},
{
"state_after": "R : Type u\nS : Type v\nσ : Type u_1\na a' a₁ a₂ : R\ne : ℕ\nn m✝ : σ\ns : σ →₀ ℕ\ninst✝ : CommRing R\np q : MvPolynomial σ R\nx : σ\nf g : MvPolynomial σ R\nk : ℕ\nh : 0 < k\nhf : ∀ (m : σ →₀ ℕ), m ∈ support f → k ≤ ↑m x → coeff m f = coeff m g\nhg : ∀ (m : σ →₀ ℕ), m ∈ support g → k ≤ ↑m x → coeff m f = coeff m g\nm : σ →₀ ℕ\nhm : m ∈ support (f - g)\nhc : k ≤ ↑m x\n⊢ False",
"state_before": "R : Type u\nS : Type v\nσ : Type u_1\na a' a₁ a₂ : R\ne : ℕ\nn m✝ : σ\ns : σ →₀ ℕ\ninst✝ : CommRing R\np q : MvPolynomial σ R\nx : σ\nf g : MvPolynomial σ R\nk : ℕ\nh : 0 < k\nhf : ∀ (m : σ →₀ ℕ), m ∈ support f → k ≤ ↑m x → coeff m f = coeff m g\nhg : ∀ (m : σ →₀ ℕ), m ∈ support g → k ≤ ↑m x → coeff m f = coeff m g\nm : σ →₀ ℕ\nhm : m ∈ support (f - g)\n⊢ ↑m x < k",
"tactic": "by_contra' hc"
},
{
"state_after": "R : Type u\nS : Type v\nσ : Type u_1\na a' a₁ a₂ : R\ne : ℕ\nn m✝ : σ\ns : σ →₀ ℕ\ninst✝ : CommRing R\np q : MvPolynomial σ R\nx : σ\nf g : MvPolynomial σ R\nk : ℕ\nh✝ : 0 < k\nhf : ∀ (m : σ →₀ ℕ), m ∈ support f → k ≤ ↑m x → coeff m f = coeff m g\nhg : ∀ (m : σ →₀ ℕ), m ∈ support g → k ≤ ↑m x → coeff m f = coeff m g\nm : σ →₀ ℕ\nhm : m ∈ support (f - g)\nhc : k ≤ ↑m x\nh : m ∈ support f ∪ support g\n⊢ False",
"state_before": "R : Type u\nS : Type v\nσ : Type u_1\na a' a₁ a₂ : R\ne : ℕ\nn m✝ : σ\ns : σ →₀ ℕ\ninst✝ : CommRing R\np q : MvPolynomial σ R\nx : σ\nf g : MvPolynomial σ R\nk : ℕ\nh : 0 < k\nhf : ∀ (m : σ →₀ ℕ), m ∈ support f → k ≤ ↑m x → coeff m f = coeff m g\nhg : ∀ (m : σ →₀ ℕ), m ∈ support g → k ≤ ↑m x → coeff m f = coeff m g\nm : σ →₀ ℕ\nhm : m ∈ support (f - g)\nhc : k ≤ ↑m x\n⊢ False",
"tactic": "have h := support_sub σ f g hm"
},
{
"state_after": "R : Type u\nS : Type v\nσ : Type u_1\na a' a₁ a₂ : R\ne : ℕ\nn m✝ : σ\ns : σ →₀ ℕ\ninst✝ : CommRing R\np q : MvPolynomial σ R\nx : σ\nf g : MvPolynomial σ R\nk : ℕ\nh✝ : 0 < k\nhf : ∀ (m : σ →₀ ℕ), m ∈ support f → k ≤ ↑m x → coeff m f = coeff m g\nhg : ∀ (m : σ →₀ ℕ), m ∈ support g → k ≤ ↑m x → coeff m f = coeff m g\nm : σ →₀ ℕ\nhc : k ≤ ↑m x\nh : m ∈ support f ∪ support g\nhm : ¬coeff m f = coeff m g\n⊢ False",
"state_before": "R : Type u\nS : Type v\nσ : Type u_1\na a' a₁ a₂ : R\ne : ℕ\nn m✝ : σ\ns : σ →₀ ℕ\ninst✝ : CommRing R\np q : MvPolynomial σ R\nx : σ\nf g : MvPolynomial σ R\nk : ℕ\nh✝ : 0 < k\nhf : ∀ (m : σ →₀ ℕ), m ∈ support f → k ≤ ↑m x → coeff m f = coeff m g\nhg : ∀ (m : σ →₀ ℕ), m ∈ support g → k ≤ ↑m x → coeff m f = coeff m g\nm : σ →₀ ℕ\nhm : m ∈ support (f - g)\nhc : k ≤ ↑m x\nh : m ∈ support f ∪ support g\n⊢ False",
"tactic": "simp only [mem_support_iff, Ne.def, coeff_sub, sub_eq_zero] at hm"
},
{
"state_after": "case inl\nR : Type u\nS : Type v\nσ : Type u_1\na a' a₁ a₂ : R\ne : ℕ\nn m✝ : σ\ns : σ →₀ ℕ\ninst✝ : CommRing R\np q : MvPolynomial σ R\nx : σ\nf g : MvPolynomial σ R\nk : ℕ\nh✝ : 0 < k\nhf : ∀ (m : σ →₀ ℕ), m ∈ support f → k ≤ ↑m x → coeff m f = coeff m g\nhg : ∀ (m : σ →₀ ℕ), m ∈ support g → k ≤ ↑m x → coeff m f = coeff m g\nm : σ →₀ ℕ\nhc : k ≤ ↑m x\nh : m ∈ support f ∪ support g\nhm : ¬coeff m f = coeff m g\ncf : m ∈ support f\n⊢ False\n\ncase inr\nR : Type u\nS : Type v\nσ : Type u_1\na a' a₁ a₂ : R\ne : ℕ\nn m✝ : σ\ns : σ →₀ ℕ\ninst✝ : CommRing R\np q : MvPolynomial σ R\nx : σ\nf g : MvPolynomial σ R\nk : ℕ\nh✝ : 0 < k\nhf : ∀ (m : σ →₀ ℕ), m ∈ support f → k ≤ ↑m x → coeff m f = coeff m g\nhg : ∀ (m : σ →₀ ℕ), m ∈ support g → k ≤ ↑m x → coeff m f = coeff m g\nm : σ →₀ ℕ\nhc : k ≤ ↑m x\nh : m ∈ support f ∪ support g\nhm : ¬coeff m f = coeff m g\ncg : m ∈ support g\n⊢ False",
"state_before": "R : Type u\nS : Type v\nσ : Type u_1\na a' a₁ a₂ : R\ne : ℕ\nn m✝ : σ\ns : σ →₀ ℕ\ninst✝ : CommRing R\np q : MvPolynomial σ R\nx : σ\nf g : MvPolynomial σ R\nk : ℕ\nh✝ : 0 < k\nhf : ∀ (m : σ →₀ ℕ), m ∈ support f → k ≤ ↑m x → coeff m f = coeff m g\nhg : ∀ (m : σ →₀ ℕ), m ∈ support g → k ≤ ↑m x → coeff m f = coeff m g\nm : σ →₀ ℕ\nhc : k ≤ ↑m x\nh : m ∈ support f ∪ support g\nhm : ¬coeff m f = coeff m g\n⊢ False",
"tactic": "cases' Finset.mem_union.1 h with cf cg"
},
{
"state_after": "no goals",
"state_before": "case inl\nR : Type u\nS : Type v\nσ : Type u_1\na a' a₁ a₂ : R\ne : ℕ\nn m✝ : σ\ns : σ →₀ ℕ\ninst✝ : CommRing R\np q : MvPolynomial σ R\nx : σ\nf g : MvPolynomial σ R\nk : ℕ\nh✝ : 0 < k\nhf : ∀ (m : σ →₀ ℕ), m ∈ support f → k ≤ ↑m x → coeff m f = coeff m g\nhg : ∀ (m : σ →₀ ℕ), m ∈ support g → k ≤ ↑m x → coeff m f = coeff m g\nm : σ →₀ ℕ\nhc : k ≤ ↑m x\nh : m ∈ support f ∪ support g\nhm : ¬coeff m f = coeff m g\ncf : m ∈ support f\n⊢ False",
"tactic": "exact hm (hf m cf hc)"
},
{
"state_after": "no goals",
"state_before": "case inr\nR : Type u\nS : Type v\nσ : Type u_1\na a' a₁ a₂ : R\ne : ℕ\nn m✝ : σ\ns : σ →₀ ℕ\ninst✝ : CommRing R\np q : MvPolynomial σ R\nx : σ\nf g : MvPolynomial σ R\nk : ℕ\nh✝ : 0 < k\nhf : ∀ (m : σ →₀ ℕ), m ∈ support f → k ≤ ↑m x → coeff m f = coeff m g\nhg : ∀ (m : σ →₀ ℕ), m ∈ support g → k ≤ ↑m x → coeff m f = coeff m g\nm : σ →₀ ℕ\nhc : k ≤ ↑m x\nh : m ∈ support f ∪ support g\nhm : ¬coeff m f = coeff m g\ncg : m ∈ support g\n⊢ False",
"tactic": "exact hm (hg m cg hc)"
}
] |
[
194,
26
] |
5a919533f110b7d76410134a237ee374f24eaaad
|
https://github.com/leanprover-community/mathlib4
|
[
182,
1
] |
Mathlib/Analysis/SpecialFunctions/Trigonometric/Inverse.lean
|
Real.arcsin_one
|
[] |
[
121,
88
] |
5a919533f110b7d76410134a237ee374f24eaaad
|
https://github.com/leanprover-community/mathlib4
|
[
120,
1
] |
Mathlib/Data/List/Chain.lean
|
List.chain_iff_pairwise
|
[] |
[
129,
35
] |
5a919533f110b7d76410134a237ee374f24eaaad
|
https://github.com/leanprover-community/mathlib4
|
[
128,
1
] |
Mathlib/Data/List/Cycle.lean
|
List.next_ne_head_ne_getLast
|
[
{
"state_after": "no goals",
"state_before": "α : Type ?u.59864\ninst✝ : DecidableEq α\nl : List α\nx : α\nh✝ : x ∈ l\ny : α\nh : x ∈ y :: l\nhy : x ≠ y\nhx : x ≠ getLast (y :: l) (_ : y :: l ≠ [])\n⊢ x ∈ l",
"tactic": "simpa [hy] using h"
},
{
"state_after": "case x_mem\nα : Type u_1\ninst✝ : DecidableEq α\nl : List α\nx : α\nh✝ : x ∈ l\ny : α\nh : x ∈ y :: l\nhy : x ≠ y\nhx : x ≠ getLast (y :: l) (_ : y :: l ≠ [])\n⊢ x ∈ l\n\ncase x_ne\nα : Type u_1\ninst✝ : DecidableEq α\nl : List α\nx : α\nh✝ : x ∈ l\ny : α\nh : x ∈ y :: l\nhy : x ≠ y\nhx : x ≠ getLast (y :: l) (_ : y :: l ≠ [])\n⊢ x ≠ getLast l (_ : l ≠ [])",
"state_before": "α : Type u_1\ninst✝ : DecidableEq α\nl : List α\nx : α\nh✝ : x ∈ l\ny : α\nh : x ∈ y :: l\nhy : x ≠ y\nhx : x ≠ getLast (y :: l) (_ : y :: l ≠ [])\n⊢ next (y :: l) x h = next l x (_ : x ∈ l)",
"tactic": "rw [next, next, nextOr_cons_of_ne _ _ _ _ hy, nextOr_eq_nextOr_of_mem_of_ne]"
},
{
"state_after": "case x_mem\nα : Type u_1\ninst✝ : DecidableEq α\nl : List α\nx : α\nh✝ : x ∈ l\ny : α\nh : x ∈ y :: l\nhy : x ≠ y\nhx : x ≠ getLast (y :: l) (_ : y :: l ≠ [])\n⊢ l ≠ []",
"state_before": "case x_mem\nα : Type u_1\ninst✝ : DecidableEq α\nl : List α\nx : α\nh✝ : x ∈ l\ny : α\nh : x ∈ y :: l\nhy : x ≠ y\nhx : x ≠ getLast (y :: l) (_ : y :: l ≠ [])\n⊢ x ∈ l",
"tactic": "rwa [getLast_cons] at hx"
},
{
"state_after": "no goals",
"state_before": "case x_mem\nα : Type u_1\ninst✝ : DecidableEq α\nl : List α\nx : α\nh✝ : x ∈ l\ny : α\nh : x ∈ y :: l\nhy : x ≠ y\nhx : x ≠ getLast (y :: l) (_ : y :: l ≠ [])\n⊢ l ≠ []",
"tactic": "exact ne_nil_of_mem (by assumption)"
},
{
"state_after": "no goals",
"state_before": "α : Type u_1\ninst✝ : DecidableEq α\nl : List α\nx : α\nh✝ : x ∈ l\ny : α\nh : x ∈ y :: l\nhy : x ≠ y\nhx : x ≠ getLast (y :: l) (_ : y :: l ≠ [])\n⊢ ?m.65092 ∈ l",
"tactic": "assumption"
},
{
"state_after": "no goals",
"state_before": "case x_ne\nα : Type u_1\ninst✝ : DecidableEq α\nl : List α\nx : α\nh✝ : x ∈ l\ny : α\nh : x ∈ y :: l\nhy : x ≠ y\nhx : x ≠ getLast (y :: l) (_ : y :: l ≠ [])\n⊢ x ≠ getLast l (_ : l ≠ [])",
"tactic": "rwa [getLast_cons] at hx"
}
] |
[
173,
29
] |
5a919533f110b7d76410134a237ee374f24eaaad
|
https://github.com/leanprover-community/mathlib4
|
[
167,
1
] |
Mathlib/Order/Category/NonemptyFinLinOrdCat.lean
|
NonemptyFinLinOrdCat.mono_iff_injective
|
[
{
"state_after": "A B : NonemptyFinLinOrdCat\nf : A ⟶ B\n⊢ Mono f → Function.Injective ↑f",
"state_before": "A B : NonemptyFinLinOrdCat\nf : A ⟶ B\n⊢ Mono f ↔ Function.Injective ↑f",
"tactic": "refine' ⟨_, ConcreteCategory.mono_of_injective f⟩"
},
{
"state_after": "A B : NonemptyFinLinOrdCat\nf : A ⟶ B\na✝ : Mono f\n⊢ Function.Injective ↑f",
"state_before": "A B : NonemptyFinLinOrdCat\nf : A ⟶ B\n⊢ Mono f → Function.Injective ↑f",
"tactic": "intro"
},
{
"state_after": "A B : NonemptyFinLinOrdCat\nf : A ⟶ B\na✝ : Mono f\na₁ a₂ : ↑A\nh : ↑f a₁ = ↑f a₂\n⊢ a₁ = a₂",
"state_before": "A B : NonemptyFinLinOrdCat\nf : A ⟶ B\na✝ : Mono f\n⊢ Function.Injective ↑f",
"tactic": "intro a₁ a₂ h"
},
{
"state_after": "A B : NonemptyFinLinOrdCat\nf : A ⟶ B\na✝ : Mono f\na₁ a₂ : ↑A\nh : ↑f a₁ = ↑f a₂\nX : NonemptyFinLinOrdCat := of (ULift (Fin 1))\n⊢ a₁ = a₂",
"state_before": "A B : NonemptyFinLinOrdCat\nf : A ⟶ B\na✝ : Mono f\na₁ a₂ : ↑A\nh : ↑f a₁ = ↑f a₂\n⊢ a₁ = a₂",
"tactic": "let X := NonemptyFinLinOrdCat.of (ULift (Fin 1))"
},
{
"state_after": "A B : NonemptyFinLinOrdCat\nf : A ⟶ B\na✝ : Mono f\na₁ a₂ : ↑A\nh : ↑f a₁ = ↑f a₂\nX : NonemptyFinLinOrdCat := of (ULift (Fin 1))\ng₁ : X ⟶ A := { toFun := fun x => a₁, monotone' := (_ : ∀ (x x_1 : ↑X), x ≤ x_1 → (fun x => a₁) x ≤ (fun x => a₁) x) }\n⊢ a₁ = a₂",
"state_before": "A B : NonemptyFinLinOrdCat\nf : A ⟶ B\na✝ : Mono f\na₁ a₂ : ↑A\nh : ↑f a₁ = ↑f a₂\nX : NonemptyFinLinOrdCat := of (ULift (Fin 1))\n⊢ a₁ = a₂",
"tactic": "let g₁ : X ⟶ A := ⟨fun _ => a₁, fun _ _ _ => by rfl⟩"
},
{
"state_after": "A B : NonemptyFinLinOrdCat\nf : A ⟶ B\na✝ : Mono f\na₁ a₂ : ↑A\nh : ↑f a₁ = ↑f a₂\nX : NonemptyFinLinOrdCat := of (ULift (Fin 1))\ng₁ : X ⟶ A := { toFun := fun x => a₁, monotone' := (_ : ∀ (x x_1 : ↑X), x ≤ x_1 → (fun x => a₁) x ≤ (fun x => a₁) x) }\ng₂ : X ⟶ A := { toFun := fun x => a₂, monotone' := (_ : ∀ (x x_1 : ↑X), x ≤ x_1 → (fun x => a₂) x ≤ (fun x => a₂) x) }\n⊢ a₁ = a₂",
"state_before": "A B : NonemptyFinLinOrdCat\nf : A ⟶ B\na✝ : Mono f\na₁ a₂ : ↑A\nh : ↑f a₁ = ↑f a₂\nX : NonemptyFinLinOrdCat := of (ULift (Fin 1))\ng₁ : X ⟶ A := { toFun := fun x => a₁, monotone' := (_ : ∀ (x x_1 : ↑X), x ≤ x_1 → (fun x => a₁) x ≤ (fun x => a₁) x) }\n⊢ a₁ = a₂",
"tactic": "let g₂ : X ⟶ A := ⟨fun _ => a₂, fun _ _ _ => by rfl⟩"
},
{
"state_after": "A B : NonemptyFinLinOrdCat\nf : A ⟶ B\na✝ : Mono f\na₁ a₂ : ↑A\nh : ↑f a₁ = ↑f a₂\nX : NonemptyFinLinOrdCat := of (ULift (Fin 1))\ng₁ : X ⟶ A := { toFun := fun x => a₁, monotone' := (_ : ∀ (x x_1 : ↑X), x ≤ x_1 → (fun x => a₁) x ≤ (fun x => a₁) x) }\ng₂ : X ⟶ A := { toFun := fun x => a₂, monotone' := (_ : ∀ (x x_1 : ↑X), x ≤ x_1 → (fun x => a₂) x ≤ (fun x => a₂) x) }\n⊢ ↑g₁ { down := 0 } = ↑g₂ { down := 0 }",
"state_before": "A B : NonemptyFinLinOrdCat\nf : A ⟶ B\na✝ : Mono f\na₁ a₂ : ↑A\nh : ↑f a₁ = ↑f a₂\nX : NonemptyFinLinOrdCat := of (ULift (Fin 1))\ng₁ : X ⟶ A := { toFun := fun x => a₁, monotone' := (_ : ∀ (x x_1 : ↑X), x ≤ x_1 → (fun x => a₁) x ≤ (fun x => a₁) x) }\ng₂ : X ⟶ A := { toFun := fun x => a₂, monotone' := (_ : ∀ (x x_1 : ↑X), x ≤ x_1 → (fun x => a₂) x ≤ (fun x => a₂) x) }\n⊢ a₁ = a₂",
"tactic": "change g₁ (ULift.up (0 : Fin 1)) = g₂ (ULift.up (0 : Fin 1))"
},
{
"state_after": "A B : NonemptyFinLinOrdCat\nf : A ⟶ B\na✝ : Mono f\na₁ a₂ : ↑A\nh : ↑f a₁ = ↑f a₂\nX : NonemptyFinLinOrdCat := of (ULift (Fin 1))\ng₁ : X ⟶ A := { toFun := fun x => a₁, monotone' := (_ : ∀ (x x_1 : ↑X), x ≤ x_1 → (fun x => a₁) x ≤ (fun x => a₁) x) }\ng₂ : X ⟶ A := { toFun := fun x => a₂, monotone' := (_ : ∀ (x x_1 : ↑X), x ≤ x_1 → (fun x => a₂) x ≤ (fun x => a₂) x) }\neq : g₁ ≫ f = g₂ ≫ f\n⊢ ↑g₁ { down := 0 } = ↑g₂ { down := 0 }",
"state_before": "A B : NonemptyFinLinOrdCat\nf : A ⟶ B\na✝ : Mono f\na₁ a₂ : ↑A\nh : ↑f a₁ = ↑f a₂\nX : NonemptyFinLinOrdCat := of (ULift (Fin 1))\ng₁ : X ⟶ A := { toFun := fun x => a₁, monotone' := (_ : ∀ (x x_1 : ↑X), x ≤ x_1 → (fun x => a₁) x ≤ (fun x => a₁) x) }\ng₂ : X ⟶ A := { toFun := fun x => a₂, monotone' := (_ : ∀ (x x_1 : ↑X), x ≤ x_1 → (fun x => a₂) x ≤ (fun x => a₂) x) }\n⊢ ↑g₁ { down := 0 } = ↑g₂ { down := 0 }",
"tactic": "have eq : g₁ ≫ f = g₂ ≫ f := by\n ext\n exact h"
},
{
"state_after": "A B : NonemptyFinLinOrdCat\nf : A ⟶ B\na✝ : Mono f\na₁ a₂ : ↑A\nh : ↑f a₁ = ↑f a₂\nX : NonemptyFinLinOrdCat := of (ULift (Fin 1))\ng₁ : X ⟶ A := { toFun := fun x => a₁, monotone' := (_ : ∀ (x x_1 : ↑X), x ≤ x_1 → (fun x => a₁) x ≤ (fun x => a₁) x) }\ng₂ : X ⟶ A := { toFun := fun x => a₂, monotone' := (_ : ∀ (x x_1 : ↑X), x ≤ x_1 → (fun x => a₂) x ≤ (fun x => a₂) x) }\neq : g₁ = g₂\n⊢ ↑g₁ { down := 0 } = ↑g₂ { down := 0 }",
"state_before": "A B : NonemptyFinLinOrdCat\nf : A ⟶ B\na✝ : Mono f\na₁ a₂ : ↑A\nh : ↑f a₁ = ↑f a₂\nX : NonemptyFinLinOrdCat := of (ULift (Fin 1))\ng₁ : X ⟶ A := { toFun := fun x => a₁, monotone' := (_ : ∀ (x x_1 : ↑X), x ≤ x_1 → (fun x => a₁) x ≤ (fun x => a₁) x) }\ng₂ : X ⟶ A := { toFun := fun x => a₂, monotone' := (_ : ∀ (x x_1 : ↑X), x ≤ x_1 → (fun x => a₂) x ≤ (fun x => a₂) x) }\neq : g₁ ≫ f = g₂ ≫ f\n⊢ ↑g₁ { down := 0 } = ↑g₂ { down := 0 }",
"tactic": "rw [cancel_mono] at eq"
},
{
"state_after": "no goals",
"state_before": "A B : NonemptyFinLinOrdCat\nf : A ⟶ B\na✝ : Mono f\na₁ a₂ : ↑A\nh : ↑f a₁ = ↑f a₂\nX : NonemptyFinLinOrdCat := of (ULift (Fin 1))\ng₁ : X ⟶ A := { toFun := fun x => a₁, monotone' := (_ : ∀ (x x_1 : ↑X), x ≤ x_1 → (fun x => a₁) x ≤ (fun x => a₁) x) }\ng₂ : X ⟶ A := { toFun := fun x => a₂, monotone' := (_ : ∀ (x x_1 : ↑X), x ≤ x_1 → (fun x => a₂) x ≤ (fun x => a₂) x) }\neq : g₁ = g₂\n⊢ ↑g₁ { down := 0 } = ↑g₂ { down := 0 }",
"tactic": "rw [eq]"
},
{
"state_after": "no goals",
"state_before": "A B : NonemptyFinLinOrdCat\nf : A ⟶ B\na✝ : Mono f\na₁ a₂ : ↑A\nh : ↑f a₁ = ↑f a₂\nX : NonemptyFinLinOrdCat := of (ULift (Fin 1))\nx✝² x✝¹ : ↑X\nx✝ : x✝² ≤ x✝¹\n⊢ (fun x => a₁) x✝² ≤ (fun x => a₁) x✝¹",
"tactic": "rfl"
},
{
"state_after": "no goals",
"state_before": "A B : NonemptyFinLinOrdCat\nf : A ⟶ B\na✝ : Mono f\na₁ a₂ : ↑A\nh : ↑f a₁ = ↑f a₂\nX : NonemptyFinLinOrdCat := of (ULift (Fin 1))\ng₁ : X ⟶ A := { toFun := fun x => a₁, monotone' := (_ : ∀ (x x_1 : ↑X), x ≤ x_1 → (fun x => a₁) x ≤ (fun x => a₁) x) }\nx✝² x✝¹ : ↑X\nx✝ : x✝² ≤ x✝¹\n⊢ (fun x => a₂) x✝² ≤ (fun x => a₂) x✝¹",
"tactic": "rfl"
},
{
"state_after": "case w\nA B : NonemptyFinLinOrdCat\nf : A ⟶ B\na✝ : Mono f\na₁ a₂ : ↑A\nh : ↑f a₁ = ↑f a₂\nX : NonemptyFinLinOrdCat := of (ULift (Fin 1))\ng₁ : X ⟶ A := { toFun := fun x => a₁, monotone' := (_ : ∀ (x x_1 : ↑X), x ≤ x_1 → (fun x => a₁) x ≤ (fun x => a₁) x) }\ng₂ : X ⟶ A := { toFun := fun x => a₂, monotone' := (_ : ∀ (x x_1 : ↑X), x ≤ x_1 → (fun x => a₂) x ≤ (fun x => a₂) x) }\nx✝ : (forget NonemptyFinLinOrdCat).obj X\n⊢ (forget NonemptyFinLinOrdCat).map (g₁ ≫ f) x✝ = (forget NonemptyFinLinOrdCat).map (g₂ ≫ f) x✝",
"state_before": "A B : NonemptyFinLinOrdCat\nf : A ⟶ B\na✝ : Mono f\na₁ a₂ : ↑A\nh : ↑f a₁ = ↑f a₂\nX : NonemptyFinLinOrdCat := of (ULift (Fin 1))\ng₁ : X ⟶ A := { toFun := fun x => a₁, monotone' := (_ : ∀ (x x_1 : ↑X), x ≤ x_1 → (fun x => a₁) x ≤ (fun x => a₁) x) }\ng₂ : X ⟶ A := { toFun := fun x => a₂, monotone' := (_ : ∀ (x x_1 : ↑X), x ≤ x_1 → (fun x => a₂) x ≤ (fun x => a₂) x) }\n⊢ g₁ ≫ f = g₂ ≫ f",
"tactic": "ext"
},
{
"state_after": "no goals",
"state_before": "case w\nA B : NonemptyFinLinOrdCat\nf : A ⟶ B\na✝ : Mono f\na₁ a₂ : ↑A\nh : ↑f a₁ = ↑f a₂\nX : NonemptyFinLinOrdCat := of (ULift (Fin 1))\ng₁ : X ⟶ A := { toFun := fun x => a₁, monotone' := (_ : ∀ (x x_1 : ↑X), x ≤ x_1 → (fun x => a₁) x ≤ (fun x => a₁) x) }\ng₂ : X ⟶ A := { toFun := fun x => a₂, monotone' := (_ : ∀ (x x_1 : ↑X), x ≤ x_1 → (fun x => a₂) x ≤ (fun x => a₂) x) }\nx✝ : (forget NonemptyFinLinOrdCat).obj X\n⊢ (forget NonemptyFinLinOrdCat).map (g₁ ≫ f) x✝ = (forget NonemptyFinLinOrdCat).map (g₂ ≫ f) x✝",
"tactic": "exact h"
}
] |
[
162,
10
] |
5a919533f110b7d76410134a237ee374f24eaaad
|
https://github.com/leanprover-community/mathlib4
|
[
149,
1
] |
Mathlib/Control/Bitraversable/Lemmas.lean
|
Bitraversable.tfst_tsnd
|
[
{
"state_after": "t : Type u → Type u → Type u\ninst✝⁵ : Bitraversable t\nβ : Type u\nF G : Type u → Type u\ninst✝⁴ : Applicative F\ninst✝³ : Applicative G\ninst✝² : IsLawfulBitraversable t\ninst✝¹ : LawfulApplicative F\ninst✝ : LawfulApplicative G\nα₀ α₁ β₀ β₁ : Type u\nf : α₀ → F α₁\nf' : β₀ → G β₁\nx : t α₀ β₀\n⊢ bitraverse (Comp.mk ∘ map f ∘ pure) (Comp.mk ∘ map pure ∘ f') x =\n bitraverse (Comp.mk ∘ pure ∘ f) (Comp.mk ∘ map pure ∘ f') x",
"state_before": "t : Type u → Type u → Type u\ninst✝⁵ : Bitraversable t\nβ : Type u\nF G : Type u → Type u\ninst✝⁴ : Applicative F\ninst✝³ : Applicative G\ninst✝² : IsLawfulBitraversable t\ninst✝¹ : LawfulApplicative F\ninst✝ : LawfulApplicative G\nα₀ α₁ β₀ β₁ : Type u\nf : α₀ → F α₁\nf' : β₀ → G β₁\nx : t α₀ β₀\n⊢ Comp.mk (tfst f <$> tsnd f' x) = bitraverse (Comp.mk ∘ pure ∘ f) (Comp.mk ∘ map pure ∘ f') x",
"tactic": "rw [← comp_bitraverse]"
},
{
"state_after": "no goals",
"state_before": "t : Type u → Type u → Type u\ninst✝⁵ : Bitraversable t\nβ : Type u\nF G : Type u → Type u\ninst✝⁴ : Applicative F\ninst✝³ : Applicative G\ninst✝² : IsLawfulBitraversable t\ninst✝¹ : LawfulApplicative F\ninst✝ : LawfulApplicative G\nα₀ α₁ β₀ β₁ : Type u\nf : α₀ → F α₁\nf' : β₀ → G β₁\nx : t α₀ β₀\n⊢ bitraverse (Comp.mk ∘ map f ∘ pure) (Comp.mk ∘ map pure ∘ f') x =\n bitraverse (Comp.mk ∘ pure ∘ f) (Comp.mk ∘ map pure ∘ f') x",
"tactic": "simp only [Function.comp, map_pure]"
}
] |
[
89,
38
] |
5a919533f110b7d76410134a237ee374f24eaaad
|
https://github.com/leanprover-community/mathlib4
|
[
85,
1
] |
Mathlib/Data/Finset/Pointwise.lean
|
Finset.univ_pow
|
[
{
"state_after": "no goals",
"state_before": "F : Type ?u.474133\nα : Type u_1\nβ : Type ?u.474139\nγ : Type ?u.474142\ninst✝³ : DecidableEq α\ninst✝² : DecidableEq β\ninst✝¹ : Monoid α\ns t : Finset α\na : α\nm n : ℕ\ninst✝ : Fintype α\nhn : n ≠ 0\n⊢ ↑(univ ^ n) = ↑univ",
"tactic": "rw [coe_pow, coe_univ, Set.univ_pow hn]"
}
] |
[
954,
62
] |
5a919533f110b7d76410134a237ee374f24eaaad
|
https://github.com/leanprover-community/mathlib4
|
[
953,
1
] |
Mathlib/RingTheory/Localization/FractionRing.lean
|
IsFractionRing.to_map_ne_zero_of_mem_nonZeroDivisors
|
[] |
[
105,
67
] |
5a919533f110b7d76410134a237ee374f24eaaad
|
https://github.com/leanprover-community/mathlib4
|
[
103,
11
] |
Mathlib/Order/PropInstances.lean
|
Prop.bot_eq_false
|
[] |
[
45,
6
] |
5a919533f110b7d76410134a237ee374f24eaaad
|
https://github.com/leanprover-community/mathlib4
|
[
44,
1
] |
Mathlib/Data/Matrix/Basic.lean
|
Matrix.conjTranspose_sub
|
[
{
"state_after": "no goals",
"state_before": "l : Type ?u.967201\nm : Type u_1\nn : Type u_2\no : Type ?u.967210\nm' : o → Type ?u.967215\nn' : o → Type ?u.967220\nR : Type ?u.967223\nS : Type ?u.967226\nα : Type v\nβ : Type w\nγ : Type ?u.967233\ninst✝¹ : AddGroup α\ninst✝ : StarAddMonoid α\nM N : Matrix m n α\n⊢ ∀ (i : n) (j : m), (M - N)ᴴ i j = (Mᴴ - Nᴴ) i j",
"tactic": "simp"
}
] |
[
2157,
24
] |
5a919533f110b7d76410134a237ee374f24eaaad
|
https://github.com/leanprover-community/mathlib4
|
[
2155,
1
] |
Mathlib/Data/Complex/Exponential.lean
|
Complex.sinh_add_cosh
|
[
{
"state_after": "no goals",
"state_before": "x y : ℂ\n⊢ sinh x + cosh x = exp x",
"tactic": "rw [add_comm, cosh_add_sinh]"
}
] |
[
732,
83
] |
5a919533f110b7d76410134a237ee374f24eaaad
|
https://github.com/leanprover-community/mathlib4
|
[
732,
1
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.